TypeScript ತಂಡವು 6.0 ಬಿಡುಗಾವಣೆಯಲ್ಲಿ ಹೊಸ ಕಾಂಪೈಲರ್ ಫ್ಲಾಗ್ ಅನ್ನು ಪರಿಚಯಿಸಿದೆ – --noPropertyAccessFromIndexSignature. ಇದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿದಾಗ, ಕಾಂಪೈಲರ್ ಇಂಡೆಕ್ಸ್ ಸಿಗ್ನೇಚರ್‌ನಿಂದ (index signature) ಬರುವ ಪ್ರಾಪರ್ಟಿಗಳಿಗೆ ಡಾಟ್-ನೋಟೇಶನ್ (dot-notation) ಬಳಕೆಯನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ, ಇದರಿಂದ ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರು ಬ್ರಾಕೆಟ್ ನೋಟೇಶನ್ (bracket notation) ಬಳಸಲು ಮತ್ತು ಪ್ರೊಡಕ್ಷನ್‌ನಲ್ಲಿ ಬರುವ ಬದಲಿಗೆ ಕಾಂಪೈಲ್ ಸಮಯದಲ್ಲಿಯೇ ಸಂಭಾವ್ಯ undefined ಮೌಲ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಒತ್ತಾಯಿಸುತ್ತದೆ.

ಈ ಫ್ಲಾಗ್ ಏಕೆ ಮುಖ್ಯ

JavaScript ನಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಹೆಚ್ಚಾಗಿ ಡಿಕ್ಷನರಿಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು TypeScript ಇಂತಹ ರಚನೆಗಳನ್ನು ಇಂಡೆಕ್ಸ್ ಸಿಗ್ನೇಚರ್ ಬಳಸಿ ಟೈಪ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ Record<string, T>. ಈ ಭಾಷೆಯು obj.key ಮತ್ತು obj["key"] ಎರಡನ್ನೂ ಒಂದೇ ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಕೀ (key) ಕೇವಲ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಮಾತ್ರ ತಿಳಿದಿದ್ದರೂ ಸಹ, ಆ ಪ್ರಾಪರ್ಟಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಕಾಂಪೈಲರ್ ಭಾವಿಸುತ್ತದೆ. ಈ ಮೌನ ಅನ್ವಯವು (assumption) ಅನೇಕ ಕ್ರ್ಯಾಶ್‌ಗಳಿಗೆ ಮೂಲವಾಗಿದೆ: obj.missingProp ಅನ್ನು ಬಳಸುವ ಕೋಡ್ ಸರಿಯಾಗಿ ಕಾಂಪೈಲ್ ಆಗುತ್ತದೆ ಮತ್ತು ರನ್ ಆಗುತ್ತದೆ, ಆದರೆ ಮೌಲ್ಯವು undefined ಆಗಿರುವುದರಿಂದ ನಂತರ ಎರ್ರರ್ ಉಂಟಾಗುತ್ತದೆ.

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

ಈ ಫ್ಲಾಗ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

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

// Before
const name = userData.name;          // OK even if "name" is not in the index

// After enabling the flag
const name = userData["name"];       // Error unless brackets are used

ನಂತರ ಕಾಂಪೈಲರ್ ಬ್ರಾಕೆಟ್ ಪ್ರವೇಶಕ್ಕಾಗಿ ಈಗಾಗಲೇ ಬಳಸುವ ಅದೇ undefined-ಹ್ಯಾಂಡ್ಲಿಂಗ್ ನಿಯಮಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ. --noUncheckedIndexedAccess ಅನ್ನು ಸಹ ಸಕ್ರಿಯಗೊಳಿಸಿದ್ದರೆ, userData["name"] ನ ಟೈಪ್ T | undefined ಆಗುತ್ತದೆ, ಇದು ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರು ಕೀ ಇಲ್ಲದಿರುವ ಸಂದರ್ಭವನ್ನು ಪರಿಶೀಲಿಸಲು ಒತ್ತಾಯಿಸುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕ ಮೈಗ್ರೇಷನ್ ಹಂತಗಳು

  1. tsconfig.json ನಲ್ಲಿ ಫ್ಲಾಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ:

    {
  "compilerOptions": {
    "noPropertyAccessFromIndexSignature": true
  }
}

  2. ಟೈಪ್ ಚೆಕರ್ ಅನ್ನು ರನ್ ಮಾಡಿ. ಇಂಡೆಕ್ಸ್-ಸಿಗ್ನೇಚರ್ ಕೀಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಎಲ್ಲಾ ಡಾಟ್-ನೋಟೇಶನ್ ಪ್ರವೇಶಗಳು ಎರ್ರರ್‌ಗಳಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ.

  3. ಡಾಟ್‌ಗಳ ಬದಲಿಗೆ ಬ್ರಾಕೆಟ್‌ಗಳನ್ನು ಬಳಸಿ. ಈ ಬದಲಾವಣೆಯು ಮೆಕ್ಯಾನಿಕಲ್ ಆಗಿದೆ; ಇದು ರನ್‌ಟೈಮ್ ಪರ್ಫಾರ್ಮೆನ್ಸ್ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ.

  4. ಪರಿಣಾಮವಾಗಿ ಬರುವ undefined ಟೈಪ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಿ. ಅಗತ್ಯವಿರುವಲ್ಲಿ nullish coalescing, optional chaining ಅಥವಾ ಸ್ಪಷ್ಟವಾದ ಚೆಕ್‌ಗಳನ್ನು ಸೇರಿಸಿ.

  5. ಗರಿಷ್ಠ ಸುರಕ್ಷತೆಗಾಗಿ --noUncheckedIndexedAccess ಜೊತೆಗೆ ಇದನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಇವೆರಡೂ ಸೇರಿ ಯಾವುದೇ ಡಿಕ್ಷನರಿ-ಶೈಲಿಯ ಪ್ರವೇಶವನ್ನು ಸಂಭಾವ್ಯವಾಗಿ ಇಲ್ಲದಿರುವ ಸಂದರ್ಭವೆಂದು ಪರಿಗಣಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ.

ಸ್ಪಷ್ಟ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು (explicit properties) ಯಾವಾಗ ಇಟ್ಟುಕೊಳ್ಳಬೇಕು

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

ವಿರೋಧಾಭಿಪ್ರಾಯ: ಹೆಚ್ಚುವರಿ ವರ್ಬೋಸಿಟಿ (verbosity)

ಕೆಲವು ತಂಡಗಳಿಗೆ ಹೆಚ್ಚುವರಿ ಬ್ರಾಕೆಟ್‌ಗಳು ಅನಗತ್ಯವಾಗಿ ಕಾಣಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ಫ್ಲೆಕ್ಸಿಬಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸುವ ಕೋಡ್‌ಬೇಸ್‌ಗಳಲ್ಲಿ. ಈ ಫ್ಲಾಗ್ ಕಟ್ಟುನಿಟ್ಟಾದ ಶಿಸ್ತನ್ನು ಬಯಸುತ್ತದೆ, ಇದು ಹಳೆಯ (legacy) ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ದೊಡ್ಡ ಮಟ್ಟದ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅಗತ್ಯವಾಗಬಹುದು. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಫ್ಲಾಗ್ ಅನ್ನು ಹಂತ ಹಂತವಾಗಿ ಪರಿಚಯಿಸಬಹುದು, ಬಹುಶಃ ಹೊಸ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಮಾತ್ರ ಸೀಮಿತಗೊಳಿಸಿ, ನಂತರ ಕಾಲಕ್ರಮೇಣ ಇಡೀ ಕೋಡ್‌ಬೇಸ್ ಈ ಮಾದರಿಯನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದು.

ಮುಂದೆ ಏನನ್ನು ಗಮನಿಸಬೇಕು

ಈ ಫ್ಲಾಗ್ TypeScript 6.0 ರಲ್ಲಿ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪ್ ಸೇಫ್ಟಿ (type safety) ಕಡೆಗೆ ಮಾಡಲಾಗುತ್ತಿರುವ ವ್ಯಾಪಕ ಪ್ರಯತ್ನದ ಭಾಗವಾಗಿದೆ. ಭವಿಷ್ಯದ ಬಿಡುಗಣೆಗಳು ಆಬ್ಜೆಕ್ಟ್ ಸ್ಪ್ರೆಡ್ (object spread), ಆಪ್ಷನಲ್ ಚೈನಿಂಗ್ (optional chaining) ಅಥವಾ ಇನ್ಫರ್ಡ್ any ಬಳಕೆಯ ಸುತ್ತ ಹೆಚ್ಚಿನ ಪರಿಶೀಲನೆಗಳನ್ನು ಪರಿಚಯಿಸಬಹುದು. TypeScript ರೋಡ್‌ಮ್ಯಾಪ್ ಅನ್ನು ಗಮನಿಸುತ್ತಿರುವುದು, ವಿತರಣಾ ವೇಳಾಪಟ್ಟಿಯನ್ನು (delivery schedules) ಅಡ್ಡಿಪಡಿಸದೆ ಮುಂದಿನ ಸುರಕ್ಷತಾ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಯಾವಾಗ ಅಳವಡಿಸಿಕೊಳ್ಳಬೇಕು ಎಂದು ನಿರ್ಧರಿಸಲು ತಂಡಗಳಿಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಸಾರಾಂಶ: --noPropertyAccessFromIndexSignature ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದರಿಂದ "ಈ ಪ್ರಾಪರ್ಟಿ ಖಚಿತವಾಗಿದೆ" ಮತ್ತು "ಈ ಪ್ರಾಪರ್ಟಿ ಇಲ್ಲದಿರಬಹುದು" ಎಂಬ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಕೋಡ್‌ನಲ್ಲಿ ಸ್ಪಷ್ಟಪಡಿಸಬಹುದು, ಇದರಿಂದ ಪ್ರೊಡಕ್ಷನ್‌ಗೆ ತಲುಪುವ ಮೊದಲೇ ಒಂದು ವರ್ಗದ ಬಗ್‌ಗಳನ್ನು (bugs) ಪತ್ತೆಹಚ್ಚಬಹುದು. ಮೌನ ರನ್‌ಟೈಮ್ ವೈಫಲ್ಯವನ್ನು ಕಾಂಪೈಲ್-ಟೈಮ್ ಎರ್ರರ್ ಆಗಿ ಪರಿವರ್ತಿಸುವುದು ವಿಶ್ವಾಸಾರ್ಹತೆಯ ಮೇಲೆ ಅತಿ ಹೆಚ್ಚಿನ ಪ್ರಭಾವ ಬೀರುವ ಒಂದು ಸಣ್ಣ ಬದಲಾವಣೆಯಾಗಿದೆ.