ಸೂಚ್ಯಂಕ ಸಹಿಗಳು: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಡೈನಾಮಿಕ್ ಗುಣಲಕ್ಷಣ ಪ್ರಕಾರ ವ್ಯಾಖ್ಯಾನಗಳು

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

ಸೂಚ್ಯಂಕ ಸಹಿಗಳು ಎಂದರೇನು?

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

ಅಂತರರಾಷ್ಟ್ರೀಯ ಅಪ್ಲಿಕೇಶನ್‌ನ ಬ್ಯಾಕೆಂಡ್‌ನಿಂದ ನೀವು ಕಾನ್ಫಿಗರೇಶನ್ ಡೇಟಾವನ್ನು ತರುತ್ತಿದ್ದೀರಿ ಎಂದು ಪರಿಗಣಿಸಿ. ಈ ಡೇಟಾವು ವಿಭಿನ್ನ ಭಾಷೆಗಳಿಗಾಗಿ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಅಲ್ಲಿ ಕೀಲಿಗಳು ಭಾಷಾ ಕೋಡ್‌ಗಳಾಗಿವೆ (ಉದಾ 'en', 'fr', 'es-MX') ಮತ್ತು ಮೌಲ್ಯಗಳು ಸ್ಥಳೀಯ ಪಠ್ಯವನ್ನು ಒಳಗೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿವೆ. ನೀವು ಎಲ್ಲಾ ಸಂಭವನೀಯ ಭಾಷಾ ಕೋಡ್‌ಗಳನ್ನು ಮುಂಚಿತವಾಗಿ ತಿಳಿದಿರುವುದಿಲ್ಲ, ಆದರೆ ಅವು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿರುತ್ತವೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ, ಮತ್ತು ಅವುಗಳೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಮೌಲ್ಯಗಳು ಸಹ ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿರುತ್ತವೆ.

ಸೂಚ್ಯಂಕ ಸಹಿಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್

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

ಇಲ್ಲಿ ಸಾಮಾನ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಇದೆ:

            
[keyName: KeyType]: ValueType;

            

              
                Copy
              
            
          

• keyName: ಇದು ಸೂಚ್ಯಂಕದ ಹೆಸರನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಗುರುತಿಸುವಿಕೆಯಾಗಿದೆ. ಇದು ಒಂದು ಸಮ್ಮೇಳನವಾಗಿದೆ ಮತ್ತು ಟೈಪ್ ಪರಿಶೀಲನೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.
• KeyType: ಇದು ಕೀಲಿಗಳ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ಇದು string ಅಥವಾ number ಆಗಿರುತ್ತದೆ. ನೀವು ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳ ಒಕ್ಕೂಟ ಪ್ರಕಾರಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು, ಆದರೆ ಇದು ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದೆ ಮತ್ತು ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ಇತರ ವಿಧಾನಗಳಿಂದ ಉತ್ತಮವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.
• ValueType: ಇದು ಪ್ರತಿ ಕೀಲಿಯೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಮೌಲ್ಯಗಳ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

ಸೂಚ್ಯಂಕ ಸಹಿಗಳ ಸಾಮಾನ್ಯ ಬಳಕೆ ಪ್ರಕರಣಗಳು

ಕೆಳಗಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸೂಚ್ಯಂಕ ಸಹಿಗಳು ವಿಶೇಷವಾಗಿ ಮೌಲ್ಯಯುತವಾಗಿವೆ:

• ಕಾನ್ಫಿಗರೇಶನ್ ವಸ್ತುಗಳು: ಅಪ್ಲಿಕೇಶನ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಅಲ್ಲಿ ಕೀಲಿಗಳು ವೈಶಿಷ್ಟ್ಯ ಧ್ವಜಗಳು, ಪರಿಸರ-ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಗಳು ಅಥವಾ ಬಳಕೆದಾರರ ಆದ್ಯತೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಥೀಮ್ ಬಣ್ಣಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಒಂದು ವಸ್ತು, ಅಲ್ಲಿ ಕೀಲಿಗಳು 'ಪ್ರಾಥಮಿಕ', 'ದ್ವಿತೀಯಕ', 'ಉಚ್ಚಾರಣೆ' ಮತ್ತು ಮೌಲ್ಯಗಳು ಬಣ್ಣ ಕೋಡ್‌ಗಳಾಗಿವೆ (ಸ್ಟ್ರಿಂಗ್‌ಗಳು).
• ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಮತ್ತು ಸ್ಥಳೀಕರಣ (l10n): ಹಿಂದಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ವಿವರಿಸಿದಂತೆ ವಿಭಿನ್ನ ಭಾಷೆಗಳಿಗಾಗಿ ಅನುವಾದಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು.
• API ಪ್ರತಿಕ್ರಿಯೆಗಳು: ರಚನೆಯು ಬದಲಾಗಬಹುದಾದ ಅಥವಾ ಕ್ರಿಯಾತ್ಮಕ ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊಂದಿರಬಹುದಾದ API ಗಳಿಂದ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವುದು. ಉದಾಹರಣೆಗೆ, ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂದಿರುಗಿಸುವ ಪ್ರತಿಕ್ರಿಯೆ, ಅಲ್ಲಿ ಪ್ರತಿಯೊಂದು ವಸ್ತುವನ್ನು ಅನನ್ಯ ಗುರುತಿಸುವಿಕೆಯಿಂದ ಕೀ ಮಾಡಲಾಗುತ್ತದೆ.
• ಮ್ಯಾಪಿಂಗ್ ಮತ್ತು ಡಿಕ್ಷನರಿಗಳು: ಎಲ್ಲಾ ಮೌಲ್ಯಗಳು ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಕ್ಕೆ ಅನುಗುಣವಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮಗೆ ಅಗತ್ಯವಿರುವಲ್ಲಿ ಸರಳ ಕೀ-ಮೌಲ್ಯದ ಅಂಗಡಿಗಳು ಅಥವಾ ಡಿಕ್ಷನರಿಗಳನ್ನು ರಚಿಸುವುದು.
• DOM ಅಂಶಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು: JavaScript ಪರಿಸರಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವುದು, ಅಲ್ಲಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ ಅವುಗಳ ID ಅಥವಾ ಹೆಸರಿನಿಂದ ಸಂಗ್ರಹಣೆಯಲ್ಲಿರುವ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು.

string ಕೀಲಿಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಸಹಿಗಳು

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

ಉದಾಹರಣೆ 1: ಬಳಕೆದಾರರ ಆದ್ಯತೆಗಳು

ಬಳಕೆದಾರರಿಗೆ ಕಸ್ಟಮ್ ಆದ್ಯತೆಗಳನ್ನು ಹೊಂದಿಸಲು ಅನುಮತಿಸುವ ಬಳಕೆದಾರರ ಪ್ರೊಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ನೀವು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಊಹಿಸಿ. ಈ ಆದ್ಯತೆಗಳು ಏನಾದರೂ ಆಗಿರಬಹುದು, ಆದರೆ ಯಾವುದೇ ಆದ್ಯತೆಯ ಮೌಲ್ಯವು ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಸಂಖ್ಯೆಯಾಗಿರಬೇಕು ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ.

            
interface UserPreferences {
  [key: string]: string | number;
  theme: string;
  fontSize: number;
  notificationsEnabled: string; // Example of a string value
}

const myPreferences: UserPreferences = {
  theme: 'dark',
  fontSize: 16,
  notificationsEnabled: 'daily',
  language: 'en-US' // This is allowed because 'language' is a string key, and 'en-US' is a string value.
};

console.log(myPreferences.theme); // Output: dark
console.log(myPreferences['fontSize']); // Output: 16
console.log(myPreferences.language); // Output: en-US

// This would cause a TypeScript error because 'color' is not defined and its value type is not string | number:
// const invalidPreferences: UserPreferences = {
//   color: true;
// };

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, [key: string]: string | number; ಯಾವುದೇ ಗುಣಲಕ್ಷಣವನ್ನು UserPreferences ಪ್ರಕಾರದ ವಸ್ತುವಿನ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್ ಕೀಯನ್ನು ಬಳಸಿ ಪ್ರವೇಶಿಸಿದರೆ ಅದು string ಅಥವಾ number ಆಗಿರಬೇಕು ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ನೀವು theme, fontSize, ಮತ್ತು notificationsEnabled ನಂತಹ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಇನ್ನೂ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳು ಸೂಚ್ಯಂಕ ಸಹಿಯ ಮೌಲ್ಯ ಪ್ರಕಾರಕ್ಕೆ ಬದ್ಧವಾಗಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ 2: ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಂದೇಶಗಳು

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

            
interface TranslatedMessages {
  [locale: string]: { [key: string]: string };
}

const messages: TranslatedMessages = {
  'en': {
    greeting: 'Hello',
    welcome: 'Welcome to our service',
  },
  'fr': {
    greeting: 'Bonjour',
    welcome: 'Bienvenue à notre service',
  },
  'es-MX': {
    greeting: 'Hola',
    welcome: 'Bienvenido a nuestro servicio',
  }
};

console.log(messages['en'].greeting); // Output: Hello
console.log(messages['fr']['welcome']); // Output: Bienvenue à notre service

// This would cause a TypeScript error because 'fr' does not have a property named 'farewell' defined:
// console.log(messages['fr'].farewell);

// To handle potentially missing translations gracefully, you might use optional properties or add more specific checks.

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, ಹೊರಗಿನ ಸೂಚ್ಯಂಕ ಸಹಿ [locale: string]: { [key: string]: string }; ಸಂದೇಶಗಳು ವಸ್ತುವಿನಲ್ಲಿ ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಎಂದು ಸೂಚಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಪ್ರತಿ ಗುಣಲಕ್ಷಣ ಕೀಲಿಯು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ (ಸ್ಥಳೀಯತೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, 'en', 'fr'), ಮತ್ತು ಪ್ರತಿಯೊಂದು ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯವು ಸ್ವತಃ ಒಂದು ವಸ್ತುವಾಗಿದೆ. { [key: string]: string } ಸಹಿಯಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಈ ಆಂತರಿಕ ವಸ್ತುವು ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್ ಕೀಲಿಗಳನ್ನು ಹೊಂದಿರಬಹುದು (ಸಂದೇಶ ಕೀಲಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, 'ಶುಭಾಶಯ') ಮತ್ತು ಅವುಗಳ ಮೌಲ್ಯಗಳು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿರಬೇಕು.

number ಕೀಲಿಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಸಹಿಗಳು

ಸಂಖ್ಯಾ ಕೀಲಿಗಳೊಂದಿಗೆ ಸೂಚ್ಯಂಕ ಸಹಿಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು. ನೀವು ಎಲ್ಲಾ ಅಂಶಗಳಿಗೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವನ್ನು ಜಾರಿಗೊಳಿಸಲು ಬಯಸುವಲ್ಲಿ ಅರೇ ಅಥವಾ ಅರೇ-ರೀತಿಯ ರಚನೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ 3: ಸಂಖ್ಯೆಗಳ ಅರೇ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿರುವ ಅರೇಗಳು ಈಗಾಗಲೇ ಸ್ಪಷ್ಟವಾದ ಪ್ರಕಾರದ ವ್ಯಾಖ್ಯಾನವನ್ನು ಹೊಂದಿವೆ (ಉದಾಹರಣೆಗೆ, number[]), ಆದರೆ ಅರೇಯಂತೆ ವರ್ತಿಸುವ ಆದರೆ ವಸ್ತುವಿನ ಮೂಲಕ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಯಾವುದನ್ನಾದರೂ ನೀವು ಪ್ರತಿನಿಧಿಸಬೇಕಾಗಬಹುದು.

            
interface NumberCollection {
  [index: number]: number;
  length: number; // Arrays typically have a length property
}

const numbers: NumberCollection = [
  10,
  20,
  30,
  40
];

numbers.length = 4; // This is also allowed by the NumberCollection interface

console.log(numbers[0]); // Output: 10
console.log(numbers[2]); // Output: 30

// This would cause a TypeScript error because the value is not a number:
// numbers[1] = 'twenty';

            

              
                Copy
              
            
          

ಈ ಸಂದರ್ಭದಲ್ಲಿ, [index: number]: number; ಸಂಖ್ಯೆಗಳು ವಸ್ತುವಿನ ಮೇಲೆ ಒಂದು ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕದೊಂದಿಗೆ ಪ್ರವೇಶಿಸಲಾದ ಯಾವುದೇ ಗುಣಲಕ್ಷಣವು number ಅನ್ನು ನೀಡಬೇಕು ಎಂದು ನಿರ್ದೇಶಿಸುತ್ತದೆ. ಅರೇ-ರೀತಿಯ ರಚನೆಗಳನ್ನು ಮಾದರಿಯಾಗಿಸುವಾಗ length ಗುಣಲಕ್ಷಣವೂ ಒಂದು ಸಾಮಾನ್ಯ ಸೇರ್ಪಡೆಯಾಗಿದೆ.

ಉದಾಹರಣೆ 4: ಡೇಟಾಗೆ ಸಂಖ್ಯಾ ಗುರುತಿಸುವಿಕೆಗಳ ಮ್ಯಾಪಿಂಗ್

ಸಂಖ್ಯಾ ಗುರುತಿಸುವಿಕೆಗಳಿಂದ ಡೇಟಾ ದಾಖಲೆಗಳನ್ನು ಪ್ರವೇಶಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಪರಿಗಣಿಸಿ.

            
interface RecordMap {
  [id: number]: { name: string, isActive: boolean };
}

const records: RecordMap = {
  101: { name: 'Alpha', isActive: true },
  205: { name: 'Beta', isActive: false },
  310: { name: 'Gamma', isActive: true }
};

console.log(records[101].name); // Output: Alpha
console.log(records[205].isActive); // Output: false

// This would cause a TypeScript error because the property 'description' is not defined within the value type:
// console.log(records[101].description);

            

              
                Copy
              
            
          

ಈ ಸೂಚ್ಯಂಕ ಸಹಿಯು ನೀವು records ವಸ್ತುವಿನ ಮೇಲೆ ಸಂಖ್ಯಾ ಕೀಯೊಂದಿಗೆ ಒಂದು ಗುಣಲಕ್ಷಣವನ್ನು ಪ್ರವೇಶಿಸಿದರೆ, ಮೌಲ್ಯವು { name: string, isActive: boolean } ಆಕಾರಕ್ಕೆ ಅನುಗುಣವಾಗಿರುವ ವಸ್ತುವಾಗಿರುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

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

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

1. ಸೂಚ್ಯಂಕ ಸಹಿ ಪ್ರಕಾರ ನಿರ್ಬಂಧಗಳು

ಸೂಚ್ಯಂಕ ಸಹಿಯಲ್ಲಿ ಕೀ ಪ್ರಕಾರ ಹೀಗಿರಬಹುದು:

• string
• number
• symbol (ಕಡಿಮೆ ಸಾಮಾನ್ಯ, ಆದರೆ ಬೆಂಬಲಿತವಾಗಿದೆ)

ನೀವು ಸೂಚ್ಯಂಕ ಪ್ರಕಾರವಾಗಿ number ಅನ್ನು ಬಳಸಿದರೆ, JavaScript ನಲ್ಲಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸುವಾಗ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು ಆಂತರಿಕವಾಗಿ string ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಏಕೆಂದರೆ JavaScript ಆಬ್ಜೆಕ್ಟ್ ಕೀಗಳು ಮೂಲಭೂತವಾಗಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿವೆ (ಅಥವಾ ಚಿಹ್ನೆಗಳು). ಅಂದರೆ, ನೀವು ಒಂದೇ ಪ್ರಕಾರದಲ್ಲಿ string ಮತ್ತು number ಸೂಚ್ಯಂಕ ಸಹಿಯನ್ನು ಹೊಂದಿದ್ದರೆ, string ಸಹಿ ಆದ್ಯತೆ ಪಡೆಯುತ್ತದೆ.

ಇದನ್ನು ಪರಿಗಣಿಸಿ:

            
interface MixedIndex {
  [key: string]: number;
  [index: number]: string; // This will be effectively ignored because the string index signature already covers numeric keys.
}

// If you try to assign values:
const mixedExample: MixedIndex = {
  'a': 1,
  'b': 2
};

// According to the string signature, numeric keys should also have number values.
mixedExample[1] = 3; // This assignment is allowed and '3' is assigned.

// However, if you try to access it as if the number signature was active for value type 'string':
// console.log(mixedExample[1]); // This will output '3', a number, not a string.

// The type of mixedExample[1] is considered 'number' due to the string index signature.

            

              
                Copy
              
            
          

ಉತ್ತಮ ಅಭ್ಯಾಸ: ಒಂದು ವಸ್ತುವಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಪ್ರಾಥಮಿಕ ಸೂಚ್ಯಂಕ ಸಹಿ ಪ್ರಕಾರಕ್ಕೆ (ಸಾಮಾನ್ಯವಾಗಿ string) ಅಂಟಿಕೊಳ್ಳುವುದು ಉತ್ತಮ, ನೀವು ನಿರ್ದಿಷ್ಟ ಕಾರಣವನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ ಮತ್ತು ಸಂಖ್ಯಾ ಸೂಚ್ಯಂಕ ಪರಿವರ್ತನೆಯ ಪರಿಣಾಮಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದರೆ ಮಾತ್ರ.

2. ಸ್ಪಷ್ಟ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಸಂವಹನ

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

            
interface Config {
  port: number; // Explicit property
  [settingName: string]: any; // Index signature allows any type for other settings
}

const serverConfig: Config = {
  port: 8080,
  timeout: 5000,
  host: 'localhost',
  protocol: 'http'
};

// 'port' is a number, which is fine.
// 'timeout', 'host', 'protocol' are also allowed because the index signature is 'any'.

// If the index signature were more restrictive:
interface StrictConfig {
  port: number;
  [settingName: string]: string | number;
}

const strictServerConfig: StrictConfig = {
  port: 8080,
  timeout: '5s', // Allowed: string
  host: 'localhost' // Allowed: string
};

// This would cause an error:
// const invalidConfig: StrictConfig = {
//   port: 8080,
//   debugMode: true // Error: boolean is not assignable to string | number
// };

            

              
                Copy
              
            
          

ಉತ್ತಮ ಅಭ್ಯಾಸ: ಉತ್ತಮವಾಗಿ ತಿಳಿದಿರುವ ಕೀಲಿಗಳಿಗಾಗಿ ಸ್ಪಷ್ಟ ಗುಣಲಕ್ಷಣಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ ಮತ್ತು ತಿಳಿಯದ ಅಥವಾ ಕ್ರಿಯಾತ್ಮಕವಾದವುಗಳಿಗಾಗಿ ಸೂಚ್ಯಂಕ ಸಹಿಗಳನ್ನು ಬಳಸಿ. ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಸೂಚ್ಯಂಕ ಸಹಿಯಲ್ಲಿನ ಮೌಲ್ಯ ಪ್ರಕಾರವನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ನಿರ್ದಿಷ್ಟವಾಗಿ ಮಾಡಿ.

3. ಸೂಚ್ಯಂಕ ಸಹಿಗಳೊಂದಿಗೆ any ಅನ್ನು ಬಳಸುವುದು

ನೀವು ಸೂಚ್ಯಂಕ ಸಹಿಯಲ್ಲಿ ಮೌಲ್ಯ ಪ್ರಕಾರವಾಗಿ any ಅನ್ನು ಬಳಸಬಹುದು (ಉದಾಹರಣೆಗೆ, [key: string]: any;), ಇದು ಮೂಲಭೂತವಾಗಿ ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸದ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳಿಗಾಗಿ ಟೈಪ್ ಪರಿಶೀಲನೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಇದು ತ್ವರಿತ ಪರಿಹಾರವಾಗಬಹುದು ಆದರೆ ಸಾಧ್ಯವಾದಾಗ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಬೇಕು.

            
interface AnyObject {
  [key: string]: any;
}

const data: AnyObject = {
  name: 'Example',
  value: 123,
  isActive: true,
  config: { setting: 'abc' }
};

console.log(data.name.toUpperCase()); // Works, but TypeScript can't guarantee 'name' is a string.
console.log(data.value.toFixed(2)); // Works, but TypeScript can't guarantee 'value' is a number.

            

              
                Copy
              
            
          

ಉತ್ತಮ ಅಭ್ಯಾಸ: ನಿಮ್ಮ ಸೂಚ್ಯಂಕ ಸಹಿಯ ಮೌಲ್ಯಕ್ಕಾಗಿ ಸಾಧ್ಯವಾದಷ್ಟು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರವನ್ನು ಗುರಿ ಮಾಡಿ. ನಿಮ್ಮ ಡೇಟಾ ನಿಜವಾಗಿಯೂ ಹೆಟೆರೋಜಿನಿಯಸ್ ಪ್ರಕಾರಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಯೂನಿಯನ್ ಪ್ರಕಾರವನ್ನು (ಉದಾಹರಣೆಗೆ, string | number | boolean) ಅಥವಾ ಪ್ರತ್ಯೇಕಿತ ಒಕ್ಕೂಟವನ್ನು ಪರಿಗಣಿಸಿ, ಪ್ರಕಾರಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಒಂದು ಮಾರ್ಗವಿದ್ದರೆ.

4. ಓದಲು ಮಾತ್ರ ಸೂಚ್ಯಂಕ ಸಹಿಗಳು

readonly ಮಾರ್ಪಾಡಕವನ್ನು ಬಳಸುವ ಮೂಲಕ ನೀವು ಸೂಚ್ಯಂಕ ಸಹಿಗಳನ್ನು ಓದಲು ಮಾತ್ರ ಮಾಡಬಹುದು. ವಸ್ತುವನ್ನು ರಚಿಸಿದ ನಂತರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಮಾರ್ಪಡಿಸುವುದನ್ನು ಇದು ತಡೆಯುತ್ತದೆ.

            
interface ImmutableSettings {
  readonly [key: string]: string;
}

const settings: ImmutableSettings = {
  theme: 'dark',
  language: 'en',
  currency: 'USD'
};

console.log(settings.theme); // Output: dark

// This would cause a TypeScript error:
// settings.theme = 'light';

// You can still define explicit properties with specific types, and the readonly modifier applies to them as well.
interface ReadonlyUser { 
  readonly id: number;
  readonly [key: string]: string;
}

const user: ReadonlyUser = {
  id: 123,
  username: 'global_dev',
  email: 'dev@example.com'
};

// user.id = 456; // Error
// user.username = 'new_user'; // Error

            

              
                Copy
              
            
          

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

5. ಅತಿಕ್ರಮಿಸುವ ಸೂಚ್ಯಂಕ ಸಹಿಗಳು

ಮೊದಲು ಹೇಳಿದಂತೆ, ಒಂದೇ ಪ್ರಕಾರದ ಬಹು ಸೂಚ್ಯಂಕ ಸಹಿಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, ಎರಡು [key: string]: ...) ಅನುಮತಿಸುವುದಿಲ್ಲ ಮತ್ತು ಇದು ಕಂಪೈಲ್ ಸಮಯ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಆದಾಗ್ಯೂ, ವಿಭಿನ್ನ ಸೂಚ್ಯಂಕ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ (ಉದಾಹರಣೆಗೆ, string ಮತ್ತು number), ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿರ್ದಿಷ್ಟ ನಿಯಮಗಳನ್ನು ಹೊಂದಿದೆ:

• ನೀವು string ಪ್ರಕಾರದ ಸೂಚ್ಯಂಕ ಸಹಿ ಮತ್ತು number ಪ್ರಕಾರದ ಇನ್ನೊಂದನ್ನು ಹೊಂದಿದ್ದರೆ, ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳಿಗಾಗಿ string ಸಹಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಏಕೆಂದರೆ JavaScript ನಲ್ಲಿ ಸಂಖ್ಯಾತ್ಮಕ ಕೀಲಿಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಬಲವಂತಪಡಿಸಲಾಗುತ್ತದೆ.
• ನೀವು number ಪ್ರಕಾರದ ಸೂಚ್ಯಂಕ ಸಹಿ ಮತ್ತು string ಪ್ರಕಾರದ ಇನ್ನೊಂದನ್ನು ಹೊಂದಿದ್ದರೆ, string ಸಹಿಯು ಆದ್ಯತೆ ಪಡೆಯುತ್ತದೆ.

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

6. ಸೂಚ್ಯಂಕ ಸಹಿಗಳು ಮತ್ತು ವಿಧಾನ ವ್ಯಾಖ್ಯಾನಗಳು

ಸೂಚ್ಯಂಕ ಸಹಿಯ ಮೌಲ್ಯ ಪ್ರಕಾರದಲ್ಲಿ ನೀವು ನೇರವಾಗಿ ವಿಧಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಸೂಚ್ಯಂಕ ಸಹಿಗಳನ್ನು ಹೊಂದಿರುವ ಇಂಟರ್ಫೇಸ್‌ಗಳಲ್ಲಿ ನೀವು ವಿಧಾನಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.

            
interface DataProcessor {
  [key: string]: string; // All dynamic properties must be strings
  process(): void; // A method
  // This would be an error: `processValue: (value: string) => string;` would need to conform to the index signature type.
}

const processor: DataProcessor = {
  data1: 'value1',
  data2: 'value2',
  process: () => {
    console.log('Processing data...');
  }
};

processor.process();
console.log(processor.data1);

// This would cause an error because 'data3' is not a string:
// processor.data3 = 123;

// If you want methods to be part of the dynamic properties, you'd need to include them in the index signature's value type:
interface DynamicObjectWithMethods {
  [key: string]: string | (() => void);
}

const dynamicObj: DynamicObjectWithMethods = {
  configValue: 'some_setting',
  runTask: () => console.log('Task executed!')
};

dynamicObj.runTask();
console.log(typeof dynamicObj.configValue);

            

              
                Copy
              
            
          

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

ಸೂಚ್ಯಂಕ ಸಹಿಗಳ ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು

ಜಾಗತಿಕ ಅಭಿವೃದ್ಧಿ ಪರಿಸರದಲ್ಲಿ, ವೈವಿಧ್ಯಮಯ ಡೇಟಾ ಸ್ವರೂಪಗಳು ಮತ್ತು ಅವಶ್ಯಕತೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸೂಚ್ಯಂಕ ಸಹಿಗಳು ಅಮೂಲ್ಯವಾಗಿವೆ.

1. ಅಡ್ಡ-ಸಾಂಸ್ಕೃತಿಕ ಡೇಟಾ ನಿರ್ವಹಣೆ

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

            
interface ProductAttributes {
  [attributeName: string]: string | number | boolean;
}

const clothingAttributes: ProductAttributes = {
  size: 'M',
  color: 'Blue',
  material: 'Cotton',
  isWashable: true
};

const electronicsAttributes: ProductAttributes = {
  voltage: 220,
  powerConsumption: '50W',
  connectivity: 'Wi-Fi, Bluetooth',
  hasWarranty: true
};

function displayAttributes(attributes: ProductAttributes) {
  for (const key in attributes) {
    console.log(`${key}: ${attributes[key]}`);
  }
}

displayAttributes(clothingAttributes);
displayAttributes(electronicsAttributes);

            

              
                Copy
              
            
          

ಇಲ್ಲಿ, ವಿಶಾಲವಾದ string | number | boolean ಯೂನಿಯನ್ ಪ್ರಕಾರದೊಂದಿಗೆ ProductAttributes ವಿಭಿನ್ನ ಉತ್ಪನ್ನ ಪ್ರಕಾರಗಳು ಮತ್ತು ಪ್ರದೇಶಗಳಲ್ಲಿ ನಮ್ಯತೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಯಾವುದೇ ಗುಣಲಕ್ಷಣ ಕೀಲಿಯು ಸಾಮಾನ್ಯ ಸೆಟ್ ಮೌಲ್ಯ ಪ್ರಕಾರಗಳಿಗೆ ಮ್ಯಾಪ್ ಆಗುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

2. ಬಹು-ಕರೆನ್ಸಿ ಮತ್ತು ಬಹು-ಭಾಷಾ ಬೆಂಬಲ

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

            
interface ExchangeRates {
  [currencyCode: string]: number;
}

interface CurrencyData {
  base: string;
  rates: ExchangeRates;
}

interface LocalizedMessages {
  [locale: string]: { [messageKey: string]: string };
}

const usdData: CurrencyData = {
  base: 'USD',
  rates: {
    EUR: 0.93,
    GBP: 0.79,
    JPY: 157.38
  }
};

const frenchMessages: LocalizedMessages = {
  'fr': {
    welcome: 'Bienvenue',
    goodbye: 'Au revoir'
  }
};

console.log(`1 USD = ${usdData.rates.EUR} EUR`);
console.log(frenchMessages['fr'].welcome);

            

              
                Copy
              
            
          

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

3. ಡೈನಾಮಿಕ್ API ಸಮನ್ವಯಗಳು

ಸನ್ನಿವೇಶ: ಕ್ಷೇತ್ರಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಬಹಿರಂಗಪಡಿಸಬಹುದಾದ ಮೂರನೇ ವ್ಯಕ್ತಿಯ API ಗಳೊಂದಿಗೆ ಸಮನ್ವಯಗೊಳಿಸುವುದು. ಉದಾಹರಣೆಗೆ, CRM ಸಿಸ್ಟಮ್ ಕಾಂಟ್ಯಾಕ್ಟ್ ರೆಕಾರ್ಡ್‌ಗಳಿಗೆ ಕಸ್ಟಮ್ ಕ್ಷೇತ್ರಗಳನ್ನು ಸೇರಿಸಲು ಅನುಮತಿಸಬಹುದು, ಅಲ್ಲಿ ಕ್ಷೇತ್ರ ಹೆಸರುಗಳು ಮತ್ತು ಅವುಗಳ ಮೌಲ್ಯ ಪ್ರಕಾರಗಳು ಬದಲಾಗಬಹುದು.

            
interface CustomContactFields {
  [fieldName: string]: string | number | boolean | null;
}

interface ContactRecord {
  id: number;
  name: string;
  email: string;
  customFields: CustomContactFields;
}

const user1: ContactRecord = {
  id: 1,
  name: 'Alice',
  email: 'alice@example.com',
  customFields: {
    leadSource: 'Webinar',
    accountTier: 2,
    isVIP: true,
    lastContacted: null
  }
};

function getCustomField(record: ContactRecord, fieldName: string): string | number | boolean | null {
  return record.customFields[fieldName];
}

console.log(`Lead Source: ${getCustomField(user1, 'leadSource')}`);
console.log(`Account Tier: ${getCustomField(user1, 'accountTier')}`);

            

              
                Copy
              
            
          

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

ತೀರ್ಮಾನ

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

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

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