ಸುಧಾರಿತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ಯಾಟರ್ನ್‌ಗಳು: ಷರತ್ತುಬದ್ಧ ಮತ್ತು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಮಾಸ್ಟರಿ

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

ಷರತ್ತುಬದ್ಧ ಟೈಪ್ಸ್ ಎಂದರೇನು?

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

ಸಿಂಟ್ಯಾಕ್ಸ್

            T extends U ? X : Y
            

              
                Copy
              
            
          

• T: ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿರುವ ಟೈಪ್.
• U: ಹೋಲಿಸಿ ನೋಡಬೇಕಾದ ಟೈಪ್.
• extends: ಉಪ-ಟೈಪ್ (subtype) ಸಂಬಂಧವನ್ನು ಸೂಚಿಸುವ ಕೀವರ್ಡ್.
• X: ಒಂದು ವೇಳೆ Tಯು Uಗೆ ನಿಯೋಜಿಸಬಹುದಾದರೆ (assignable) ಬಳಸಬೇಕಾದ ಟೈಪ್.
• Y: ಒಂದು ವೇಳೆ Tಯು Uಗೆ ನಿಯೋಜಿಸಲಾಗದಿದ್ದರೆ (not assignable) ಬಳಸಬೇಕಾದ ಟೈಪ್.

ಸಾರಾಂಶದಲ್ಲಿ, T extends U ಎಂಬುದು ಸರಿ (true) ಎಂದು ಮೌಲ್ಯಮಾಪನಗೊಂಡರೆ, ಟೈಪ್ X ಆಗಿ ಪರಿಹರಿಸಲ್ಪಡುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಅದು Y ಆಗಿ ಪರಿಹರಿಸಲ್ಪಡುತ್ತದೆ.

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

1. ಫಂಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಟೈಪ್ ನಿರ್ಧರಿಸುವುದು

ಒಂದು ಫಂಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ನಂಬರ್ ಆಗಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುವ ಟೈಪ್ ಅನ್ನು ನೀವು ರಚಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ:

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

function processValue(value: ParamType<string | number>): void {
  if (typeof value === "string") {
    console.log("Value is a string:", value);
  } else {
    console.log("Value is a number:", value);
  }
}

processValue("hello"); // Output: Value is a string: hello
processValue(123);     // Output: Value is a number: 123
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ParamType<T> ಒಂದು ಷರತ್ತುಬದ್ಧ ಟೈಪ್ ಆಗಿದೆ. T ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದ್ದರೆ, ಟೈಪ್ string ಗೆ ಪರಿಹರಿಸಲ್ಪಡುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಅದು number ಗೆ ಪರಿಹರಿಸಲ್ಪಡುತ್ತದೆ. processValue ಫಂಕ್ಷನ್ ಈ ಷರತ್ತುಬದ್ಧ ಟೈಪ್ ಆಧರಿಸಿ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ನಂಬರ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.

2. ಇನ್‌ಪುಟ್ ಟೈಪ್ ಆಧಾರದ ಮೇಲೆ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ಹೊರತೆಗೆಯುವುದು

ಇನ್‌ಪುಟ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ವಿಭಿನ್ನ ಟೈಪ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್ ಇರುವ ಸನ್ನಿವೇಶವನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಷರತ್ತುಬದ್ಧ ಟೈಪ್ಸ್ ಸರಿಯಾದ ರಿಟರ್ನ್ ಟೈಪ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಬಹುದು:

            interface StringProcessor {
  process(input: string): number;
}

interface NumberProcessor {
  process(input: number): string;
}

type Processor<T> = T extends string ? StringProcessor : NumberProcessor;

function createProcessor<T extends string | number>(input: T): Processor<T> {
  if (typeof input === "string") {
    return { process: (input: string) => input.length } as Processor<T>;
  } else {
    return { process: (input: number) => input.toString() } as Processor<T>;
  }
}

const stringProcessor = createProcessor("example");
const numberProcessor = createProcessor(42);

console.log(stringProcessor.process("example")); // Output: 7
console.log(numberProcessor.process(42));    // Output: "42"
            

              
                Copy
              
            
          

ಇಲ್ಲಿ, Processor<T> ಟೈಪ್, ಇನ್‌ಪುಟ್‌ನ ಟೈಪ್ ಅನ್ನು ಆಧರಿಸಿ StringProcessor ಅಥವಾ NumberProcessor ಅನ್ನು ಷರತ್ತುಬದ್ಧವಾಗಿ ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. ಇದು createProcessor ಫಂಕ್ಷನ್ ಸರಿಯಾದ ರೀತಿಯ ಪ್ರೊಸೆಸರ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

3. ವಿವೇಚನಾಶೀಲ ಯೂನಿಯನ್‌ಗಳು (Discriminated Unions)

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

            interface Square {
  kind: "square";
  size: number;
}

interface Circle {
  kind: "circle";
  radius: number;
}

type Shape = Square | Circle;

type Area<T extends Shape> = T extends { kind: "square" } ? number : string;

function calculateArea(shape: Shape): Area<typeof shape> {
  if (shape.kind === "square") {
    return shape.size * shape.size;
  } else {
    return Math.PI * shape.radius * shape.radius;
  }
}

const mySquare: Square = { kind: "square", size: 5 };
const myCircle: Circle = { kind: "circle", radius: 3 };

console.log(calculateArea(mySquare)); // Output: 25
console.log(calculateArea(myCircle)); // Output: 28.274333882308138
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, Shape ಟೈಪ್ ಒಂದು ವಿವೇಚನಾಶೀಲ ಯೂನಿಯನ್ ಆಗಿದೆ. Area<T> ಟೈಪ್ ಒಂದು ಷರತ್ತುಬದ್ಧ ಟೈಪ್ ಅನ್ನು ಬಳಸಿ ಆಕಾರವು ಚೌಕವೇ ಅಥವಾ ವೃತ್ತವೇ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ, ಚೌಕಗಳಿಗೆ number ಮತ್ತು ವೃತ್ತಗಳಿಗೆ string ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ (ಆದರೂ ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶದಲ್ಲಿ, ನೀವು ಸ್ಥಿರವಾದ ರಿಟರ್ನ್ ಟೈಪ್ಸ್ ಅನ್ನು ಬಯಸಬಹುದು, ಇದು ತತ್ವವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ).

ಷರತ್ತುಬದ್ಧ ಟೈಪ್ಸ್ ಬಗ್ಗೆ ಪ್ರಮುಖ ಅಂಶಗಳು

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

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

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್ಸ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳ ಮೇಲೆ ಮ್ಯಾಪಿಂಗ್ ಮಾಡುವ ಮೂಲಕ ಅವುಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ. ಅವು ನಿಮಗೆ ಬೇರೊಂದು ಟೈಪ್‌ನ ಪ್ರಾಪರ್ಟಿಗಳ ಆಧಾರದ ಮೇಲೆ ಹೊಸ ಟೈಪ್ಸ್ ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕ (optional), ರೀಡ್-ಓನ್ಲಿ (readonly) ಮಾಡುವುದು ಅಥವಾ ಅವುಗಳ ಟೈಪ್ಸ್ ಅನ್ನು ಬದಲಾಯಿಸುವಂತಹ ಮಾರ್ಪಾಡುಗಳನ್ನು ಅನ್ವಯಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತವೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್

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

              
                Copy
              
            
          

• T: ಇನ್‌ಪುಟ್ ಟೈಪ್.
• keyof T: T ಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿ ಕೀಗಳ ಯೂನಿಯನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಟೈಪ್ ಆಪರೇಟರ್.
• K in keyof T: keyof T ಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಕೀ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಪ್ರತಿ ಕೀಯನ್ನು K ಟೈಪ್ ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಯೋಜಿಸುತ್ತದೆ.
• ModifiedType: ಪ್ರತಿಯೊಂದು ಪ್ರಾಪರ್ಟಿಯನ್ನು ಮ್ಯಾಪ್ ಮಾಡಲಾಗುವ ಟೈಪ್. ಇದು ಷರತ್ತುಬದ್ಧ ಟೈಪ್ಸ್ ಅಥವಾ ಇತರ ಟೈಪ್ ಪರಿವರ್ತನೆಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.

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

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

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

            interface User {
  id: number;
  name: string;
  email: string;
}

type PartialUser = {
  [K in keyof User]?: User[K];
};

const partialUser: PartialUser = {
  name: "John Doe",
}; // Valid, as 'id' and 'email' are optional

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, PartialUser ಒಂದು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಆಗಿದ್ದು ಅದು User ಇಂಟರ್ಫೇಸ್‌ನ ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಕೀ K ಗೆ, ಅದು ? ಮಾರ್ಪಾಡನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಐಚ್ಛಿಕಗೊಳಿಸುತ್ತದೆ. User[K] User ಇಂಟರ್ಫೇಸ್‌ನಿಂದ K ಪ್ರಾಪರ್ಟಿಯ ಟೈಪ್ ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ.

2. ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರೀಡ್-ಓನ್ಲಿ (Readonly) ಮಾಡುವುದು

ಅದೇ ರೀತಿ, ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ನ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರೀಡ್-ಓನ್ಲಿ ಮಾಡಬಹುದು:

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

type ReadonlyProduct = {
  readonly [K in keyof Product]: Product[K];
};

const readonlyProduct: ReadonlyProduct = {
  id: 123,
  name: "Example Product",
  price: 25.00,
};

// readonlyProduct.price = 30.00; // Error: Cannot assign to 'price' because it is a read-only property.
            

              
                Copy
              
            
          

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ReadonlyProduct ಒಂದು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಆಗಿದ್ದು ಅದು Product ಇಂಟರ್ಫೇಸ್‌ನ ಪ್ರತಿಯೊಂದು ಪ್ರಾಪರ್ಟಿಗೆ readonly ಮಾರ್ಪಾಡನ್ನು ಸೇರಿಸುತ್ತದೆ.

3. ಪ್ರಾಪರ್ಟಿ ಟೈಪ್ಸ್ ಅನ್ನು ಪರಿವರ್ತಿಸುವುದು

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

            interface Config {
  apiUrl: string;
  timeout: string;
  maxRetries: number;
}

type NumericConfig = {
  [K in keyof Config]: Config[K] extends string ? number : Config[K];
};

const numericConfig: NumericConfig = {
  apiUrl: 123, // Must be a number due to the mapping
  timeout: 456, // Must be a number due to the mapping
  maxRetries: 3,
};

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಒಳಗೆ ಷರತ್ತುಬದ್ಧ ಟೈಪ್ ಬಳಸುವುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಪ್ರಾಪರ್ಟಿ K ಗಾಗಿ, ಅದು Config[K] ಯ ಟೈಪ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಟೈಪ್ number ಗೆ ಮ್ಯಾಪ್ ಆಗುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಅದು ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ.

4. ಕೀ ಮರುಮ್ಯಾಪಿಂಗ್ (ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ 4.1 ರಿಂದ)

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

            interface Event {
  eventId: string;
  eventName: string;
  eventDate: Date;
}

type TransformedEvent = {
  [K in keyof Event as `new${Capitalize<string&K>}`]: Event[K];
};

// Result:
// {
//   newEventId: string;
//   newEventName: string;
//   newEventDate: Date;
// }

//Capitalize function used to Capitalize first letter
type Capitalize<S extends string> = Uppercase<string&S> extends never ? string :  `$Capitalize<S>`;

//Usage with an actual object
const myEvent: TransformedEvent = {
    newEventId: "123",
    newEventName: "New Name",
    newEventDate: new Date()
};

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, TransformedEvent ಟೈಪ್ ಪ್ರತಿ ಕೀ K ಅನ್ನು "new" ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಮತ್ತು ಕ್ಯಾಪಿಟಲೈಸ್ ಮಾಡಿದ ಹೊಸ ಕೀಗೆ ಮರುಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ. `Capitalize` ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್, ಕೀಲಿಯ ಮೊದಲ ಅಕ್ಷರವನ್ನು ಕ್ಯಾಪಿಟಲೈಸ್ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. `string & K` ಇಂಟರ್ಸೆಕ್ಷನ್ ನಾವು ಕೇವಲ ಸ್ಟ್ರಿಂಗ್ ಕೀಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಿದ್ದೇವೆ ಮತ್ತು K ಯಿಂದ ಸರಿಯಾದ ಲಿಟರಲ್ ಟೈಪ್ ಪಡೆಯುತ್ತಿದ್ದೇವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಕೀ ಮರುಮ್ಯಾಪಿಂಗ್ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳಿಗೆ ಟೈಪ್ಸ್ ಅನ್ನು ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಹೊಂದಿಸಲು ಶಕ್ತಿಯುತ ಸಾಧ್ಯತೆಗಳನ್ನು ತೆರೆಯುತ್ತದೆ. ಸಂಕೀರ್ಣ ತರ್ಕದ ಆಧಾರದ ಮೇಲೆ ಕೀಗಳನ್ನು ಮರುಹೆಸರಿಸಲು, ಫಿಲ್ಟರ್ ಮಾಡಲು ಅಥವಾ ಮಾರ್ಪಡಿಸಲು ಇದು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಬಗ್ಗೆ ಪ್ರಮುಖ ಅಂಶಗಳು

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

ಷರತ್ತುಬದ್ಧ ಮತ್ತು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಅನ್ನು ಸಂಯೋಜಿಸುವುದು

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

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

            interface Data {
  name: string;
  age: number;
  city: string;
  country: string;
  isEmployed: boolean;
}

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

type StringData = StringProperties<Data>;

// Result:
// {
//   name: string;
//   city: string;
//   country: string;
// }

const stringData: StringData = {
  name: "John",
  city: "New York",
  country: "USA",
};

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, StringProperties<T> ಟೈಪ್ ಕೀ ಮರುಮ್ಯಾಪಿಂಗ್ ಮತ್ತು ಷರತ್ತುಬದ್ಧ ಟೈಪ್‌ನೊಂದಿಗೆ ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಪ್ರತಿ ಪ್ರಾಪರ್ಟಿ K ಗಾಗಿ, ಅದು T[K] ಯ ಟೈಪ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದರೆ, ಕೀಯನ್ನು ಉಳಿಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು never ಗೆ ಮ್ಯಾಪ್ ಮಾಡಲಾಗುತ್ತದೆ, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಅದನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುತ್ತದೆ. ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ ಕೀ ಆಗಿ never ಅನ್ನು ಬಳಸುವುದು ಅದನ್ನು ಫಲಿತಾಂಶದ ಟೈಪ್‌ನಿಂದ ತೆಗೆದುಹಾಕುತ್ತದೆ. ಇದು StringData ಟೈಪ್‌ನಲ್ಲಿ ಕೇವಲ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾಪರ್ಟಿಗಳು ಮಾತ್ರ ಸೇರಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

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

ಸಾಮಾನ್ಯ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್

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

ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್ ಅನ್ನು ಷರತ್ತುಬದ್ಧ ಮತ್ತು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಬಳಸಿ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಈ ಸುಧಾರಿತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯಗಳ ಶಕ್ತಿ ಮತ್ತು ನಮ್ಯತೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, Partial<T> ಅನ್ನು ಹೀಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ:

            type Partial<T> = {
  [P in keyof T]?: T[P];
};
            

              
                Copy
              
            
          

ಷರತ್ತುಬದ್ಧ ಮತ್ತು ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

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

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

ತೀರ್ಮಾನ

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