ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಮತ್ತು ಕಂಡೀಷನಲ್ ಟೈಪ್ಸ್‌ಗಳಲ್ಲಿ ಪಾಂಡಿತ್ಯ

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

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಎಂದರೇನು?

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ಗಳನ್ನು ಪರಿವರ್ತಿಸುವ ಮೂಲಕ ಹೊಸ ಟೈಪ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಅವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತವೆ ಮತ್ತು ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿಗೆ ಒಂದು ಪರಿವರ್ತನೆಯನ್ನು ಅನ್ವಯಿಸುತ್ತವೆ. ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕ (optional) ಅಥವಾ ಓದಲು ಮಾತ್ರ (read-only) ಮಾಡುವಂತಹ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ಗಳ ವ್ಯತ್ಯಾಸಗಳನ್ನು ರಚಿಸಲು ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಮೂಲಭೂತ ಸಿಂಟ್ಯಾಕ್ಸ್

ಒಂದು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

            type NewType<T> = {
  [K in keyof T]: Transformation;
};
            

              
                Copy
              
            
          

• T: ನೀವು ಮ್ಯಾಪ್ ಮಾಡಲು ಬಯಸುವ ಇನ್‌ಪುಟ್ ಟೈಪ್.
• K in keyof T: ಇನ್‌ಪುಟ್ ಟೈಪ್ T ಯಲ್ಲಿನ ಪ್ರತಿ ಕೀ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ. keyof T ಎಂಬುದು T ಯಲ್ಲಿನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿ ಹೆಸರುಗಳ ಯೂನಿಯನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಮತ್ತು K ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ಪ್ರತಿ ಪ್ರತ್ಯೇಕ ಕೀಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• Transformation: ನೀವು ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿಗೆ ಅನ್ವಯಿಸಲು ಬಯಸುವ ಪರಿವರ್ತನೆ. ಇದು ಮಾರ್ಪಾಡುಕಾರಕವನ್ನು (readonly ಅಥವಾ ? ನಂತಹ) ಸೇರಿಸುವುದು, ಟೈಪ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು, ಅಥವಾ ಸಂಪೂರ್ಣವಾಗಿ ಬೇರೆನಾದರೂ ಆಗಿರಬಹುದು.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಓದಲು-ಮಾತ್ರ (Read-Only) ಮಾಡುವುದು

ನೀವು ಬಳಕೆದಾರರ ಪ್ರೊಫೈಲ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಇಂಟರ್ಫೇಸ್ ಹೊಂದಿದ್ದೀರಿ ಎಂದುಕೊಳ್ಳೋಣ:

            interface UserProfile {
  name: string;
  age: number;
  email: string;
}
            

              
                Copy
              
            
          

ನೀವು ಹೊಸ ಟೈಪ್ ಅನ್ನು ರಚಿಸಬಹುದು, ಅಲ್ಲಿ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಓದಲು-ಮಾತ್ರ ಇರುತ್ತವೆ:

            type ReadOnlyUserProfile = {
  readonly [K in keyof UserProfile]: UserProfile[K];
};
            

              
                Copy
              
            
          

ಈಗ, ReadOnlyUserProfile, UserProfile ನಂತೆಯೇ ಅದೇ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಆದರೆ ಅವೆಲ್ಲವೂ ಓದಲು-ಮಾತ್ರ ಇರುತ್ತವೆ.

ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕ (Optional) ಮಾಡುವುದು

ಅದೇ ರೀತಿ, ನೀವು ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕ ಮಾಡಬಹುದು:

            type OptionalUserProfile = {
  [K in keyof UserProfile]?: UserProfile[K];
};
            

              
                Copy
              
            
          

OptionalUserProfile, UserProfile ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಆದರೆ ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿ ಐಚ್ಛಿಕವಾಗಿರುತ್ತದೆ.

ಪ್ರಾಪರ್ಟಿ ಟೈಪ್‌ಗಳನ್ನು ಮಾರ್ಪಡಿಸುವುದು

ನೀವು ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿಯ ಟೈಪ್ ಅನ್ನು ಸಹ ಮಾರ್ಪಡಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು:

            type StringifiedUserProfile = {
  [K in keyof UserProfile]: string;
};
            

              
                Copy
              
            
          

ಈ ಸಂದರ್ಭದಲ್ಲಿ, StringifiedUserProfile ನಲ್ಲಿನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು string ಟೈಪ್‌ನದ್ದಾಗಿರುತ್ತವೆ.

ಕಂಡೀಷನಲ್ ಟೈಪ್ಸ್ ಎಂದರೇನು?

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

ಮೂಲಭೂತ ಸಿಂಟ್ಯಾಕ್ಸ್

ಒಂದು ಕಂಡೀಷನಲ್ ಟೈಪ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:

            T extends U ? X : Y
            

              
                Copy
              
            
          

• T: ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿರುವ ಟೈಪ್.
• U: T ಯಿಂದ ವಿಸ್ತರಿಸಲ್ಪಡುತ್ತಿರುವ ಟೈಪ್ (ಷರತ್ತು).
• X: Tಯು U ಅನ್ನು ವಿಸ್ತರಿಸಿದರೆ (ಷರತ್ತು ನಿಜವಾಗಿದ್ದರೆ) ಹಿಂತಿರುಗಿಸಬೇಕಾದ ಟೈಪ್.
• Y: Tಯು U ಅನ್ನು ವಿಸ್ತರಿಸದಿದ್ದರೆ (ಷರತ್ತು ಸುಳ್ಳಾಗಿದ್ದರೆ) ಹಿಂತಿರುಗಿಸಬೇಕಾದ ಟೈಪ್.

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

ಒಂದು ಟೈಪ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುವುದು

ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸೋಣ, ಅದು ಇನ್‌ಪುಟ್ ಟೈಪ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದ್ದರೆ string ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ number ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ:

            type StringOrNumber<T> = T extends string ? string : number;

type Result1 = StringOrNumber<string>;  // string
type Result2 = StringOrNumber<number>;  // number
type Result3 = StringOrNumber<boolean>; // number
            

              
                Copy
              
            
          

ಯೂನಿಯನ್‌ನಿಂದ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುವುದು

ಯೂನಿಯನ್ ಟೈಪ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯಲು ನೀವು ಕಂಡೀಷನಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಾನ್-ನಲ್ಲೇಬಲ್ (non-nullable) ಟೈಪ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು:

            type NonNullable<T> = T extends null | undefined ? never : T;

type Result4 = NonNullable<string | null | undefined>; // string
            

              
                Copy
              
            
          

ಇಲ್ಲಿ, T ಯು null ಅಥವಾ undefined ಆಗಿದ್ದರೆ, ಟೈಪ್ never ಆಗುತ್ತದೆ, ಇದನ್ನು ನಂತರ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಯೂನಿಯನ್ ಟೈಪ್ ಸರಳೀಕರಣದಿಂದ ಫಿಲ್ಟರ್ ಮಾಡಲಾಗುತ್ತದೆ.

ಟೈಪ್‌ಗಳನ್ನು ಇನ್ಫರ್ ಮಾಡುವುದು (Inferring Types)

infer ಕೀವರ್ಡ್ ಬಳಸಿ ಟೈಪ್‌ಗಳನ್ನು ಇನ್ಫರ್ ಮಾಡಲು ಸಹ ಕಂಡೀಷನಲ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಇದು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಟೈಪ್ ರಚನೆಯಿಂದ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

            type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

function myFunction(x: number): string {
  return x.toString();
}

type Result5 = ReturnType<typeof myFunction>; // string
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ReturnType ಒಂದು ಫಂಕ್ಷನ್‌ನ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ. ಇದು T ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು R ಟೈಪ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಅದು R ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಅದು any ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಮತ್ತು ಕಂಡೀಷನಲ್ ಟೈಪ್ಸ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು

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

ಉದಾಹರಣೆ: ಡೀಪ್ ರೀಡ್‌ಓನ್ಲಿ (Deep Readonly)

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

            type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

interface Company {
  name: string;
  address: {
    street: string;
    city: string;
  };
}

type ReadonlyCompany = DeepReadonly<Company>;
            

              
                Copy
              
            
          

ಇಲ್ಲಿ, DeepReadonly ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳು ಮತ್ತು ಅವುಗಳ ನೆಸ್ಟೆಡ್ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ readonly ಮಾರ್ಪಾಡುಕಾರಕವನ್ನು ರಿಕರ್ಸಿವ್ ಆಗಿ ಅನ್ವಯಿಸುತ್ತದೆ. ಒಂದು ಪ್ರಾಪರ್ಟಿ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದ್ದರೆ, ಅದು ಆ ಆಬ್ಜೆಕ್ಟ್ ಮೇಲೆ DeepReadonly ಅನ್ನು ರಿಕರ್ಸಿವ್ ಆಗಿ ಕರೆಯುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು ಕೇವಲ ಪ್ರಾಪರ್ಟಿಗೆ readonly ಮಾರ್ಪಾಡುಕಾರಕವನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ.

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

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

            type FilterByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

interface Person {
  name: string;
  age: number;
  isEmployed: boolean;
}

type StringProperties = FilterByType<Person, string>; // { name: string; }

type NonStringProperties = Omit<Person, keyof StringProperties>;

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, FilterByType, T ಯ ಪ್ರಾಪರ್ಟಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿಯ ಟೈಪ್ U ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಅದು ಫಲಿತಾಂಶದ ಟೈಪ್‌ನಲ್ಲಿ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಕೀಯನ್ನು never ಗೆ ಮ್ಯಾಪ್ ಮಾಡುವ ಮೂಲಕ ಅದನ್ನು ಹೊರಗಿಡುತ್ತದೆ. ಕೀಗಳನ್ನು ರಿಮ್ಯಾಪ್ ಮಾಡಲು "as" ಬಳಕೆಯನ್ನು ಗಮನಿಸಿ. ನಂತರ ನಾವು ಮೂಲ ಇಂಟರ್ಫೇಸ್‌ನಿಂದ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ತೆಗೆದುಹಾಕಲು `Omit` ಮತ್ತು `keyof StringProperties` ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

ಸುಧಾರಿತ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಪ್ಯಾಟರ್ನ್‌ಗಳು

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

ವಿತರಕ ಕಂಡೀಷನಲ್ ಟೈಪ್ಸ್ (Distributive Conditional Types)

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

            type ToArray<T> = T extends any ? T[] : never;

type Result6 = ToArray<string | number>; // string[] | number[]
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ToArray ಅನ್ನು string | number ಯೂನಿಯನ್‌ನ ಪ್ರತಿಯೊಬ್ಬ ಸದಸ್ಯನಿಗೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ string[] | number[] ಬರುತ್ತದೆ. ಷರತ್ತು ವಿತರಕವಾಗಿರದಿದ್ದರೆ, ಫಲಿತಾಂಶವು (string | number)[] ಆಗಿರುತ್ತಿತ್ತು.

ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್ ಬಳಸುವುದು

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್, ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಮತ್ತು ಕಂಡೀಷನಲ್ ಟೈಪ್ಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಹಲವಾರು ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಟೈಪ್ ಪರಿವರ್ತನೆಗಳಿಗೆ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್‌ಗಳಾಗಿ ಬಳಸಬಹುದು.

• Partial<T>: T ಯ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕಗೊಳಿಸುತ್ತದೆ.
• Required<T>: T ಯ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಕಡ್ಡಾಯಗೊಳಿಸುತ್ತದೆ.
• Readonly<T>: T ಯ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಓದಲು-ಮಾತ್ರ ಮಾಡುತ್ತದೆ.
• Pick<T, K>: T ಯಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.
• Omit<T, K>: T ಯಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
• Record<K, T>: T ಟೈಪ್‌ನ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪಿನೊಂದಿಗೆ ಒಂದು ಟೈಪ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
• Exclude<T, U>: T ಯಿಂದ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾದ ಎಲ್ಲಾ ಟೈಪ್‌ಗಳನ್ನು ಹೊರಗಿಡುತ್ತದೆ.
• Extract<T, U>: T ಯಿಂದ U ಗೆ ನಿಯೋಜಿಸಬಹುದಾದ ಎಲ್ಲಾ ಟೈಪ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ.
• NonNullable<T>: T ಯಿಂದ null ಮತ್ತು undefined ಅನ್ನು ಹೊರಗಿಡುತ್ತದೆ.
• Parameters<T>: ಫಂಕ್ಷನ್ ಟೈಪ್ T ಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಪಡೆಯುತ್ತದೆ.
• ReturnType<T>: ಫಂಕ್ಷನ್ ಟೈಪ್ T ಯ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ಪಡೆಯುತ್ತದೆ.
• InstanceType<T>: ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಫಂಕ್ಷನ್ ಟೈಪ್ T ಯ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಟೈಪ್ ಅನ್ನು ಪಡೆಯುತ್ತದೆ.

ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್‌ಗಳು ಸಂಕೀರ್ಣ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ಗಳನ್ನು ಸರಳಗೊಳಿಸಬಲ್ಲ ಶಕ್ತಿಯುತ ಸಾಧನಗಳಾಗಿವೆ. ಉದಾಹರಣೆಗೆ, ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಮಾತ್ರ ಐಚ್ಛಿಕಗೊಳಿಸುವ ಟೈಪ್ ಅನ್ನು ರಚಿಸಲು ನೀವು Pick ಮತ್ತು Partial ಅನ್ನು ಸಂಯೋಜಿಸಬಹುದು:

            type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type OptionalDescriptionProduct = Optional<Product, "description">;
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, OptionalDescriptionProduct, Product ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿದೆ, ಆದರೆ description ಪ್ರಾಪರ್ಟಿ ಐಚ್ಛಿಕವಾಗಿದೆ.

ಟೆಂಪ್ಲೇಟ್ ಲಿಟರಲ್ ಟೈಪ್ಸ್ ಬಳಸುವುದು

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

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

interface Settings {
  apiUrl: string;
  timeout: number;
}

type PrefixedSettings = Prefix<Settings, "data_">;
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, PrefixedSettings, data_apiUrl ಮತ್ತು data_timeout ಎಂಬ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

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

ತೀರ್ಮಾನ

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

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