ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು: ಆಬ್ಜೆಕ್ಟ್ ಪರಿವರ್ತನೆ ಮತ್ತು ಪ್ರಾಪರ್ಟಿ ಮಾರ್ಪಾಡಿನಲ್ಲಿ ಪಾಂಡಿತ್ಯ

ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ನಿರಂತರವಾಗಿ ವಿಕಸಿಸುತ್ತಿರುವ ಭೂದೃಶ್ಯದಲ್ಲಿ, ನಿರ್ವಹಿಸಬಹುದಾದ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ದೃಢವಾದ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ಗಳು ಪ್ರಮುಖವಾಗಿವೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್, ಅದರ ಶಕ್ತಿಶಾಲಿ ಟೈಪ್ ಇನ್‌ಫೆರೆನ್ಸ್ ಮತ್ತು ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ, ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅನಿವಾರ್ಯ ಸಾಧನವಾಗಿ ಮಾರ್ಪಟ್ಟಿದೆ. ಅದರ ಅತ್ಯಂತ ಪ್ರಬಲ ಸಾಮರ್ಥ್ಯಗಳಲ್ಲಿ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ಸೇರಿವೆ, ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್‌ಗಳನ್ನು ಹೊಸದಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ನಮಗೆ ಅನುಮತಿಸುವ ಅತ್ಯಾಧುನಿಕ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳ ಜಗತ್ತಿಗೆ ಆಳವಾಗಿ ಧುಮುಕುತ್ತದೆ, ಅವುಗಳ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳು, ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್ ಪರಿವರ್ತನೆಗಳು ಮತ್ತು ಪ್ರಾಪರ್ಟಿ ಮಾರ್ಪಾಡುಗಳನ್ನು ಸೊಗಸಾಗಿ ನಿರ್ವಹಿಸಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಹೇಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತವೆ ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳ ಮೂಲ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ನ ಹೃದಯಭಾಗದಲ್ಲಿ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಮೂಲಕ ಹೊಸ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. ಇದನ್ನು ಟೈಪ್‌ಗಳಿಗಾಗಿ ಲೂಪ್ ಎಂದು ಪರಿಗಣಿಸಿ. ಮೂಲ ಟೈಪ್‌ನಲ್ಲಿರುವ ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿಗಾಗಿ, ನೀವು ಅದರ ಕೀ, ಅದರ ಮೌಲ್ಯ ಅಥವಾ ಎರಡಕ್ಕೂ ಪರಿವರ್ತನೆಯನ್ನು ಅನ್ವಯಿಸಬಹುದು. ಇದು ಹಸ್ತಚಾಲಿತ ಪುನರಾವರ್ತನೆ ಇಲ್ಲದೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳ ಆಧಾರದ ಮೇಲೆ ಹೊಸ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ರಚಿಸಲು ವ್ಯಾಪಕವಾದ ಸಾಧ್ಯತೆಗಳನ್ನು ತೆರೆಯುತ್ತದೆ.

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಾಗಿ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್ { [P in K]: T } ರಚನೆಯನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದರಲ್ಲಿ:

• P: ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತಿರುವ ಪ್ರಾಪರ್ಟಿಯ ಹೆಸರನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• in K: ಇದು ನಿರ್ಣಾಯಕ ಭಾಗವಾಗಿದೆ, P ಟೈಪ್ K (ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳ ಯೂನಿಯನ್, ಅಥವಾ ಕೀಯಾಫ್ ಟೈಪ್) ನಿಂದ ಪ್ರತಿ ಕೀಲಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.
• T: ಹೊಸ ಟೈಪ್‌ನಲ್ಲಿ ಪ್ರಾಪರ್ಟಿ P ಗಾಗಿ ಮೌಲ್ಯದ ಟೈಪ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.

ಸರಳವಾದ ವಿವರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ನಿಮ್ಮಲ್ಲಿ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಆಬ್ಜೆಕ್ಟ್ ಇದೆ ಎಂದು ಊಹಿಸಿ, ಮತ್ತು ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಐಚ್ಛಿಕವಾಗಿರುವ ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸಲು ನೀವು ಬಯಸುತ್ತೀರಿ. ಇದು ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ಅಥವಾ ಭಾಗಶಃ ನವೀಕರಣಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ.

ಉದಾಹರಣೆ 1: ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕವಾಗಿಸುವುದು

ಈ ಮೂಲ ಟೈಪ್ ಅನ್ನು ಪರಿಗಣಿಸಿ:

            
type User = {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
};

            

              
                Copy
              
            
          

ನಾವು ಹೊಸ ಟೈಪ್, OptionalUser ಅನ್ನು ರಚಿಸಬಹುದು, ಇದರಲ್ಲಿ ಈ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಐಚ್ಛಿಕವಾಗಿರುತ್ತವೆ:

            
type OptionalUser = {
  [P in keyof User]?: User[P];
};

            

              
                Copy
              
            
          

ಇದನ್ನು ವಿಭಜಿಸೋಣ:

• keyof User: ಇದು User ಟೈಪ್‌ನ ಕೀಗಳ ಯೂನಿಯನ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, 'id' | 'name' | 'email' | 'isActive').
• P in keyof User: ಇದು ಯೂನಿಯನ್‌ನಲ್ಲಿನ ಪ್ರತಿ ಕೀ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
• ?: ಇದು ಪ್ರಾಪರ್ಟಿಯನ್ನು ಐಚ್ಛಿಕವಾಗಿಸುವ ಮಾಡಿಫೈಯರ್ ಆಗಿದೆ.
• User[P]: ಇದು ಒಂದು ಲುಕಪ್ ಟೈಪ್ ಆಗಿದೆ. ಪ್ರತಿ ಕೀ P ಗಾಗಿ, ಇದು ಮೂಲ User ಟೈಪ್‌ನಿಂದ ಅನುಗುಣವಾದ ಮೌಲ್ಯದ ಟೈಪ್ ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ.

ಪರಿಣಾಮವಾಗಿ OptionalUser ಟೈಪ್ ಹೀಗೆ ಕಾಣುತ್ತದೆ:

            
{
  id?: number;
  name?: string;
  email?: string;
  isActive?: boolean;
}

            

              
                Copy
              
            
          

ಇದು ನಂಬಲಾಗದಷ್ಟು ಶಕ್ತಿಶಾಲಿಯಾಗಿದೆ. ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿಯನ್ನು ? ನೊಂದಿಗೆ ಹಸ್ತಚಾಲಿತವಾಗಿ ಮರು-ವ್ಯಾಖ್ಯಾನಿಸುವ ಬದಲು, ನಾವು ಟೈಪ್ ಅನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸಿದ್ದೇವೆ. ಈ ತತ್ವವನ್ನು ಇತರ ಹಲವು ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸಲು ವಿಸ್ತರಿಸಬಹುದು.

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳಲ್ಲಿನ ಸಾಮಾನ್ಯ ಪ್ರಾಪರ್ಟಿ ಮಾಡಿಫೈಯರ್‌ಗಳು

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ಕೇವಲ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕವಾಗಿಸುವುದಕ್ಕೆ ಮಾತ್ರ ಸೀಮಿತವಾಗಿಲ್ಲ. ಅವು ನಿಮಗೆ ಪರಿಣಾಮವಾಗಿ ಬರುವ ಟೈಪ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ವಿವಿಧ ಮಾಡಿಫೈಯರ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತವೆ. ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದವುಗಳು ಸೇರಿವೆ:

• ಐಚ್ಛಿಕತೆ (Optionality): ? ಮಾಡಿಫೈಯರ್ ಅನ್ನು ಸೇರಿಸುವುದು ಅಥವಾ ತೆಗೆದುಹಾಕುವುದು.
• ರೀಡ್‌ಓನ್ಲಿ (Readonly): readonly ಮಾಡಿಫೈಯರ್ ಅನ್ನು ಸೇರಿಸುವುದು ಅಥವಾ ತೆಗೆದುಹಾಕುವುದು.
• ನಲ್/ನಾನ್-ನಲ್ (Nullability/Non-nullability): | null ಅಥವಾ | undefined ಅನ್ನು ಸೇರಿಸುವುದು ಅಥವಾ ತೆಗೆದುಹಾಕುವುದು.

ಉದಾಹರಣೆ 2: ಟೈಪ್‌ನ ರೀಡ್‌ಓನ್ಲಿ ಆವೃತ್ತಿಯನ್ನು ರಚಿಸುವುದು

ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕವಾಗಿಸುವಂತೆಯೇ, ನಾವು ReadonlyUser ಟೈಪ್ ಅನ್ನು ರಚಿಸಬಹುದು:

            
type ReadonlyUser = {
  readonly [P in keyof User]: User[P];
};

            

              
                Copy
              
            
          

ಇದು ಇದನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

            
{
  readonly id: number;
  readonly name: string;
  readonly email: string;
  readonly isActive: boolean;
}

            

              
                Copy
              
            
          

ಒಮ್ಮೆ ರಚಿಸಿದ ಕೆಲವು ಡೇಟಾ ರಚನೆಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ, ಇದು ದೃಢವಾದ, ಊಹಿಸಬಹುದಾದ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಒಂದು ಮೂಲಭೂತ ತತ್ವವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಸಮಕಾಲೀನ ಪರಿಸರದಲ್ಲಿ ಅಥವಾ ಅನೇಕ ಅಂತರರಾಷ್ಟ್ರೀಯ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳು ಅಳವಡಿಸಿಕೊಂಡ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಗಳಲ್ಲಿ ಜನಪ್ರಿಯವಾಗಿರುವ ಬದಲಾಯಿಸಲಾಗದ ಡೇಟಾ ಮಾದರಿಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ.

ಉದಾಹರಣೆ 3: ಐಚ್ಛಿಕತೆ ಮತ್ತು ರೀಡ್‌ಓನ್ಲಿಯನ್ನು ಸಂಯೋಜಿಸುವುದು

ನಾವು ಮಾಡಿಫೈಯರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರಾಪರ್ಟಿಗಳು ಐಚ್ಛಿಕ ಮತ್ತು ರೀಡ್‌ಓನ್ಲಿ ಎರಡೂ ಆಗಿರುವ ಟೈಪ್:

            
type OptionalReadonlyUser = {
  readonly [P in keyof User]?: User[P];
};

            

              
                Copy
              
            
          

ಇದು ಹೀಗೆ ಪರಿಣಮಿಸುತ್ತದೆ:

            
{
  readonly id?: number;
  readonly name?: string;
  readonly email?: string;
  readonly isActive?: boolean;
}

            

              
                Copy
              
            
          

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಮಾಡಿಫೈಯರ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು

ಒಂದು ಮಾಡಿಫೈಯರ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು ನೀವು ಬಯಸಿದರೆ ಏನು? ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳಲ್ಲಿ -? ಮತ್ತು -readonly ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು ಅಥವಾ ಸಂಕೀರ್ಣ ಟೈಪ್ ಸಂಯೋಜನೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಶಕ್ತಿಶಾಲಿಯಾಗಿದೆ.

ನಿಮ್ಮಲ್ಲಿ Partial<T> ಟೈಪ್ ಇದೆ ಎಂದು ಹೇಳೋಣ (ಇದು ಅಂತರ್ನಿರ್ಮಿತವಾಗಿದೆ ಮತ್ತು ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕವಾಗಿಸುತ್ತದೆ), ಮತ್ತು ನೀವು Partial<T> ನಂತೆಯೇ ಇರುವ ಆದರೆ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮತ್ತೆ ಕಡ್ಡಾಯಗೊಳಿಸಿದ ಟೈಪ್ ಅನ್ನು ರಚಿಸಲು ಬಯಸುತ್ತೀರಿ.

            
type Mandatory<T> = {
  -?: T extends object ? T[keyof T] : never;
};

type FullyPopulatedUser = Mandatory<Partial<User>>;

            

              
                Copy
              
            
          

ಇದು ಅಸಹಜವೆಂದು ತೋರುತ್ತದೆ. ಅದನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ:

Partial<User> ನಮ್ಮ OptionalUser ಗೆ ಸಮನಾಗಿದೆ. ಈಗ, ನಾವು ಅದರ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕಡ್ಡಾಯಗೊಳಿಸಲು ಬಯಸುತ್ತೇವೆ. -? ಸಿಂಟ್ಯಾಕ್ಸ್ ಐಚ್ಛಿಕ ಮಾಡಿಫೈಯರ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.

ಇದನ್ನು ಸಾಧಿಸಲು ಹೆಚ್ಚು ನೇರವಾದ ಮಾರ್ಗವೆಂದರೆ, ಮೊದಲು Partial ಮೇಲೆ ಅವಲಂಬಿತವಾಗದೆ, ಮೂಲ ಟೈಪ್ ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಅದು ಐಚ್ಛಿಕವಾಗಿದ್ದರೆ ಅದನ್ನು ಕಡ್ಡಾಯವಾಗಿಸುವುದು:

            
type MakeMandatory<T> = {
  -?: T;
};

type MandatoryUser = MakeMandatory<OptionalUser>;

            

              
                Copy
              
            
          

ಇದು OptionalUser ಅನ್ನು ಮೂಲ User ಟೈಪ್ ರಚನೆಗೆ (ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಪ್ರಸ್ತುತ ಮತ್ತು ಅಗತ್ಯ) ಸರಿಯಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಅಂತೆಯೇ, readonly ಮಾಡಿಫೈಯರ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು:

            
type Mutable<T> = {
  -readonly [P in keyof T]: T[P];
};

type MutableUser = Mutable<ReadonlyUser>;

            

              
                Copy
              
            
          

MutableUser ಮೂಲ User ಟೈಪ್‌ಗೆ ಸಮನಾಗಿರುತ್ತದೆ, ಆದರೆ ಅದರ ಪ್ರಾಪರ್ಟಿಗಳು ರೀಡ್‌ಓನ್ಲಿ ಆಗಿರುವುದಿಲ್ಲ.

ನಲ್ಲಬಿಲಿಟಿ ಮತ್ತು ಅನ್‌ಡಿಫೈನೆಬಿಲಿಟಿ

ನೀವು ನಲ್ಲಬಿಲಿಟಿಯನ್ನು ಸಹ ನಿಯಂತ್ರಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಖಂಡಿತವಾಗಿ ನಾನ್-ನಲ್ಲಬಲ್ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು:

            
type NonNullableValues<T> = {
  [P in keyof T]-?: NonNullable<T[P]>;
};

interface MaybeNull {
  name: string | null;
  age: number | undefined;
}

type DefiniteValues = NonNullableValues<MaybeNull>;
// type DefiniteValues = {
//   name: string;
//   age: number;
// }

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, -? ಪ್ರಾಪರ್ಟಿಗಳು ಐಚ್ಛಿಕವಾಗಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಮತ್ತು NonNullable<T[P]> ಮೌಲ್ಯದ ಟೈಪ್‌ನಿಂದ null ಮತ್ತು undefined ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.

ಪ್ರಾಪರ್ಟಿ ಕೀಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ನಂಬಲಾಗದಷ್ಟು ಬಹುಮುಖವಾಗಿವೆ, ಮತ್ತು ಅವು ಕೇವಲ ಮೌಲ್ಯಗಳನ್ನು ಅಥವಾ ಮಾಡಿಫೈಯರ್‌ಗಳನ್ನು ಮಾರ್ಪಡಿಸುವುದಕ್ಕೆ ಮಾತ್ರ ಸೀಮಿತವಾಗಿಲ್ಲ. ನೀವು ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್‌ನ ಕೀಗಳನ್ನು ಸಹ ಪರಿವರ್ತಿಸಬಹುದು. ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ನಿಜವಾಗಿಯೂ ಇಲ್ಲಿ ಹೊಳೆಯುತ್ತವೆ.

ಉದಾಹರಣೆ 4: ಪ್ರಾಪರ್ಟಿ ಕೀಗಳಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯ ಸೇರಿಸುವುದು

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ನಿರ್ದಿಷ್ಟ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಹೊಂದಿರುವ ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸಲು ನೀವು ಬಯಸುತ್ತೀರಿ ಎಂದು ಊಹಿಸಿ. ಇದು ನೇಮ್‌ಸ್ಪೇಸಿಂಗ್‌ಗಾಗಿ ಅಥವಾ ಡೇಟಾ ರಚನೆಗಳ ವ್ಯತ್ಯಾಸಗಳನ್ನು ರಚಿಸಲು ಉಪಯುಕ್ತವಾಗಬಹುದು.

            
type Prefixed<T, Prefix extends string> = {
  [P in keyof T as `${Prefix}${Capitalize<string & P>}`]: T[P];
};

type OriginalConfig = {
  timeout: number;
  retries: number;
};

type PrefixedConfig = Prefixed<OriginalConfig, 'app'>;
// type PrefixedConfig = {
//   appTimeout: number;
//   appRetries: number;
// }

            

              
                Copy
              
            
          

ಕೀ ಪರಿವರ್ತನೆಯನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ:

• P in keyof T: ಇನ್ನೂ ಮೂಲ ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.
• as `${Prefix}${Capitalize<string & P>}`: ಇದು ಕೀ ಮರುಮ್ಯಾಪಿಂಗ್ ಷರತ್ತು.
• `${Prefix}${...}`: ಇದು ಒದಗಿಸಿದ Prefix ಅನ್ನು ಪರಿವರ್ತಿತ ಪ್ರಾಪರ್ಟಿ ಹೆಸರಿನೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಹೊಸ ಕೀ ಹೆಸರನ್ನು ನಿರ್ಮಿಸಲು ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.
• Capitalize<string & P>: ಪ್ರಾಪರ್ಟಿ ಹೆಸರು P ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಕ್ಯಾಪಿಟಲೈಸ್ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಸಾಮಾನ್ಯ ಮಾದರಿಯಾಗಿದೆ. P ಅನ್ನು string ನೊಂದಿಗೆ ಛೇದಿಸಲು ನಾವು string & P ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು ಸ್ಟ್ರಿಂಗ್ ಟೈಪ್ ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು Capitalize ಗೆ ಅಗತ್ಯವಾಗಿದೆ.

ಈ ಉದಾಹರಣೆಯು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಾಪರ್ಟಿಗಳ ಆಧಾರದ ಮೇಲೆ ನೀವು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮರುಹೆಸರಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಇದು ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿಭಿನ್ನ ಲೇಯರ್‌ಗಳಲ್ಲಿ ಸ್ಥಿರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯಗಳನ್ನು ಹೊಂದಿರುವ ಬಾಹ್ಯ ಸಿಸ್ಟಮ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವಾಗ ಪ್ರಬಲ ತಂತ್ರವಾಗಿದೆ.

ಉದಾಹರಣೆ 5: ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು

ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮಾತ್ರ ನೀವು ಸೇರಿಸಲು ಬಯಸಿದರೆ ಏನು? ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳನ್ನು ಕಂಡಿಷನಲ್ ಟೈಪ್‌ಗಳು ಮತ್ತು ಕೀ ಮರುಮ್ಯಾಪಿಂಗ್‌ಗಾಗಿ as ಷರತ್ತಿನೊಂದಿಗೆ ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಇದನ್ನು ಸಾಧಿಸಬಹುದು, ಹೆಚ್ಚಾಗಿ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು.

            
type OnlyStrings<T> = {
  [P in keyof T as T[P] extends string ? P : never]: T[P];
};

interface MixedData {
  name: string;
  age: number;
  city: string;
  isActive: boolean;
}

type StringOnlyData = OnlyStrings<MixedData>;
// type StringOnlyData = {
//   name: string;
//   city: string;
// }

            

              
                Copy
              
            
          

ಈ ಸಂದರ್ಭದಲ್ಲಿ:

• T[P] extends string ? P : never: ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿ P ಗಾಗಿ, ಅದರ ಮೌಲ್ಯದ ಟೈಪ್ (T[P]) string ಗೆ ನಿಯೋಜಿಸಬಹುದೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ.
• ಅದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದ್ದರೆ, ಕೀ P ಅನ್ನು ಇಟ್ಟುಕೊಳ್ಳಲಾಗುತ್ತದೆ.
• ಅದು ಸ್ಟ್ರಿಂಗ್ ಅಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು never ಗೆ ಮ್ಯಾಪ್ ಮಾಡಲಾಗುತ್ತದೆ. ಕೀಯನ್ನು never ಗೆ ಮ್ಯಾಪ್ ಮಾಡಿದಾಗ, ಅದನ್ನು ಪರಿಣಾಮವಾಗಿ ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್‌ನಿಂದ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

ಈ ತಂತ್ರವು ವಿಶಾಲವಾದ ಟೈಪ್‌ಗಳಿಂದ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾದ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸಲು ಅಮೂಲ್ಯವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ನ ಕಾನ್ಫಿಗರೇಶನ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಮಾತ್ರ ಹೊರತೆಗೆಯುವುದು ಅಥವಾ ಡೇಟಾ ಕ್ಷೇತ್ರಗಳನ್ನು ಅವುಗಳ ಸ್ವರೂಪದಿಂದ ಪ್ರತ್ಯೇಕಿಸುವುದು.

ಉದಾಹರಣೆ 6: ಕೀಗಳನ್ನು ವಿಭಿನ್ನ ಆಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು

ನೀವು ಕೀಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ರೀತಿಯ ಕೀಗಳಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಸ್ಟ್ರಿಂಗ್ ಕೀಗಳನ್ನು ಸಂಖ್ಯೆಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು, ಅಥವಾ ಪ್ರತಿಯಾಗಿ, ಆದರೂ ಇದು ನೇರ ಆಬ್ಜೆಕ್ಟ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗೆ ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದೆ ಮತ್ತು ಹೆಚ್ಚು ಸುಧಾರಿತ ಟೈಪ್-ಲೆವೆಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಆಗಿದೆ.

ಸ್ಟ್ರಿಂಗ್ ಕೀಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್‌ಗಳ ಯೂನಿಯನ್ ಆಗಿ ಪರಿವರ್ತಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ, ಮತ್ತು ನಂತರ ಅದನ್ನು ಹೊಸ ಟೈಪ್‌ಗೆ ಆಧಾರವಾಗಿ ಬಳಸುವುದು. ಈ ನಿರ್ದಿಷ್ಟ ರೀತಿಯಲ್ಲಿ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ನಲ್ಲಿ ಆಬ್ಜೆಕ್ಟ್‌ನ ಕೀಗಳನ್ನು ನೇರವಾಗಿ ಪರಿವರ್ತಿಸದಿದ್ದರೂ, ಇದು ಕೀಗಳನ್ನು ಹೇಗೆ ಮಾರ್ಪಡಿಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

ಹೆಚ್ಚು ನೇರವಾದ ಕೀ ಪರಿವರ್ತನೆ ಉದಾಹರಣೆಯು ಕೀಗಳನ್ನು ಅವುಗಳ ಅಪ್ಪರ್‌ಕೇಸ್ ಆವೃತ್ತಿಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುವುದಾಗಿರಬಹುದು:

            
type UppercaseKeys<T> = {
  [P in keyof T as Uppercase<string & P>]: T[P];
};

type LowercaseData = {
  firstName: string;
  lastName: string;
};

type UppercaseData = UppercaseKeys<LowercaseData>;
// type UppercaseData = {
//   FIRSTNAME: string;
//   LASTNAME: string;
// }

            

              
                Copy
              
            
          

ಪ್ರತಿ ಕೀ P ಅನ್ನು ಅದರ ಅಪ್ಪರ್‌ಕೇಸ್ ಸಮಾನಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಇದು as ಷರತ್ತನ್ನು ಬಳಸುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಿಕೆಗಳು ಮತ್ತು ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳು

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ಕೇವಲ ಸೈದ್ಧಾಂತಿಕ ರಚನೆಗಳಲ್ಲ; ಅವು ವಿವಿಧ ಅಭಿವೃದ್ಧಿ ಡೊಮೇನ್‌ಗಳಲ್ಲಿ ಗಮನಾರ್ಹ ಪ್ರಾಯೋಗಿಕ ಪರಿಣಾಮಗಳನ್ನು ಹೊಂದಿವೆ. ಅವು ಅಮೂಲ್ಯವಾಗಿರುವ ಕೆಲವು ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶಗಳು ಇಲ್ಲಿವೆ:

1. ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು

ಅನೇಕ ಸಾಮಾನ್ಯ ಟೈಪ್ ಪರಿವರ್ತನೆಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳಲ್ಲಿ ಆವರಿಸಬಹುದು. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿ ಈಗಾಗಲೇ Partial<T>, Readonly<T>, Record<K, T>, ಮತ್ತು Pick<T, K> ನಂತಹ ಅತ್ಯುತ್ತಮ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಿಮ್ಮ ಅಭಿವೃದ್ಧಿ ಕಾರ್ಯಪ್ರವಾಹವನ್ನು ಸುಗಮಗೊಳಿಸಲು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮದೇ ಆದ ಕಸ್ಟಮ್ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ, ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮೂಲ ಮೌಲ್ಯವನ್ನು ಸ್ವೀಕರಿಸಿ ಹೊಸ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಕಾರ್ಯಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುವ ಟೈಪ್:

            
type Mappers<T> = {
  [P in keyof T]: (value: T[P]) => T[P];
};

interface ProductInfo {
  name: string;
  price: number;
}

type ProductMappers = Mappers<ProductInfo>;
// type ProductMappers = {
//   name: (value: string) => string;
//   price: (value: number) => number;
// }

            

              
                Copy
              
            
          

2. ಡೈನಾಮಿಕ್ ಫಾರ್ಮ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಮತ್ತು ವ್ಯಾಲಿಡೇಷನ್

ಫ್ರಂಟ್‌ಎಂಡ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ರಿಯಾಕ್ಟ್ ಅಥವಾ ಆಂಗ್ಯುಲರ್‌ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ (ಇಲ್ಲಿನ ಉದಾಹರಣೆಗಳು ಶುದ್ಧ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿದ್ದರೂ), ಫಾರ್ಮ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ವ್ಯಾಲಿಡೇಷನ್ ಸ್ಥಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ. ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ಪ್ರತಿ ಫಾರ್ಮ್ ಕ್ಷೇತ್ರದ ವ್ಯಾಲಿಡೇಷನ್ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

'pristine', 'touched', 'valid', ಅಥವಾ 'invalid' ಆಗಿರುವ ಕ್ಷೇತ್ರಗಳೊಂದಿಗೆ ಫಾರ್ಮ್ ಅನ್ನು ಪರಿಗಣಿಸಿ.

            
type FormFieldState = 'pristine' | 'touched' | 'dirty' | 'valid' | 'invalid';

type FormState<T> = {
  [P in keyof T]: FormFieldState;
};

interface UserForm {
  username: string;
  email: string;
  password: string;
}

type UserFormState = FormState<UserForm>;
// type UserFormState = {
//   username: FormFieldState;
//   email: FormFieldState;
//   password: FormFieldState;
// }

            

              
                Copy
              
            
          

ಇದು ನಿಮ್ಮ ಫಾರ್ಮ್‌ನ ಡೇಟಾ ರಚನೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವ ಟೈಪ್ ಅನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಬದಲಾಗಿ ಪ್ರತಿ ಕ್ಷೇತ್ರದ ಸ್ಥಿತಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ, ನಿಮ್ಮ ಫಾರ್ಮ್ ನಿರ್ವಹಣಾ ತರ್ಕಕ್ಕಾಗಿ ಸ್ಥಿರತೆ ಮತ್ತು ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ವೈವಿಧ್ಯಮಯ UI/UX ಅವಶ್ಯಕತೆಗಳು ಸಂಕೀರ್ಣ ಫಾರ್ಮ್ ಸ್ಥಿತಿಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದಾದ ಅಂತರರಾಷ್ಟ್ರೀಯ ಯೋಜನೆಗಳಿಗೆ ಇದು ವಿಶೇಷವಾಗಿ ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ.

3. API ಪ್ರತಿಕ್ರಿಯೆ ಪರಿವರ್ತನೆ

API ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ, ಪ್ರತಿಕ್ರಿಯೆ ಡೇಟಾ ಯಾವಾಗಲೂ ನಿಮ್ಮ ಆಂತರಿಕ ಡೊಮೇನ್ ಮಾದರಿಗಳಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಹೊಂದಿಕೆಯಾಗದಿರಬಹುದು. ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಬಯಸಿದ ಆಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಕೀಗಳಿಗಾಗಿ snake_case ಅನ್ನು ಬಳಸುವ API ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಊಹಿಸಿ, ಆದರೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ camelCase ಅನ್ನು ಆದ್ಯತೆ ನೀಡುತ್ತದೆ:

            
// Assume this is the incoming API response type
type ApiUserData = {
  user_id: number;
  first_name: string;
  last_name: string;
};

// Helper to convert snake_case to camelCase for keys
type ToCamelCase<S extends string>: string = S extends `${infer T}_${infer U}`
  ? `${T}${Capitalize<U>}`
  : S;

type CamelCasedKeys<T> = {
  [P in keyof T as ToCamelCase<string & P>]: T[P];
};

type AppUserData = CamelCasedKeys<ApiUserData>;
// type AppUserData = {
//   userId: number;
//   firstName: string;
//   lastName: string;
// }

            

              
                Copy
              
            
          

ಇದು ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಾಗಿ ರಿಕರ್ಸಿವ್ ಕಂಡಿಷನಲ್ ಟೈಪ್ ಅನ್ನು ಬಳಸುವ ಹೆಚ್ಚು ಸುಧಾರಿತ ಉದಾಹರಣೆಯಾಗಿದೆ. ಪ್ರಮುಖ ಟೇಕ್‌ಅವೇ ಏನೆಂದರೆ, ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು, ಇತರ ಸುಧಾರಿತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ, ಸಂಕೀರ್ಣ ಡೇಟಾ ಪರಿವರ್ತನೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು, ಅಭಿವೃದ್ಧಿ ಸಮಯವನ್ನು ಉಳಿಸಬಹುದು ಮತ್ತು ರನ್‌ಟೈಮ್ ದೋಷಗಳ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು. ವೈವಿಧ್ಯಮಯ ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಜಾಗತಿಕ ತಂಡಗಳಿಗೆ ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.

4. ಎನಮ್-ರೀತಿಯ ರಚನೆಗಳನ್ನು ಹೆಚ್ಚಿಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ enum ಗಳು ಇದ್ದರೂ, ಕೆಲವೊಮ್ಮೆ ನೀವು ಹೆಚ್ಚು ನಮ್ಯತೆಯನ್ನು ಬಯಸಬಹುದು ಅಥವಾ ಎನಮ್‌ಗಳಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಆಬ್ಜೆಕ್ಟ್ ಲಿಟರಲ್‌ಗಳಿಂದ ಟೈಪ್‌ಗಳನ್ನು ಪಡೆಯಲು ಬಯಸಬಹುದು.

            
const AppPermissions = {
  READ: 'read',
  WRITE: 'write',
  DELETE: 'delete',
  ADMIN: 'admin',
} as const;

type Permission = typeof AppPermissions[keyof typeof AppPermissions];
// type Permission = 'read' | 'write' | 'delete' | 'admin'

type UserPermissions = {
  [P in Permission]?: boolean;
};

type RolePermissions = {
  [P in Permission]: boolean;
};

const userPerms: UserPermissions = {
  read: true,
};

const adminRole: RolePermissions = {
  read: true,
  write: true,
  delete: true,
  admin: true,
};

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, ನಾವು ಮೊದಲು ಎಲ್ಲಾ ಸಂಭವನೀಯ ಅನುಮತಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಯೂನಿಯನ್ ಟೈಪ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ. ನಂತರ, ಪ್ರತಿ ಅನುಮತಿಯು ಕೀ ಆಗಿರುವ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸಲು ನಾವು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ, ಬಳಕೆದಾರರು ಆ ಅನುಮತಿಯನ್ನು ಹೊಂದಿದ್ದಾರೆಯೇ (ಐಚ್ಛಿಕ) ಅಥವಾ ಪಾತ್ರವು ಅದನ್ನು ಕಡ್ಡಾಯಗೊಳಿಸುತ್ತದೆಯೇ (ಅಗತ್ಯ) ಎಂಬುದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಈ ಮಾದರಿಯು ವಿಶ್ವಾದ್ಯಂತ ಅಧಿಕೃತ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿದೆ.

ಸವಾಲುಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ನಂಬಲಾಗದಷ್ಟು ಶಕ್ತಿಶಾಲಿಯಾಗಿದ್ದರೂ, ಸಂಭಾವ್ಯ ಸಂಕೀರ್ಣತೆಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಮುಖ್ಯ:

• ಓದಲು ಸುಲಭ ಮತ್ತು ಸಂಕೀರ್ಣತೆ: ಅತಿಯಾದ ಸಂಕೀರ್ಣ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳನ್ನು ಓದಲು ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಈ ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳಿಗೆ ಹೊಸಬರಾದ ಡೆವಲಪರ್‌ಗಳಿಗೆ. ಯಾವಾಗಲೂ ಸ್ಪಷ್ಟತೆಗಾಗಿ ಶ್ರಮಿಸಿ ಮತ್ತು ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸುವುದನ್ನು ಅಥವಾ ಸಂಕೀರ್ಣ ಪರಿವರ್ತನೆಗಳನ್ನು ವಿಭಜಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳು: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಪರಿಶೀಲನೆಯು ಕಂಪೈಲ್-ಟೈಮ್ ಆಗಿದ್ದರೂ, ಅತಿ ಸಂಕೀರ್ಣವಾದ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳು, ಸಿದ್ಧಾಂತದಲ್ಲಿ, ಕಂಪೈಲೇಶನ್ ಸಮಯವನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚಿಸಬಹುದು. ಹೆಚ್ಚಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಇದು ನಗಣ್ಯ, ಆದರೆ ಅತಿ ದೊಡ್ಡ ಕೋಡ್‌ಬೇಸ್‌ಗಳು ಅಥವಾ ಹೆಚ್ಚು ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಬಿಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಇದನ್ನು ನೆನಪಿನಲ್ಲಿಡಬೇಕು.
• ಡೀಬಗ್ ಮಾಡುವುದು: ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ನೀಡಿದಾಗ, ಡೀಬಗ್ ಮಾಡುವುದು ಕೆಲವೊಮ್ಮೆ ಸವಾಲಾಗಬಹುದು. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ಲೇಗ್ರೌಂಡ್ ಅಥವಾ IDE ಯ ಟೈಪ್ ತಪಾಸಣೆ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸುವುದು ಟೈಪ್‌ಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಲಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
• keyof ಮತ್ತು ಲುಕಪ್ ಟೈಪ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳ ಪರಿಣಾಮಕಾರಿ ಬಳಕೆಯು keyof ಮತ್ತು ಲುಕಪ್ ಟೈಪ್‌ಗಳ (T[P]) ದೃಢವಾದ ತಿಳುವಳಿಕೆಯನ್ನು ಅವಲಂಬಿಸಿದೆ. ಈ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ನಿಮ್ಮ ತಂಡವು ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಂಡಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುವುದಕ್ಕಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಮತ್ತು ಅವುಗಳ ಸವಾಲುಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಸರಳವಾಗಿ ಪ್ರಾರಂಭಿಸಿ: ಸಂಕೀರ್ಣ ಕೀ ಮರುಮ್ಯಾಪಿಂಗ್‌ಗಳು ಅಥವಾ ಕಂಡಿಷನಲ್ ಲಾಜಿಕ್‌ಗೆ ಧುಮುಕುವ ಮೊದಲು ಮೂಲಭೂತ ಐಚ್ಛಿಕತೆ ಮತ್ತು ರೀಡ್‌ಓನ್ಲಿ ಪರಿವರ್ತನೆಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ.
• ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಿ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳಾದ Partial, Readonly, Record, Pick, Omit, ಮತ್ತು Exclude ಗಳ ಬಗ್ಗೆ ಪರಿಚಿತರಾಗಿ. ಅವು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳಿಗೆ ಸಾಕಾಗುತ್ತದೆ ಮತ್ತು ಉತ್ತಮವಾಗಿ ಪರೀಕ್ಷಿಸಲ್ಪಟ್ಟಿವೆ ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲ್ಪಟ್ಟಿವೆ.
• ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಜೆನೆರಿಕ್ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸಿ: ಸಾಮಾನ್ಯ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಮಾದರಿಗಳನ್ನು ಜೆನೆರಿಕ್ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳಲ್ಲಿ ಆವರಿಸಿ. ಇದು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನಾದ್ಯಂತ ಮತ್ತು ಜಾಗತಿಕ ತಂಡಗಳಿಗೆ ಸ್ಥಿರತೆಯನ್ನು ಉತ್ತೇಜಿಸುತ್ತದೆ ಮತ್ತು ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಕೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ವಿವರಣಾತ್ಮಕ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ಮತ್ತು ಜೆನೆರಿಕ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಿಗೆ ಅವುಗಳ ಉದ್ದೇಶವನ್ನು ಸೂಚಿಸಲು ಸ್ಪಷ್ಟವಾಗಿ ಹೆಸರಿಸಿ (ಉದಾಹರಣೆಗೆ, Optional<T>, DeepReadonly<T>, PrefixedKeys<T, Prefix>).
• ಓದಲು ಸುಲಭಕ್ಕೆ ಆದ್ಯತೆ ನೀಡಿ: ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಹೆಚ್ಚು ಜಟಿಲವಾಗಿದ್ದರೆ, ಅದೇ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸಲು ಸರಳವಾದ ಮಾರ್ಗವಿದೆಯೇ ಅಥವಾ ಹೆಚ್ಚುವರಿ ಸಂಕೀರ್ಣತೆಗೆ ಇದು ಯೋಗ್ಯವಾಗಿದೆಯೇ ಎಂದು ಪರಿಗಣಿಸಿ. ಕೆಲವೊಮ್ಮೆ, ಸ್ವಲ್ಪ ಹೆಚ್ಚು ವಿಸ್ತಾರವಾದ ಆದರೆ ಸ್ಪಷ್ಟವಾದ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನವು ಉತ್ತಮವಾಗಿರುತ್ತದೆ.
• ಸಂಕೀರ್ಣ ಟೈಪ್‌ಗಳನ್ನು ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡಿ: ಸಂಕೀರ್ಣ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳಿಗಾಗಿ, ಅವುಗಳ ಕಾರ್ಯನಿರ್ವಹಣೆಯನ್ನು ವಿವರಿಸುವ JSDoc ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಿ, ವಿಶೇಷವಾಗಿ ವೈವಿಧ್ಯಮಯ ಅಂತರರಾಷ್ಟ್ರೀಯ ತಂಡದೊಳಗೆ ಕೋಡ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುವಾಗ.
• ನಿಮ್ಮ ಟೈಪ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ನಿರೀಕ್ಷಿತವಾಗಿ ವರ್ತಿಸುತ್ತವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಟೈಪ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ ಅಥವಾ ಉದಾಹರಣೆಗಳನ್ನು ಬಳಸಿ. ಸೂಕ್ಷ್ಮ ದೋಷಗಳನ್ನು ಹಿಡಿಯಲು ಕಷ್ಟವಾಗುವ ಸಂಕೀರ್ಣ ಪರಿವರ್ತನೆಗಳಿಗೆ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ಸುಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ನ ಮೂಲಾಧಾರವಾಗಿದ್ದು, ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್‌ಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಅಳವಡಿಸಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸಾಟಿಯಿಲ್ಲದ ಶಕ್ತಿಯನ್ನು ನೀಡುತ್ತದೆ. ನೀವು ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕ, ರೀಡ್-ಓನ್ಲಿ ಮಾಡುವಾಗ, ಅವುಗಳನ್ನು ಮರುಹೆಸರಿಸುವಾಗ ಅಥವಾ ಸಂಕೀರ್ಣ ಪರಿಸ್ಥಿತಿಗಳ ಆಧಾರದ ಮೇಲೆ ಅವುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವಾಗ, ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳು ನಿಮ್ಮ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಘೋಷಣಾತ್ಮಕ, ಟೈಪ್-ಸುರಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತಿದಾಯಕ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ.

ಈ ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಕೋಡ್ ಮರುಬಳಕೆಯನ್ನು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಿಸಬಹುದು, ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಉನ್ನತೀಕರಿಸಲು ಮತ್ತು ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಸಾಫ್ಟ್‌ವೇರ್ ಪರಿಹಾರಗಳನ್ನು ನಿರ್ಮಿಸಲು ಕೊಡುಗೆ ನೀಡಲು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ಗಳ ಶಕ್ತಿಯನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ. ನೀವು ವಿಭಿನ್ನ ಪ್ರದೇಶಗಳ ಡೆವಲಪರ್‌ಗಳೊಂದಿಗೆ ಸಹಕರಿಸುವಾಗ, ಈ ಸುಧಾರಿತ ಟೈಪ್ ಮಾದರಿಗಳು ಕೋಡ್ ಗುಣಮಟ್ಟ ಮತ್ತು ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಾಮಾನ್ಯ ಭಾಷೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು, ಟೈಪ್ ಸಿಸ್ಟಮ್‌ನ ನಿಖರತೆಯ ಮೂಲಕ ಸಂಭಾವ್ಯ ಸಂವಹನ ಅಂತರವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು.