ಸುಧಾರಿತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್, ಕೀಆಫ್ ಆಪರೇಟರ್ ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು. ಅವುಗಳ ವ್ಯತ್ಯಾಸ ಮತ್ತು ಟೈಪ್-ಸುರಕ್ಷಿತ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಅವುಗಳ ಸಂಯೋಜನೆ.
ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಸುಧಾರಿತ: ಕೀಆಫ್ ಆಪರೇಟರ್ ವರ್ಸಸ್ ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್ಸ್ ವಿವರಣೆ
ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ವಿಶಾಲವಾದ ಮತ್ತು ನಿರಂತರವಾಗಿ ವಿಕಸಿಸುತ್ತಿರುವ ಭೂದೃಶ್ಯದಲ್ಲಿ, ಬಲವಾದ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿರ್ಣಾಯಕ ಸಾಧನವಾಗಿ ಹೊರಹೊಮ್ಮಿದೆ. ಅದರ ಸ್ಥಿರ ಟೈಪಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳು ಪ್ರಪಂಚದಾದ್ಯಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ದೋಷಗಳನ್ನು ಮೊದಲೇ ಪತ್ತೆಹಚ್ಚಲು, ಕೋಡ್ ಓದುವಿಕೆಯನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತು ವೈವಿಧ್ಯಮಯ ತಂಡಗಳು ಮತ್ತು ಯೋಜನೆಗಳಾದ್ಯಂತ ಸಹಯೋಗವನ್ನು ಸುಗಮಗೊಳಿಸಲು ಅಧಿಕಾರ ನೀಡುತ್ತವೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಶಕ್ತಿಯ ಕೇಂದ್ರದಲ್ಲಿ ಅದರ ಅತ್ಯಾಧುನಿಕ ಟೈಪ್ ಸಿಸ್ಟಮ್ ಇದೆ, ವಿಶೇಷವಾಗಿ ಅದರ ಜೆನೆರಿಕ್ಸ್ ಮತ್ತು ಸುಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ವೈಶಿಷ್ಟ್ಯಗಳು. ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ಮೂಲ ಜೆನೆರಿಕ್ಸ್‌ಗಳೊಂದಿಗೆ ಆರಾಮದಾಯಕವಾಗಿದ್ದರೂ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಿಜವಾಗಿಯೂ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು, keyof ಆಪರೇಟರ್ ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳಂತಹ ಸುಧಾರಿತ ಪರಿಕಲ್ಪನೆಗಳ ಆಳವಾದ ತಿಳುವಳಿಕೆ ಅಗತ್ಯವಿದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ತಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೌಶಲ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸಲು ಬಯಸುವ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಮೀರಿ ಭಾಷೆಯ ಸಂಪೂರ್ಣ ಅಭಿವ್ಯಕ್ತಿ ಶಕ್ತಿಯನ್ನು ಹೆಚ್ಚಿಸಲು. ನಾವು ವಿವರವಾದ ಪ್ರಯಾಣವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, keyof ಆಪರೇಟರ್ ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತೇವೆ, ಅವುಗಳ ವೈಯಕ್ತಿಕ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ಪ್ರತಿಯೊಂದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕೆಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ನಿರ್ಣಾಯಕವಾಗಿ, ನಂಬಲಾಗದಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಟೈಪ್-ಸುರಕ್ಷಿತ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಅವುಗಳನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸಬೇಕು ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತೇವೆ. ನೀವು ಜಾಗತಿಕ ಎಂಟರ್‌ಪ್ರೈಸ್ ಅಪ್ಲಿಕೇಶನ್, ಓಪನ್-ಸೋರ್ಸ್ ಲೈಬ್ರರಿ ನಿರ್ಮಿಸುತ್ತಿರಲಿ ಅಥವಾ ಅಂತರ-ಸಾಂಸ್ಕೃತಿಕ ಅಭಿವೃದ್ಧಿ ಯೋಜನೆಗೆ ಕೊಡುಗೆ ನೀಡುತ್ತಿರಲಿ, ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಲು ಈ ಸುಧಾರಿತ ತಂತ್ರಗಳು ಅನಿವಾರ್ಯವಾಗಿವೆ.
ನಿಜವಾಗಿಯೂ ಸುಧಾರಿತ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳ ರಹಸ್ಯಗಳನ್ನು ಅನ್‌ಲಾಕ್ ಮಾಡೋಣ ಮತ್ತು ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಗೆ ಅಧಿಕಾರ ನೀಡೋಣ!
ಮೂಲಾಧಾರ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳ ವಿಶೇಷತೆಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ಜೆನೆರಿಕ್ಸ್‌ನ ಪರಿಕಲ್ಪನೆಯನ್ನು ಮತ್ತು ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಅವು ಏಕೆ ಅತಿ ಮುಖ್ಯವಾಗಿವೆ ಎಂಬುದನ್ನು ದೃಢವಾಗಿ ಗ್ರಹಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಜೆನೆರಿಕ್ಸ್ ಒಂದೇ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ಸೀಮಿತವಾಗುವ ಬದಲು, ವಿವಿಧ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಘಟಕಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಅಪಾರ ನಮ್ಯತೆ ಮತ್ತು ಮರುಬಳಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಇಂದಿನ ವೇಗದ ಅಭಿವೃದ್ಧಿ ಪರಿಸರದಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕವಾಗಿ ವೈವಿಧ್ಯಮಯ ಡೇಟಾ ರಚನೆಗಳು ಮತ್ತು ವ್ಯಾಪಾರ ತರ್ಕಕ್ಕೆ ಸರಿಹೊಂದುವಂತೆ ಪ್ರಮುಖವಾಗಿದೆ.
ಮೂಲಭೂತ ಜೆನೆರಿಕ್ಸ್: ಒಂದು ಹೊಂದಿಕೊಳ್ಳುವ ಅಡಿಪಾಯ
ನೀವು ಅರೇಯ ಮೊದಲ ಅಂಶವನ್ನು ಹಿಂದಿರುಗಿಸುವ ಕಾರ್ಯದ ಅಗತ್ಯವಿದೆ ಎಂದು ಊಹಿಸಿ. ಜೆನೆರಿಕ್ಸ್ ಇಲ್ಲದೆ, ನೀವು ಅದನ್ನು ಹೀಗೆ ಬರೆಯಬಹುದು:
function getFirstElement(arr: any[]): any {
if (arr.length === 0) {
return undefined;
}
return arr[0];
}
// Usage with numbers
const numbers = [1, 2, 3];
const firstNumber = getFirstElement(numbers); // type: any
// Usage with strings
const names = ['Alice', 'Bob'];
const firstName = getFirstElement(names); // type: any
// Problem: We lose type information!
const lengthOfFirstName = (firstName as string).length; // Requires type assertion
ಇಲ್ಲಿನ ಸಮಸ್ಯೆ ಏನೆಂದರೆ any ಸಂಪೂರ್ಣವಾಗಿ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಅಳಿಸಿಹಾಕುತ್ತದೆ. ಜೆನೆರಿಕ್ಸ್ ಇದನ್ನು ಪರಿಹರಿಸುತ್ತವೆ, ವಾದದ ಪ್ರಕಾರವನ್ನು ಸೆರೆಹಿಡಿಯಲು ಮತ್ತು ಅದನ್ನು ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರವಾಗಿ ಬಳಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:
function getFirstElement<T>(arr: T[]): T {
if (arr.length === 0) {
// Depending on strict settings, you might need to return T | undefined
// For simplicity, let's assume non-empty arrays or handle undefined explicitly.
// A more robust signature might be T[] => T | undefined.
return undefined as any; // Or handle more carefully
}
return arr[0];
}
const numbers = [1, 2, 3];
const firstNumber = getFirstElement(numbers); // type: number
const names = ['Alice', 'Bob'];
const firstName = getFirstElement(names); // type: string
// Type safety maintained!
const lengthOfFirstName = firstName.length; // No type assertion needed, TypeScript knows it's a string
ಇಲ್ಲಿ, <T> ಒಂದು ಟೈಪ್ ವೇರಿಯಬಲ್ T ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ. ನೀವು ಸಂಖ್ಯೆಗಳ ಅರೇಯೊಂದಿಗೆ getFirstElement ಅನ್ನು ಕರೆದಾಗ, T number ಆಗುತ್ತದೆ. ನೀವು ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ ಕರೆದಾಗ, T string ಆಗುತ್ತದೆ. ಇದು ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಮೂಲಭೂತ ಶಕ್ತಿ: ಸುರಕ್ಷತೆಯನ್ನು ತ್ಯಾಗ ಮಾಡದೆ ಟೈಪ್ ಇನ್‌ಫರೆನ್ಸ್ ಮತ್ತು ಮರುಬಳಕೆ.
extends ನೊಂದಿಗೆ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು
ಜೆನೆರಿಕ್ಸ್ ಅಪಾರ ನಮ್ಯತೆಯನ್ನು ಒದಗಿಸುತ್ತಿದ್ದರೂ, ಕೆಲವೊಮ್ಮೆ ನೀವು ಜೆನೆರಿಕ್ ಘಟಕದೊಂದಿಗೆ ಬಳಸಬಹುದಾದ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ಬಂಧಿಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಕಾರ್ಯವು ಜೆನೆರಿಕ್ ಟೈಪ್ T ಯಾವಾಗಲೂ ಒಂದು ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣ ಅಥವಾ ವಿಧಾನವನ್ನು ಹೊಂದಿರಬೇಕೆಂದು ನಿರೀಕ್ಷಿಸಿದರೆ ಏನು? ಇಲ್ಲಿ extends ಕೀವರ್ಡ್ ಬಳಸಿ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತವೆ.
ಒಂದು ಐಟಂನ ID ಯನ್ನು ಲಾಗ್ ಮಾಡುವ ಕಾರ್ಯವನ್ನು ಪರಿಗಣಿಸಿ. ಎಲ್ಲಾ ಪ್ರಕಾರಗಳು id ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ. T ಯಾವಾಗಲೂ number (ಅಥವಾ string, ಅವಶ್ಯಕತೆಗಳ ಆಧಾರದ ಮೇಲೆ) ಪ್ರಕಾರದ id ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು T ಅನ್ನು ನಿರ್ಬಂಧಿಸಬೇಕು.
interface HasId {
id: number;
}
function logId<T extends HasId>(item: T): void {
console.log(`ID: ${item.id}`);
}
// Works correctly
logId({ id: 1, name: 'Product A' }); // ID: 1
logId({ id: 2, quantity: 10 }); // ID: 2
// Error: Argument of type '{ name: string; }' is not assignable to parameter of type 'HasId'.
// Property 'id' is missing in type '{ name: string; }' but required in type 'HasId'.
// logId({ name: 'Product B' });
<T extends HasId> ಅನ್ನು ಬಳಸುವ ಮೂಲಕ, T ಯು HasId ಗೆ ನಿಯೋಜಿಸಬಹುದಾಗಿದೆ ಎಂದು ನಾವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ತಿಳಿಸುತ್ತಿದ್ದೇವೆ. ಇದರರ್ಥ logId ಗೆ ರವಾನಿಸಲಾದ ಯಾವುದೇ ಆಬ್ಜೆಕ್ಟ್ id: number ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಂದಿರಬೇಕು, ಇದು ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ಜೆನೆರಿಕ್ಸ್ ಮತ್ತು ನಿರ್ಬಂಧಗಳ ಈ ಮೂಲಭೂತ ತಿಳುವಳಿಕೆಯು ನಾವು ಹೆಚ್ಚು ಸುಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಿದಾಗ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಆಳವಾಗಿ ಧುಮುಕುವುದು: keyof ಆಪರೇಟರ್
keyof ಆಪರೇಟರ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಒಂದು ಶಕ್ತಿಶಾಲಿ ಸಾಧನವಾಗಿದ್ದು, ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ಎಲ್ಲಾ ಸಾರ್ವಜನಿಕ ಗುಣಲಕ್ಷಣದ ಹೆಸರುಗಳನ್ನು (ಕೀಗಳು) ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಯೂನಿಯನ್ ಪ್ರಕಾರಕ್ಕೆ ಹೊರತೆಗೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದನ್ನು ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ಗಾಗಿ ಎಲ್ಲಾ ಮಾನ್ಯವಾದ ಗುಣಲಕ್ಷಣ ಪ್ರವೇಶಕಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುವಂತೆ ಯೋಚಿಸಿ. ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ, ಕಾನ್ಫಿಗರೇಶನ್ ಮತ್ತು UI ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ, ವಿವಿಧ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಾದ್ಯಂತ ಆಬ್ಜೆಕ್ಟ್ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅತ್ಯಂತ ಹೊಂದಿಕೊಳ್ಳುವ ಆದರೆ ಟೈಪ್-ಸುರಕ್ಷಿತ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸಲು ಇದು ನಂಬಲಾಗದಷ್ಟು ಉಪಯುಕ್ತವಾಗಿದೆ.
keyof ಏನು ಮಾಡುತ್ತದೆ
ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್ T ಗಾಗಿ, keyof T ಯು T ನ ಗುಣಲಕ್ಷಣಗಳ ಹೆಸರುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಪ್ರಕಾರಗಳ ಯೂನಿಯನ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಇದು, "ಈ ಪ್ರಕಾರದ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ನಾನು ಯಾವೆಲ್ಲಾ ಸಂಭವನೀಯ ಕೀಗಳನ್ನು ಬಳಸಬಹುದು?" ಎಂದು ಕೇಳಿದಂತಿದೆ.
ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಮೂಲಭೂತ ಬಳಕೆ
ಸಿಂಟ್ಯಾಕ್ಸ್ ನೇರವಾಗಿದೆ: keyof TypeName.
interface User {
id: number;
name: string;
email?: string;
age: number;
}
type UserKeys = keyof User; // Type is 'id' | 'name' | 'email' | 'age'
const userKey: UserKeys = 'name'; // Valid
// const invalidKey: UserKeys = 'address'; // Error: Type "address" is not assignable to type 'UserKeys'.
class Product {
public productId: string;
private _cost: number;
protected _warehouseId: string;
constructor(id: string, cost: number) {
this.productId = id;
this._cost = cost;
this._warehouseId = 'default';
}
public getCost(): number {
return this._cost;
}
}
type ProductKeys = keyof Product; // Type is 'productId' | 'getCost'
// Note: private and protected members are not included in keyof for classes,
// as they are not publicly accessible keys.
ನೀವು ನೋಡುವಂತೆ, keyof ಎಲ್ಲಾ ಸಾರ್ವಜನಿಕವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದಾದ ಗುಣಲಕ್ಷಣದ ಹೆಸರುಗಳನ್ನು, ವಿಧಾನಗಳು ಸೇರಿದಂತೆ (ಇವು ಕಾರ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಗುಣಲಕ್ಷಣಗಳು) ಸರಿಯಾಗಿ ಗುರುತಿಸುತ್ತದೆ, ಆದರೆ ಖಾಸಗಿ ಮತ್ತು ಸಂರಕ್ಷಿತ ಸದಸ್ಯರನ್ನು ಹೊರತುಪಡಿಸುತ್ತದೆ. ಈ ನಡವಳಿಕೆಯು ಅದರ ಉದ್ದೇಶಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ: ಗುಣಲಕ್ಷಣ ಪ್ರವೇಶಕ್ಕಾಗಿ ಮಾನ್ಯವಾದ ಕೀಗಳನ್ನು ಗುರುತಿಸುವುದು.
ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳಲ್ಲಿ keyof
ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿದಾಗ keyof ನ ನಿಜವಾದ ಶಕ್ತಿ ಪ್ರಕಾಶಿಸುತ್ತದೆ. ಈ ಸಂಯೋಜನೆಯು ಯಾವುದೇ ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಆ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ ನಿಜವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಗುಣಲಕ್ಷಣಗಳ ಮೇಲೆ ಮಾತ್ರ, ಸಂಕಲನ-ಕಾಲದ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಒಂದು ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ: ಆಬ್ಜೆಕ್ಟ್‌ನಿಂದ ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯವನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಪಡೆಯಲು ಒಂದು ಯುಟಿಲಿಟಿ ಕಾರ್ಯ.
ಉದಾಹರಣೆ 1: getProperty ಕಾರ್ಯವನ್ನು ರಚಿಸುವುದು
keyof ಇಲ್ಲದೆ, ನೀವು any ಅಥವಾ ಕಡಿಮೆ ಸುರಕ್ಷಿತ ವಿಧಾನವನ್ನು ಆಶ್ರಯಿಸಬಹುದು:
function getPropertyUnsafe(obj: any, key: string): any {
return obj[key];
}
const myUser = { id: 1, name: 'Charlie' };
const userName = getPropertyUnsafe(myUser, 'name'); // Returns 'Charlie', but type is any
const userAddress = getPropertyUnsafe(myUser, 'address'); // Returns undefined, no compile-time error
ಈಗ, ಈ ಕಾರ್ಯವನ್ನು ದೃಢವಾಗಿಸಲು ಮತ್ತು ಟೈಪ್-ಸುರಕ್ಷಿತವಾಗಿಸಲು keyof ಅನ್ನು ಪರಿಚಯಿಸೋಣ:
/**
* Safely retrieves a property from an object.
* @template T The type of the object.
* @template K The type of the key, constrained to be a key of T.
* @param obj The object to query.
* @param key The key (property name) to retrieve.
* @returns The value of the property at the given key.
*/
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
interface Employee {
employeeId: number;
firstName: string;
lastName: string;
department: string;
}
const employee: Employee = {
employeeId: 101,
firstName: 'Anna',
lastName: 'Johnson',
department: 'Engineering'
};
// Valid usage:
const empFirstName = getProperty(employee, 'firstName'); // type: string, value: 'Anna'
console.log(`Employee First Name: ${empFirstName}`);
const empId = getProperty(employee, 'employeeId'); // type: number, value: 101
console.log(`Employee ID: ${empId}`);
// Invalid usage (compile-time error):
// Argument of type "salary" is not assignable to parameter of type "employeeId" | "firstName" | "lastName" | "department".
// const empSalary = getProperty(employee, 'salary');
interface Configuration {
locale: 'en-US' | 'es-ES' | 'fr-FR';
theme: 'light' | 'dark';
maxItemsPerPage: number;
}
const appConfig: Configuration = {
locale: 'en-US',
theme: 'dark',
maxItemsPerPage: 20
};
const currentTheme = getProperty(appConfig, 'theme'); // type: 'light' | 'dark', value: 'dark'
console.log(`Current Theme: ${currentTheme}`);
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] ಅನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ:
<T>: ಆಬ್ಜೆಕ್ಟ್‌ಗಾಗಿ ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್Tಅನ್ನು ಘೋಷಿಸುತ್ತದೆ.<K extends keyof T>: ಕೀಗಾಗಿ ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್Kಅನ್ನು ಘೋಷಿಸುತ್ತದೆ. ಇದು ನಿರ್ಣಾಯಕ ಭಾಗ. ಇದುKಅನ್ನುTನ ಕೀಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಪ್ರಕಾರಗಳಲ್ಲಿ ಒಂದಾಗಿ ನಿರ್ಬಂಧಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ,TಎಂಬುದುEmployeeಆಗಿದ್ದರೆ, ಆಗKಯು'employeeId' | 'firstName' | 'lastName' | 'department'ಆಗಿರಬೇಕು.(obj: T, key: K): ಕಾರ್ಯದ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು.objTಪ್ರಕಾರದಾಗಿದೆ, ಮತ್ತುkeyKಪ್ರಕಾರದಾಗಿದೆ.: T[K]: ಇದು ಒಂದು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್ (ಇದನ್ನು ನಾವು ಮುಂದೆ ವಿವರವಾಗಿ ಚರ್ಚಿಸುತ್ತೇವೆ), ಇದನ್ನು ಇಲ್ಲಿ ಹಿಂದಿರುಗಿಸುವ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದರರ್ಥ "ಆಬ್ಜೆಕ್ಟ್ ಟೈಪ್Tಒಳಗೆ ಕೀKನಲ್ಲಿರುವ ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರ".TಎಂಬುದುEmployeeಆಗಿದ್ದರೆ ಮತ್ತುKಎಂಬುದು'firstName'ಆಗಿದ್ದರೆ, ಆಗT[K]stringಗೆ ಪರಿಹಾರವಾಗುತ್ತದೆ.Kಎಂಬುದು'employeeId'ಆಗಿದ್ದರೆ, ಅದುnumberಗೆ ಪರಿಹಾರವಾಗುತ್ತದೆ.
keyof ನಿರ್ಬಂಧಗಳ ಪ್ರಯೋಜನಗಳು
- ಸಂಕಲನ-ಕಾಲದ ಸುರಕ್ಷತೆ: ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ, ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
- ಸುಧಾರಿತ ಡೆವಲಪರ್ ಅನುಭವ: ಕಾರ್ಯವನ್ನು ಕರೆದಾಗ ಕೀಗಳಿಗಾಗಿ ಬುದ್ಧಿವಂತ ಸ್ವಯಂಪೂರ್ಣತೆ ಸಲಹೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
- ಹೆಚ್ಚಿದ ಓದುವಿಕೆ: ಕೀಯು ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಸೇರಿದೆ ಎಂದು ಟೈಪ್ ಸಿಗ್ನೇಚರ್ ಸ್ಪಷ್ಟವಾಗಿ ಸಂವಹಿಸುತ್ತದೆ.
- ದೃಢವಾದ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್: ನೀವು
Employeeನಲ್ಲಿ ಗುಣಲಕ್ಷಣವನ್ನು ಮರುಹೆಸರಿಸಿದರೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಹಳೆಯ ಕೀಯನ್ನು ಬಳಸಿಕೊಂಡುgetPropertyಗೆ ಕರೆಗಳನ್ನು ತಕ್ಷಣವೇ ಫ್ಲ್ಯಾಗ್ ಮಾಡುತ್ತದೆ.
ಸುಧಾರಿತ keyof ಸನ್ನಿವೇಶಗಳು
ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವುದು
keyof ಸ್ವತಃ ಒಂದು ಟೈಪ್ ಆಪರೇಟರ್ ಆಗಿದ್ದರೂ, ಆಬ್ಜೆಕ್ಟ್ ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಕಾರ್ಯಗಳನ್ನು ನೀವು ಹೇಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಬಹುದು ಎಂಬುದನ್ನು ಇದು ಆಗಾಗ್ಗೆ ತಿಳಿಸುತ್ತದೆ, ನೀವು ಬಳಸುವ ಕೀಗಳು ಯಾವಾಗಲೂ ಮಾನ್ಯವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
function logAllProperties<T extends object>(obj: T): void {
// Here, Object.keys returns string[], not keyof T, so we often need assertions
// or to be careful. However, keyof T guides our thinking for type safety.
(Object.keys(obj) as Array<keyof T>).forEach(key => {
// We know 'key' is a valid key for 'obj'
console.log(`${String(key)}: ${obj[key]}`);
});
}
interface MenuItem {
id: string;
label: string;
price: number;
available: boolean;
}
const coffee: MenuItem = {
id: 'cappuccino',
label: 'Cappuccino',
price: 4.50,
available: true
};
logAllProperties(coffee);
// Output:
// id: cappuccino
// label: Cappuccino
// price: 4.5
// available: true
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, keyof T ಒಂದು ಪರಿಪೂರ್ಣ ಟೈಪ್-ಸುರಕ್ಷಿತ ಜಗತ್ತಿನಲ್ಲಿ Object.keys *ಏನನ್ನು* ಹಿಂದಿರುಗಿಸಬೇಕು ಎಂಬುದಕ್ಕೆ ಪರಿಕಲ್ಪನಾ ಮಾರ್ಗದರ್ಶಕ ತತ್ವವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಮಗೆ ಆಗಾಗ್ಗೆ as Array<keyof T> ನಂತಹ ಟೈಪ್ ಅಸರ್ಷನ್ ಅಗತ್ಯವಿರುತ್ತದೆ ಏಕೆಂದರೆ Object.keys ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಂಕಲನ-ಕಾಲದ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ಗಿಂತ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಅಂತರ್ಗತವಾಗಿ ಕಡಿಮೆ ಟೈಪ್-ಅರಿವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಇದು ರನ್‌ಟೈಮ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಸಂಕಲನ-ಕಾಲದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ.
ಯೂನಿಯನ್ ಟೈಪ್‌ಗಳೊಂದಿಗೆ keyof
ನೀವು ಯೂನಿಯನ್ ಪ್ರಕಾರಕ್ಕೆ keyof ಅನ್ನು ಅನ್ವಯಿಸಿದಾಗ, ಅದು ಯೂನಿಯನ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಪ್ರಕಾರಗಳಿಂದ ಕೀಗಳ ಛೇದಕವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇದರರ್ಥ ಅದು ಯೂನಿಯನ್‌ನ ಎಲ್ಲಾ ಸದಸ್ಯರಿಗೆ ಸಾಮಾನ್ಯವಾದ ಕೀಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುತ್ತದೆ.
interface Apple {
color: string;
sweetness: number;
}
interface Orange {
color: string;
citrus: boolean;
}
type Fruit = Apple | Orange;
type FruitKeys = keyof Fruit; // Type is 'color'
// 'sweetness' is only in Apple, 'citrus' is only in Orange.
// 'color' is common to both.
ಈ ನಡವಳಿಕೆಯು ನೆನಪಿನಲ್ಲಿಡಲು ಮುಖ್ಯವಾಗಿದೆ, ಏಕೆಂದರೆ FruitKeys ನಿಂದ ಆಯ್ಕೆಮಾಡಿದ ಯಾವುದೇ ಕೀ ಯಾವಾಗಲೂ Fruit ಪ್ರಕಾರದ ಯಾವುದೇ ಆಬ್ಜೆಕ್ಟ್‌ನಲ್ಲಿ (ಅದು Apple ಆಗಿರಲಿ ಅಥವಾ Orange ಆಗಿರಲಿ) ಮಾನ್ಯವಾದ ಗುಣಲಕ್ಷಣವಾಗಿರುತ್ತದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು ಪಾಲಿಮಾರ್ಫಿಕ್ ಡೇಟಾ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
typeof ನೊಂದಿಗೆ keyof
ಒಂದು ಆಬ್ಜೆಕ್ಟ್‌ನ ಪ್ರಕಾರದಿಂದ ನೇರವಾಗಿ ಅದರ ಮೌಲ್ಯದಿಂದ ಕೀಗಳನ್ನು ಹೊರತೆಗೆಯಲು keyof ಅನ್ನು typeof ನೊಂದಿಗೆ ಬಳಸಬಹುದು, ಇದು ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಸ್ಥಿರಾಂಕಗಳಿಗೆ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.
const APP_SETTINGS = {
API_URL: 'https://api.example.com',
TIMEOUT_MS: 5000,
DEBUG_MODE: false
};
type AppSettingKeys = keyof typeof APP_SETTINGS; // Type is 'API_URL' | 'TIMEOUT_MS' | 'DEBUG_MODE'
function getAppSetting<K extends AppSettingKeys>(key: K): (typeof APP_SETTINGS)[K] {
return APP_SETTINGS[key];
}
const apiUrl = getAppSetting('API_URL'); // type: string
const debugMode = getAppSetting('DEBUG_MODE'); // type: boolean
// const invalidSetting = getAppSetting('LOG_LEVEL'); // Error
ಜಾಗತಿಕ ಕಾನ್ಫಿಗರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವಾಗ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಈ ಮಾದರಿಯು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ, ವಿವಿಧ ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು ತಂಡಗಳಾದ್ಯಂತ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ವೈವಿಧ್ಯಮಯ ಕೊಡುಗೆದಾರರನ್ನು ಹೊಂದಿರುವ ದೊಡ್ಡ-ಪ್ರಮಾಣದ ಯೋಜನೆಗಳಲ್ಲಿ ಅಮೂಲ್ಯವಾಗಿದೆ.
ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳನ್ನು (ಲುಕ್‌ಅಪ್ ಟೈಪ್‌ಗಳು) ಅನಾವರಣಗೊಳಿಸುವುದು
keyof ನಿಮಗೆ ಗುಣಲಕ್ಷಣಗಳ ಹೆಸರುಗಳನ್ನು ನೀಡಿದರೆ, ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್ (ಸಾಮಾನ್ಯವಾಗಿ ಲುಕ್‌ಅಪ್ ಟೈಪ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಮತ್ತೊಂದು ಪ್ರಕಾರದಿಂದ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರವನ್ನು ಹೊರತೆಗೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು, "ಈ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರದೊಳಗೆ ಈ ನಿರ್ದಿಷ್ಟ ಕೀಯಲ್ಲಿರುವ ಮೌಲ್ಯದ ಪ್ರಕಾರ ಯಾವುದು?" ಎಂದು ಕೇಳಿದಂತಿದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರಗಳಿಂದ ಪಡೆದ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು, ಮರುಬಳಕೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಟೈಪ್ ಡಿಫಿನಿಷನ್‌ಗಳಲ್ಲಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಈ ಸಾಮರ್ಥ್ಯವು ಮೂಲಭೂತವಾಗಿದೆ.
ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು ಏನು ಮಾಡುತ್ತವೆ
ಒಂದು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್ ಬ್ರಾಕೆಟ್ ನೋಟೇಶನ್ (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸುವಂತೆ) ಅನ್ನು ಟೈಪ್ ಮಟ್ಟದಲ್ಲಿ ಬಳಸಿಕೊಂಡು, ಗುಣಲಕ್ಷಣದ ಕೀಯೊಂದಿಗೆ ಸಂಯೋಜಿತವಾಗಿರುವ ಪ್ರಕಾರವನ್ನು ಹುಡುಕುತ್ತದೆ. ಇತರ ಪ್ರಕಾರಗಳ ರಚನೆಯ ಆಧಾರದ ಮೇಲೆ ಪ್ರಕಾರಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿರ್ಮಿಸಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಮೂಲಭೂತ ಬಳಕೆ
ಸಿಂಟ್ಯಾಕ್ಸ್ TypeName[KeyType] ಆಗಿದೆ, ಇಲ್ಲಿ KeyType ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಟೈಪ್ ಅಥವಾ TypeName ನ ಮಾನ್ಯ ಕೀಗಳಿಗೆ ಅನುಗುಣವಾದ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಪ್ರಕಾರಗಳ ಯೂನಿಯನ್ ಆಗಿದೆ.
interface ProductInfo {
name: string;
price: number;
category: 'Electronics' | 'Apparel' | 'Books';
details: { weight: string; dimensions: string };
}
type ProductNameType = ProductInfo['name']; // Type is string
type ProductPriceType = ProductInfo['price']; // Type is number
type ProductCategoryType = ProductInfo['category']; // Type is 'Electronics' | 'Apparel' | 'Books'
type ProductDetailsType = ProductInfo['details']; // Type is { weight: string; dimensions: string; }
// You can also use a union of keys:
type NameAndPrice = ProductInfo['name' | 'price']; // Type is string | number
// If a key doesn't exist, it's a compile-time error:
// type InvalidType = ProductInfo['nonExistentKey']; // Error: Property 'nonExistentKey' does not exist on type 'ProductInfo'.
ಇದು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರವನ್ನು, ಅಥವಾ ಬಹು ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಪ್ರಕಾರಗಳ ಯೂನಿಯನ್ ಅನ್ನು, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಇಂಟರ್ಫೇಸ್ ಅಥವಾ ಟೈಪ್ ಅಲಿಯಾಸ್‌ನಿಂದ ನಿಖರವಾಗಿ ಹೊರತೆಗೆಯಲು ಹೇಗೆ ಅನುಮತಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ಒಂದು ದೊಡ್ಡ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿವಿಧ ಭಾಗಗಳಾದ್ಯಂತ ಟೈಪ್ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಅಪಾರವಾಗಿ ಮೌಲ್ಯಯುತವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ನ ಭಾಗಗಳನ್ನು ವಿವಿಧ ತಂಡಗಳು ಅಥವಾ ವಿಭಿನ್ನ ಭೌಗೋಳಿಕ ಸ್ಥಳಗಳಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಿದಾಗ.
ಜೆನೆರಿಕ್ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು
ಉದಾಹರಣೆ 2: ಹಿಂದಿರುಗಿಸುವ ಪ್ರಕಾರದಲ್ಲಿ ಇಂಡೆಕ್ಸ್ ಪ್ರವೇಶದೊಂದಿಗೆ getProperty ಕಾರ್ಯವನ್ನು ಮರುಪರಿಶೀಲಿಸಲಾಗಿದೆ
ನಮ್ಮ getProperty ಕಾರ್ಯದೊಂದಿಗೆ ಇದನ್ನು ಈಗಾಗಲೇ ಕಾರ್ಯರೂಪದಲ್ಲಿ ನೋಡಿದ್ದೇವೆ, ಆದರೆ T[K] ನ ಪಾತ್ರವನ್ನು ಪುನರುಚ್ಚರಿಸೋಣ ಮತ್ತು ಒತ್ತಿಹೇಳೋಣ:
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
interface Customer {
id: string;
firstName: string;
lastName: string;
preferences: { email: boolean; sms: boolean };
}
const customer: Customer = {
id: 'cust-123',
firstName: 'Maria',
lastName: 'Gonzales',
preferences: { email: true, sms: false }
};
const customerFirstName = getProperty(customer, 'firstName'); // Type: string, Value: 'Maria'
const customerPreferences = getProperty(customer, 'preferences'); // Type: { email: boolean; sms: boolean; }, Value: { email: true, sms: false }
// You can even access nested properties, but the getProperty function itself
// only works for top-level keys. For nested access, you'd need a more complex generic.
// For example, to get customer.preferences.email, you'd chain calls or use a different utility.
// const customerEmailPref = getProperty(customer.preferences, 'email'); // Type: boolean, Value: true
ಇಲ್ಲಿ, T[K] ಅತ್ಯಂತ ಪ್ರಮುಖವಾಗಿದೆ. getProperty ಕಾರ್ಯದ ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರವು ಆಬ್ಜೆಕ್ಟ್ T ನಲ್ಲಿನ ಗುಣಲಕ್ಷಣ K ಯ ಪ್ರಕಾರಕ್ಕೆ ನಿಖರವಾಗಿ ಸಮನಾಗಿರಬೇಕು ಎಂದು ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ತಿಳಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟ ಕೀಯನ್ನು ಆಧರಿಸಿ ಅದರ ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಕಾರ್ಯವನ್ನು ಅಷ್ಟು ಟೈಪ್-ಸುರಕ್ಷಿತ ಮತ್ತು ಬಹುಮುಖವಾಗಿಸುವ ಅಂಶ ಇದಾಗಿದೆ.
ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರವನ್ನು ಹೊರತೆಗೆಯುವುದು
ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು ಕೇವಲ ಕಾರ್ಯದ ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರಗಳಿಗೆ ಮಾತ್ರವಲ್ಲ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರಗಳ ಭಾಗಗಳ ಆಧಾರದ ಮೇಲೆ ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅವು ನಂಬಲಾಗದಷ್ಟು ಉಪಯುಕ್ತವಾಗಿವೆ. ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುವ ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಬೇಕಾದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ಅಥವಾ ದೊಡ್ಡ ಡೇಟಾ ಮಾದರಿಯಿಂದ ಡೇಟಾದ ಉಪಸಮೂಹವನ್ನು ಮಾತ್ರ ಪ್ರದರ್ಶಿಸುವ UI ಘಟಕಕ್ಕಾಗಿ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಾಗ ಇದು ಸಾಮಾನ್ಯವಾಗಿದೆ.
interface FinancialReport {
reportId: string;
dateGenerated: Date;
totalRevenue: number;
expenses: number;
profit: number;
currency: 'USD' | 'EUR' | 'JPY';
}
type EssentialReportInfo = {
reportId: FinancialReport['reportId'];
date: FinancialReport['dateGenerated'];
currency: FinancialReport['currency'];
};
const summary: EssentialReportInfo = {
reportId: 'FR-2023-Q4',
date: new Date(),
currency: 'EUR' // This is type-checked correctly
};
// We can also create a type for a property's value using a type alias:
type CurrencyType = FinancialReport['currency']; // Type is 'USD' | 'EUR' | 'JPY'
function formatAmount(amount: number, currency: CurrencyType): string {
return `${amount.toFixed(2)} ${currency}`;
}
console.log(formatAmount(1234.56, 'USD')); // 1234.56 USD
// console.log(formatAmount(789.00, 'GBP')); // Error: Type "GBP" is not assignable to type 'CurrencyType'.
ಇದು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳನ್ನು ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ನಿರೀಕ್ಷಿತ ಪ್ರಕಾರವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ, ನಿಮ್ಮ ಸಿಸ್ಟಂನ ವಿವಿಧ ಭಾಗಗಳು ಸ್ಥಿರವಾದ ವ್ಯಾಖ್ಯಾನಗಳಿಗೆ ಅಂಟಿಕೊಂಡಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ದೊಡ್ಡ, ವಿತರಿಸಿದ ಅಭಿವೃದ್ಧಿ ತಂಡಗಳಿಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಸುಧಾರಿತ ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್ ಸನ್ನಿವೇಶಗಳು
ಯೂನಿಯನ್ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಇಂಡೆಕ್ಸ್ ಪ್ರವೇಶ
ನೀವು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ನಲ್ಲಿ ಕೀಯಾಗಿ ಲಿಟರಲ್ ಪ್ರಕಾರಗಳ ಯೂನಿಯನ್ ಅನ್ನು ಬಳಸಿದಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಯೂನಿಯನ್‌ನಲ್ಲಿನ ಪ್ರತಿ ಕೀಗೆ ಅನುಗುಣವಾದ ಗುಣಲಕ್ಷಣ ಪ್ರಕಾರಗಳ ಯೂನಿಯನ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
interface EventData {
type: 'click' | 'submit' | 'scroll';
timestamp: number;
userId: string;
target?: HTMLElement;
value?: string;
}
type EventIdentifiers = EventData['type' | 'userId']; // Type is 'click' | 'submit' | 'scroll' | string
// Because 'type' is a union of string literals, and 'userId' is a string,
// the resulting type is 'click' | 'submit' | 'scroll' | string, which simplifies to string.
// Let's refine for a more illustrative example:
interface Book {
title: string;
author: string;
pages: number;
isAvailable: boolean;
}
type BookStringOrNumberProps = Book['title' | 'author' | 'pages']; // Type is string | number
// 'title' is string, 'author' is string, 'pages' is number.
// The union of these is string | number.
ಇದು "ಈ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ಒಂದು" ಪ್ರತಿನಿಧಿಸುವ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ಒಂದು ಶಕ್ತಿಶಾಲಿ ಮಾರ್ಗವಾಗಿದೆ, ಇದು ಹೊಂದಿಕೊಳ್ಳುವ ಡೇಟಾ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ನಿಭಾಯಿಸುವಾಗ ಅಥವಾ ಜೆನೆರಿಕ್ ಡೇಟಾ-ಬೈಂಡಿಂಗ್ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ಉಪಯುಕ್ತವಾಗಿದೆ.
ಷರತ್ತುಬದ್ಧ ಪ್ರಕಾರಗಳು ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಪ್ರವೇಶ
ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಷರತ್ತುಬದ್ಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಟೈಪ್ ಟ್ರಾನ್ಸ್‌ಫರ್ಮೇಷನ್‌ಗಳನ್ನು ರಚಿಸುತ್ತವೆ. ಷರತ್ತುಬದ್ಧ ಪ್ರಕಾರಗಳು ಒಂದು ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ.
interface Device {
id: string;
name: string;
firmwareVersion: string;
lastPing: Date;
isOnline: boolean;
}
// Type that extracts only string properties from a given object type T
type StringProperties<T> = {
[K in keyof T]: T[K] extends string ? K : never;
}[keyof T];
type DeviceStringKeys = StringProperties<Device>; // Type is 'id' | 'name' | 'firmwareVersion'
// This creates a new type that contains only the string properties of Device
type DeviceStringsOnly = Pick<Device, DeviceStringKeys>;
/*
Equivalent to:
interface DeviceStringsOnly {
id: string;
name: string;
firmwareVersion: string;
}
*/
const myDeviceStrings: DeviceStringsOnly = {
id: 'dev-001',
name: 'Sensor Unit Alpha',
firmwareVersion: '1.2.3'
};
// myDeviceStrings.isOnline; // Error: Property 'isOnline' does not exist on type 'DeviceStringsOnly'.
ಈ ಸುಧಾರಿತ ಮಾದರಿಯು keyof (K in keyof T ನಲ್ಲಿ) ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು (T[K]) ಷರತ್ತುಬದ್ಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ (extends string ? K : never) ಹೇಗೆ ಒಟ್ಟಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಅತ್ಯಾಧುನಿಕ ಟೈಪ್ ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಟ್ರಾನ್ಸ್‌ಫರ್ಮೇಷನ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು. ಈ ರೀತಿಯ ಸುಧಾರಿತ ಟೈಪ್ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲ API ಗಳು ಮತ್ತು ಯುಟಿಲಿಟಿ ಲೈಬ್ರರಿಗಳನ್ನು ರಚಿಸಲು ಅಮೂಲ್ಯವಾಗಿದೆ.
keyof ಆಪರೇಟರ್ ವರ್ಸಸ್ ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು: ನೇರ ಹೋಲಿಕೆ
ಈ ಹಂತದಲ್ಲಿ, keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳ ವಿಭಿನ್ನ ಪಾತ್ರಗಳ ಬಗ್ಗೆ ಮತ್ತು ಪ್ರತಿಯೊಂದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕೆಂದು ನೀವು ಆಶ್ಚರ್ಯಪಡಬಹುದು. ಅವು ಆಗಾಗ್ಗೆ ಒಟ್ಟಾಗಿ ಕಾಣಿಸಿಕೊಂಡರೂ, ಅವುಗಳ ಮೂಲಭೂತ ಉದ್ದೇಶಗಳು ವಿಭಿನ್ನವಾಗಿವೆ ಆದರೆ ಪರಸ್ಪರ ಪೂರಕವಾಗಿವೆ.
ಅವು ಏನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ
keyof T:Tನ ಗುಣಲಕ್ಷಣಗಳ ಹೆಸರುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ ಪ್ರಕಾರಗಳ ಯೂನಿಯನ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇದು ನಿಮಗೆ ಗುಣಲಕ್ಷಣಗಳ "ಲೇಬಲ್‌ಗಳು" ಅಥವಾ "ಗುರುತುಗಳನ್ನು" ನೀಡುತ್ತದೆ.T[K](ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್):Tಪ್ರಕಾರದೊಳಗೆKಕೀಯೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಮೌಲ್ಯದ ಪ್ರಕಾರವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇದು ನಿಮಗೆ ನಿರ್ದಿಷ್ಟ ಲೇಬಲ್‌ನಲ್ಲಿ "ವಿಷಯದ ಪ್ರಕಾರ" ವನ್ನು ನೀಡುತ್ತದೆ.
ಪ್ರತಿಯೊಂದನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು
- ನೀವು ಈ ಕೆಳಗಿನವುಗಳು ಅಗತ್ಯವಿದ್ದಾಗ
keyofಅನ್ನು ಬಳಸಿ:- ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಮತ್ತೊಂದು ಪ್ರಕಾರದ ಮಾನ್ಯ ಗುಣಲಕ್ಷಣದ ಹೆಸರಾಗಿ ನಿರ್ಬಂಧಿಸಲು (ಉದಾಹರಣೆಗೆ,
K extends keyof T). - ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಕ್ಕಾಗಿ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಗುಣಲಕ್ಷಣದ ಹೆಸರುಗಳನ್ನು ಎಣಿಸಲು.
Pick,Omit, ಅಥವಾ ಕಸ್ಟಮ್ ಮ್ಯಾಪಿಂಗ್ ಪ್ರಕಾರಗಳಂತಹ ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು.
- ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಮತ್ತೊಂದು ಪ್ರಕಾರದ ಮಾನ್ಯ ಗುಣಲಕ್ಷಣದ ಹೆಸರಾಗಿ ನಿರ್ಬಂಧಿಸಲು (ಉದಾಹರಣೆಗೆ,
- ನೀವು ಈ ಕೆಳಗಿನವುಗಳು ಅಗತ್ಯವಿದ್ದಾಗ ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳನ್ನು (
T[K]) ಬಳಸಿ:- ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರದಿಂದ ಗುಣಲಕ್ಷಣದ ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವನ್ನು ಹಿಂಪಡೆಯಲು.
- ಆಬ್ಜೆಕ್ಟ್ ಮತ್ತು ಕೀಯ ಆಧಾರದ ಮೇಲೆ ಕಾರ್ಯದ ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರವನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿರ್ಧರಿಸಲು (ಉದಾಹರಣೆಗೆ,
getPropertyನ ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರ). - ಇತರ ಪ್ರಕಾರಗಳಿಂದ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣ ಪ್ರಕಾರಗಳಿಂದ ಕೂಡಿದ ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು.
- ಟೈಪ್-ಲೆವೆಲ್ ಲುಕ್‌ಅಪ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು.
ವ್ಯತ್ಯಾಸವು ಸೂಕ್ಷ್ಮ ಆದರೆ ನಿರ್ಣಾಯಕ: keyof ಎಂಬುದು *ಕೀಗಳ* ಬಗ್ಗೆ, ಆದರೆ ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು ಆ ಕೀಗಳಲ್ಲಿನ *ಮೌಲ್ಯಗಳ ಪ್ರಕಾರಗಳ* ಬಗ್ಗೆ.
ಸಿನರ್ಜಿಸ್ಟಿಕ್ ಶಕ್ತಿ: keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳನ್ನು ಒಟ್ಟಾಗಿ ಬಳಸುವುದು
ಈ ಪರಿಕಲ್ಪನೆಗಳ ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಅವುಗಳನ್ನು ಸಂಯೋಜಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಇದರ ಆದರ್ಶ ಉದಾಹರಣೆ ನಮ್ಮ getProperty ಕಾರ್ಯ:
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
ಈ ಸಿಗ್ನೇಚರ್ ಅನ್ನು ಮತ್ತೊಮ್ಮೆ ವಿಶ್ಲೇಷಿಸೋಣ, ಸಿನರ್ಜಿಯನ್ನು ಪ್ರಶಂಸಿಸುತ್ತಾ:
<T>: ಆಬ್ಜೆಕ್ಟ್‌ಗಾಗಿ ಜೆನೆರಿಕ್ ಟೈಪ್Tಅನ್ನು ಪರಿಚಯಿಸುತ್ತೇವೆ. ಇದು ಕಾರ್ಯವು *ಯಾವುದೇ* ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ.<K extends keyof T>: ಗುಣಲಕ್ಷಣ ಕೀಗಾಗಿ ಎರಡನೇ ಜೆನೆರಿಕ್ ಟೈಪ್Kಅನ್ನು ಪರಿಚಯಿಸುತ್ತೇವೆ.extends keyof Tನಿರ್ಬಂಧವು ಅತ್ಯಗತ್ಯ; ಇದು ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಲಾದkeyಆರ್ಗ್ಯುಮೆಂಟ್objನ ಮಾನ್ಯ ಗುಣಲಕ್ಷಣದ ಹೆಸರಾಗಿರಬೇಕು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇಲ್ಲಿkeyofಇಲ್ಲದೆ,Kಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್ ಆಗಿರಬಹುದು, ಇದು ಕಾರ್ಯವನ್ನು ಅಸುರಕ್ಷಿತಗೊಳಿಸುತ್ತದೆ.(obj: T, key: K): ಕಾರ್ಯದ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳುTಮತ್ತುKಪ್ರಕಾರಗಳಾಗಿವೆ.: T[K]: ಇದು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್. ಇದು ಹಿಂದಿರುಗಿಸುವ ಪ್ರಕಾರವನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿರ್ಧರಿಸುತ್ತದೆ.KಎಂಬುದುTನ ಕೀ ಎಂದು ನಿರ್ಬಂಧಿತವಾಗಿರುವುದರಿಂದ,T[K]ಆ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣದಲ್ಲಿನ ಮೌಲ್ಯದ ಪ್ರಕಾರವನ್ನು ನಿಖರವಾಗಿ ನೀಡುತ್ತದೆ. ಹಿಂದಿರುಗಿಸುವ ಮೌಲ್ಯಕ್ಕಾಗಿ ಬಲವಾದ ಟೈಪ್ ಇನ್‌ಫರೆನ್ಸ್ ಅನ್ನು ಒದಗಿಸುವ ಅಂಶ ಇದಾಗಿದೆ.T[K]ಇಲ್ಲದೆ, ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರವುanyಅಥವಾ ವಿಶಾಲವಾದ ಪ್ರಕಾರವಾಗಿರುತ್ತದೆ, ಇದು ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ.
ಈ ಮಾದರಿಯು ಸುಧಾರಿತ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಮೂಲಾಧಾರವಾಗಿದೆ. ನಂಬಲಾಗದಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವ (ಯಾವುದೇ ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದು) ಮತ್ತು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಟೈಪ್-ಸುರಕ್ಷಿತ (ಮಾನ್ಯ ಕೀಗಳನ್ನು ಮಾತ್ರ ಅನುಮತಿಸುವುದು ಮತ್ತು ನಿಖರವಾದ ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರಗಳನ್ನು ಊಹಿಸುವುದು) ಕಾರ್ಯಗಳು ಮತ್ತು ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ಇದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ಮಿಸುವುದು
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅನೇಕ ಅಂತರ್ಗತ ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳು, ಉದಾಹರಣೆಗೆ Pick<T, K> ಮತ್ತು Omit<T, K>, ಆಂತರಿಕವಾಗಿ keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ. Pick ನ ಸರಳೀಕೃತ ಆವೃತ್ತಿಯನ್ನು ನೀವು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಎಂದು ನೋಡೋಣ:
/**
* Constructs a type by picking the set of properties K from Type T.
* @template T The original type.
* @template K The union of keys to pick, which must be keys of T.
*/
type MyPick<T, K extends keyof T> = {
[P in K]: T[P];
};
interface ServerLog {
id: string;
timestamp: Date;
level: 'info' | 'warn' | 'error';
message: string;
sourceIp: string;
userId?: string;
}
type CriticalLogInfo = MyPick<ServerLog, 'id' | 'timestamp' | 'level' | 'message'>;
/*
Equivalent to:
interface CriticalLogInfo {
id: string;
timestamp: Date;
level: 'info' | 'warn' | 'error';
message: string;
}
*/
const errorLog: CriticalLogInfo = {
id: 'log-001',
timestamp: new Date(),
level: 'error',
message: 'Database connection failed'
};
// errorLog.sourceIp; // Error: Property 'sourceIp' does not exist on type 'CriticalLogInfo'.
MyPick<T, K extends keyof T> ನಲ್ಲಿ:
K extends keyof T: ನಾವು ಆಯ್ಕೆ ಮಾಡಲು ಬಯಸುವ ಕೀಗಳು (K) ಮೂಲ ಪ್ರಕಾರTನ ಮಾನ್ಯ ಕೀಗಳಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.[P in K]: ಇದು ಒಂದು ಮ್ಯಾಪ್ ಮಾಡಿದ ಪ್ರಕಾರ. ಇದು ಯೂನಿಯನ್ ಪ್ರಕಾರKಒಳಗೆ ಪ್ರತಿ ಲಿಟರಲ್ ಪ್ರಕಾರPಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ.T[P]: ಪ್ರತಿ ಕೀPಗಾಗಿ, ಇದು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೂಲ ಪ್ರಕಾರTನಿಂದ ಅನುಗುಣವಾದ ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರವನ್ನು ಪಡೆಯುತ್ತದೆ.
ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರಗಳ ಭಾಗಗಳನ್ನು ನಿಖರವಾಗಿ ಆಯ್ಕೆ ಮಾಡುವ ಮತ್ತು ಹೊರತೆಗೆಯುವ ಮೂಲಕ ಹೊಸ, ಟೈಪ್-ಸುರಕ್ಷಿತ ರಚನೆಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಸಂಯೋಜಿತ ಶಕ್ತಿಯನ್ನು ಈ ಉದಾಹರಣೆಯು ಸುಂದರವಾಗಿ ವಿವರಿಸುತ್ತದೆ. ಅಂತಹ ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳು ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗಳಾದ್ಯಂತ ಡೇಟಾ ಸ್ಥಿರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಅಮೂಲ್ಯವಾಗಿವೆ, ವಿಶೇಷವಾಗಿ ವಿವಿಧ ಘಟಕಗಳು (ಉದಾಹರಣೆಗೆ, ಫ್ರಂಟ್‌ಎಂಡ್ UI, ಬ್ಯಾಕೆಂಡ್ ಸೇವೆ, ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್) ಹಂಚಿದ ಡೇಟಾ ಮಾದರಿಯ ವಿವಿಧ ಉಪಸಮೂಹಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿದಾಗ.
`Record` ಪ್ರಕಾರಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸುವುದು
Record<K, T> ಯುಟಿಲಿಟಿ ಟೈಪ್ ಮತ್ತೊಂದು ಶಕ್ತಿಶಾಲಿ ಅಂತರ್ಗತ ಪ್ರಕಾರವಾಗಿದ್ದು, ಅದರ ಗುಣಲಕ್ಷಣದ ಕೀಗಳು K ಪ್ರಕಾರದ ಮತ್ತು ಅದರ ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯಗಳು T ಪ್ರಕಾರದ ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರವನ್ನು ರಚಿಸುತ್ತದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರದಿಂದ ಕೀಗಳನ್ನು ಪಡೆಯುವ ನಿಘಂಟುಗಳು ಅಥವಾ ನಕ್ಷೆಗಳಿಗಾಗಿ ಪ್ರಕಾರಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸಲು ನೀವು keyof ಅನ್ನು Record ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು.
interface Permissions {
read: boolean;
write: boolean;
execute: boolean;
admin: boolean;
}
// Create a type that maps each permission key to a 'PermissionStatus'
type PermissionStatus = 'granted' | 'denied' | 'pending';
type PermissionsMapping = Record<keyof Permissions, PermissionStatus>;
/*
Equivalent to:
{
read: 'granted' | 'denied' | 'pending';
write: 'granted' | 'denied' | 'pending';
execute: 'granted' | 'denied' | 'pending';
admin: 'granted' | 'denied' | 'pending';
}
*/
const userPermissions: PermissionsMapping = {
read: 'granted',
write: 'denied',
execute: 'pending',
admin: 'denied'
};
// userPermissions.delete = 'granted'; // Error: Property 'delete' does not exist on type 'PermissionsMapping'.
ಈ ಮಾದರಿಯು ಲುಕ್‌ಅಪ್ ಟೇಬಲ್‌ಗಳು, ಸ್ಥಿತಿ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳು ಅಥವಾ ಪ್ರವೇಶ ನಿಯಂತ್ರಣ ಪಟ್ಟಿಗಳನ್ನು ರಚಿಸಲು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಕೀಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡೇಟಾ ಮಾದರಿ ಗುಣಲಕ್ಷಣಗಳು ಅಥವಾ ಕ್ರಿಯಾತ್ಮಕ ಸಾಮರ್ಥ್ಯಗಳಿಗೆ ನೇರವಾಗಿ ಸಂಬಂಧಿಸಿರುತ್ತವೆ.
keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಪ್ರವೇಶದೊಂದಿಗೆ ಮ್ಯಾಪಿಂಗ್ ಪ್ರಕಾರಗಳು
ಮ್ಯಾಪಿಂಗ್ ಪ್ರಕಾರಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರದ ಪ್ರತಿ ಗುಣಲಕ್ಷಣವನ್ನು ಹೊಸ ಪ್ರಕಾರವಾಗಿ ಪರಿವರ್ತಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ. ಇಲ್ಲಿ keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು ನಿಜವಾಗಿಯೂ ಪ್ರಕಾಶಿಸುತ್ತವೆ, ಸಂಕೀರ್ಣ ಟೈಪ್ ಡೆರಿವೇಶನ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತವೆ. ಆಬ್ಜೆಕ್ಟ್‌ನ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣವಾಗಿದೆ, ಇದು API ವಿನ್ಯಾಸ ಅಥವಾ ಈವೆಂಟ್-ಚಾಲಿತ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಲ್ಲಿ ಸಾಮಾನ್ಯ ಮಾದರಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ: `MapToPromises<T>`
ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರ T ಅನ್ನು ತೆಗೆದುಕೊಂಡು, ಪ್ರತಿ ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯವು Promise ನಲ್ಲಿ ಸುತ್ತುವರಿಯಲ್ಪಟ್ಟಿರುವ ಹೊಸ ಪ್ರಕಾರವಾಗಿ ಅದನ್ನು ಪರಿವರ್ತಿಸುವ ಯುಟಿಲಿಟಿ ಪ್ರಕಾರವನ್ನು ರಚಿಸೋಣ.
/**
* Transforms an object type T into a new type where each property's value
* is wrapped in a Promise.
* @template T The original object type.
*/
type MapToPromises<T> = {
[P in keyof T]: Promise<T[P]>;
};
interface UserData {
id: string;
username: string;
email: string;
age: number;
}
type AsyncUserData = MapToPromises<UserData>;
/*
Equivalent to:
interface AsyncUserData {
id: Promise<string>;
username: Promise<string>;
email: Promise<string>;
age: Promise<number>;
}
*/
// Example usage:
async function fetchUserData(): Promise<AsyncUserData> {
return {
id: Promise.resolve('user-abc'),
username: Promise.resolve('global_dev'),
email: Promise.resolve('global.dev@example.com'),
age: Promise.resolve(30)
};
}
async function displayUser() {
const data = await fetchUserData();
const username = await data.username;
console.log(`Fetched Username: ${username}`); // Fetched Username: global_dev
const email = await data.email;
// console.log(email.toUpperCase()); // This would be type-safe (string methods available)
}
displayUser();
MapToPromises<T> ನಲ್ಲಿ:
[P in keyof T]: ಇದು ಇನ್‌ಪುಟ್ ಪ್ರಕಾರTನಿಂದ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣದ ಕೀಗಳುPಮೇಲೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ.keyof Tಎಲ್ಲಾ ಗುಣಲಕ್ಷಣದ ಹೆಸರುಗಳ ಯೂನಿಯನ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.Promise<T[P]>: ಪ್ರತಿ ಕೀPಗಾಗಿ, ಇದು ಮೂಲ ಗುಣಲಕ್ಷಣದ ಪ್ರಕಾರT[P](ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್ ಬಳಸಿ) ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನುPromiseನಲ್ಲಿ ಸುತ್ತುವರಿಯುತ್ತದೆ.
ಇದು keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳು ಸಂಕೀರ್ಣ ಟೈಪ್ ಟ್ರಾನ್ಸ್‌ಫರ್ಮೇಷನ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಹೇಗೆ ಒಟ್ಟಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದಕ್ಕೆ ಒಂದು ಶಕ್ತಿಶಾಲಿ ಪ್ರದರ್ಶನವಾಗಿದೆ, ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು, ಡೇಟಾ ಕ್ಯಾಶಿಂಗ್ ಅಥವಾ ಗುಣಲಕ್ಷಣಗಳ ಪ್ರಕಾರವನ್ನು ಸ್ಥಿರವಾಗಿ ಬದಲಾಯಿಸುವ ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಸನ್ನಿವೇಶಕ್ಕಾಗಿ ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಮತ್ತು ಟೈಪ್-ಸುರಕ್ಷಿತ API ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ವಿತರಿಸಿದ ವ್ಯವಸ್ಥೆಗಳು ಮತ್ತು ಮೈಕ್ರೋಸರ್ವಿಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಲ್ಲಿ ಡೇಟಾ ಆಕಾರಗಳು ವಿಭಿನ್ನ ಸೇವಾ ಗಡಿಗಳಾದ್ಯಂತ ಹೊಂದಿಕೊಳ್ಳಬೇಕಾದಾಗ ಅಂತಹ ಟೈಪ್ ಟ್ರಾನ್ಸ್‌ಫರ್ಮೇಷನ್‌ಗಳು ನಿರ್ಣಾಯಕವಾಗಿವೆ.
ತೀರ್ಮಾನ: ಟೈಪ್ ಸುರಕ್ಷತೆ ಮತ್ತು ನಮ್ಯತೆಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು
keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳ ನಮ್ಮ ಆಳವಾದ ಪರಿಶೀಲನೆಯು ಅವುಗಳನ್ನು ವೈಯಕ್ತಿಕ ವೈಶಿಷ್ಟ್ಯಗಳಾಗಿ ಮಾತ್ರವಲ್ಲದೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸುಧಾರಿತ ಜೆನೆರಿಕ್ ಸಿಸ್ಟಮ್‌ನ ಪೂರಕ ಸ್ತಂಭಗಳಾಗಿ ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ. ನಂಬಲಾಗದಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮತ್ತು, ಮುಖ್ಯವಾಗಿ, ಟೈಪ್-ಸುರಕ್ಷಿತ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಅವು ಪ್ರಪಂಚದಾದ್ಯಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅಧಿಕಾರ ನೀಡುತ್ತವೆ. ಸಂಕೀರ್ಣ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು, ವೈವಿಧ್ಯಮಯ ತಂಡಗಳು ಮತ್ತು ಜಾಗತಿಕ ಸಹಯೋಗದ ಯುಗದಲ್ಲಿ, ಸಂಕಲನ-ಕಾಲದಲ್ಲಿ ಕೋಡ್ ಗುಣಮಟ್ಟ ಮತ್ತು ಭವಿಷ್ಯದ ಸಾಮರ್ಥ್ಯವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಅತ್ಯುನ್ನತವಾಗಿದೆ. ಈ ಸುಧಾರಿತ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು ಆ ಪ್ರಯತ್ನದಲ್ಲಿ ಅಗತ್ಯ ಸಾಧನಗಳಾಗಿವೆ.
keyof ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವ ಮೂಲಕ, ಗುಣಲಕ್ಷಣದ ಹೆಸರುಗಳನ್ನು ನಿಖರವಾಗಿ ಉಲ್ಲೇಖಿಸಲು ಮತ್ತು ನಿರ್ಬಂಧಿಸಲು ನೀವು ಸಾಮರ್ಥ್ಯವನ್ನು ಪಡೆಯುತ್ತೀರಿ, ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಕಾರ್ಯಗಳು ಮತ್ತು ಪ್ರಕಾರಗಳು ಆಬ್ಜೆಕ್ಟ್‌ನ ಮಾನ್ಯ ಭಾಗಗಳ ಮೇಲೆ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಏಕಕಾಲದಲ್ಲಿ, ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳನ್ನು (T[K]) ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಆ ಗುಣಲಕ್ಷಣಗಳ ಪ್ರಕಾರಗಳನ್ನು ನಿಖರವಾಗಿ ಹೊರತೆಗೆಯಲು ಮತ್ತು ಪಡೆಯಲು ನೀವು ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್‌ಲಾಕ್ ಮಾಡುತ್ತೀರಿ, ನಿಮ್ಮ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ ಮಾಡುತ್ತದೆ.
keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳ ನಡುವಿನ ಸಿನರ್ಜಿ, getProperty ಕಾರ್ಯ ಮತ್ತು MyPick ಅಥವಾ MapToPromises ನಂತಹ ಕಸ್ಟಮ್ ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳಂತಹ ಮಾದರಿಗಳಲ್ಲಿ ಉದಾಹರಿಸಲ್ಪಟ್ಟಂತೆ, ಟೈಪ್-ಲೆವೆಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಗಮನಾರ್ಹ ಪ್ರಗತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಈ ತಂತ್ರಗಳು ಡೇಟಾವನ್ನು ಸರಳವಾಗಿ ವಿವರಿಸುವುದನ್ನು ಮೀರಿ, ಪ್ರಕಾರಗಳನ್ನು ಸಕ್ರಿಯವಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ಪರಿವರ್ತಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಇದು ಹೆಚ್ಚು ದೃಢವಾದ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಮತ್ತು ಹೆಚ್ಚು ವರ್ಧಿತ ಡೆವಲಪರ್ ಅನುಭವಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಕಾರ್ಯಸಾಧ್ಯವಾದ ಒಳನೋಟಗಳು:
- ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಿ: ಸರಳ ಕಾರ್ಯಗಳಿಗೂ ಸಹ ಜೆನೆರಿಕ್ಸ್‌ಗಳನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿ. ನೀವು ಅವುಗಳನ್ನು ಮೊದಲೇ ಪರಿಚಯಿಸಿದಷ್ಟೂ, ಅವು ಹೆಚ್ಚು ಸಹಜವಾಗಿ ಆಗುತ್ತವೆ.
- ನಿರ್ಬಂಧಗಳಲ್ಲಿ ಯೋಚಿಸಿ: ನೀವು ಜೆನೆರಿಕ್ ಕಾರ್ಯವನ್ನು ಬರೆದಾಗಲೆಲ್ಲಾ, ನಿಮ್ಮನ್ನು ಕೇಳಿಕೊಳ್ಳಿ: "ಈ ಕಾರ್ಯವು ಕಾರ್ಯನಿರ್ವಹಿಸಲು
Tಗೆ ಯಾವ ಗುಣಲಕ್ಷಣಗಳು ಅಥವಾ ವಿಧಾನಗಳು *ಅಗತ್ಯವಿದೆ*?" ಇದು ನೈಸರ್ಗಿಕವಾಗಿ ನಿಮ್ಮನ್ನುextendsಷರತ್ತುಗಳು ಮತ್ತುkeyofಕಡೆಗೆ ಕರೆದೊಯ್ಯುತ್ತದೆ. - ಇಂಡೆಕ್ಸ್ ಪ್ರವೇಶವನ್ನು ಹೆಚ್ಚಿಸಿಕೊಳ್ಳಿ: ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಕಾರ್ಯದ ಹಿಂತಿರುಗಿಸುವ ಪ್ರಕಾರ (ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಪ್ರಕಾರ) ಮತ್ತೊಂದು ಜೆನೆರಿಕ್ ಪ್ರಕಾರದ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣವನ್ನು ಅವಲಂಬಿಸಿದಾಗ,
T[K]ಎಂದು ಯೋಚಿಸಿ. - ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳನ್ನು ಅನ್ವೇಷಿಸಿ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಂತರ್ಗತ ಯುಟಿಲಿಟಿ ಪ್ರಕಾರಗಳೊಂದಿಗೆ (
Pick,Omit,Record,Partial,Required) ಪರಿಚಿತರಾಗಿ ಮತ್ತು ಅವು ಈ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಹೇಗೆ ಬಳಸುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ನಿಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ದೃಢೀಕರಿಸಲು ಸರಳೀಕೃತ ಆವೃತ್ತಿಗಳನ್ನು ಮರುಸೃಷ್ಟಿಸಲು ಪ್ರಯತ್ನಿಸಿ. - ನಿಮ್ಮ ಪ್ರಕಾರಗಳನ್ನು ದಾಖಲಿಸಿ: ಸಂಕೀರ್ಣ ಜೆನೆರಿಕ್ ಪ್ರಕಾರಗಳಿಗಾಗಿ, ವಿಶೇಷವಾಗಿ ಹಂಚಿದ ಲೈಬ್ರರಿಗಳಲ್ಲಿ, ಅವುಗಳ ಉದ್ದೇಶ ಮತ್ತು ಜೆನೆರಿಕ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೇಗೆ ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ ಮತ್ತು ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುವ ಸ್ಪಷ್ಟ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಒದಗಿಸಿ. ಇದು ಅಂತರರಾಷ್ಟ್ರೀಯ ತಂಡದ ಸಹಯೋಗಕ್ಕೆ ಗಮನಾರ್ಹವಾಗಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳೊಂದಿಗೆ ಅಭ್ಯಾಸ ಮಾಡಿ: ಈ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ನಿಮ್ಮ ದೈನಂದಿನ ಕೋಡಿಂಗ್ ಸವಾಲುಗಳಿಗೆ ಅನ್ವಯಿಸಿ – ಅದು ಹೊಂದಿಕೊಳ್ಳುವ ಡೇಟಾ ಗ್ರಿಡ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು, ಟೈಪ್-ಸುರಕ್ಷಿತ ಕಾನ್ಫಿಗರೇಶನ್ ಲೋಡರ್ ಅನ್ನು ರಚಿಸುವುದು ಅಥವಾ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ API ಕ್ಲೈಂಟ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು.
keyof ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಆಕ್ಸೆಸ್ ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಸುಧಾರಿತ ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಕೇವಲ ಹೆಚ್ಚು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯುವುದರ ಬಗ್ಗೆ ಅಲ್ಲ; ಇದು ಎಲ್ಲಾ ಡೊಮೇನ್‌ಗಳು ಮತ್ತು ಭೌಗೋಳಿಕ ಪ್ರದೇಶಗಳಾದ್ಯಂತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ವಿಶ್ವಾಸದಿಂದ ಶಕ್ತಿ ನೀಡುವ ಉತ್ತಮ, ಸುರಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಬರೆಯುವುದರ ಬಗ್ಗೆ. ಪ್ರಯೋಗವನ್ನು ಮುಂದುವರಿಸಿ, ಕಲಿಕೆಯನ್ನು ಮುಂದುವರಿಸಿ, ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ನ ಸಂಪೂರ್ಣ ಬಲದೊಂದಿಗೆ ನಿಮ್ಮ ಜಾಗತಿಕ ಅಭಿವೃದ್ಧಿ ಪ್ರಯತ್ನಗಳನ್ನು ಸಶಕ್ತಗೊಳಿಸಿ!