ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್‌ನ ಆಳವಾದ ತಿಳುವಳಿಕೆ ಪಡೆಯಿರಿ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು JSDoc ನಂತಹ ಪರಿಕರಗಳು ಬಗ್‌ಗಳನ್ನು ತಡೆಯಲು ಮತ್ತು ಜಾಗತಿಕ ತಂಡಗಳಲ್ಲಿ ಕೋಡ್ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸಲು ಹೇಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆಂದು ತಿಳಿಯಿರಿ.
ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್‌ನೊಂದಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ಟೈಪ್ ಚೆಕಿಂಗ್‌ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ: ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಒಂದು ಮಾರ್ಗದರ್ಶಿ
ಆಧುನಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಜಗತ್ತಿನಲ್ಲಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವೆಬ್‌ನ ಭಾಷೆಯಾಗಿ ಸರ್ವಶ್ರೇಷ್ಠವಾಗಿದೆ. ಇದರ ನಮ್ಯತೆ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಸ್ವಭಾವವು ಸರಳ ವೆಬ್‌ಸೈಟ್‌ಗಳಿಂದ ಹಿಡಿದು ಸಂಕೀರ್ಣ, ಎಂಟರ್‌ಪ್ರೈಸ್-ದರ್ಜೆಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳವರೆಗೆ ಎಲ್ಲವನ್ನೂ ಶಕ್ತಿಯುತಗೊಳಿಸಿದೆ. ಆದಾಗ್ಯೂ, ಇದೇ ನಮ್ಯತೆಯು ಎರಡು ಬದಿಯ ಕತ್ತಿಯಿದ್ದಂತೆ. ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ದೊಡ್ಡದಾದಂತೆ ಮತ್ತು ವಿತರಿಸಿದ, ಅಂತರರಾಷ್ಟ್ರೀಯ ತಂಡಗಳಿಂದ ನಿರ್ವಹಿಸಲ್ಪಟ್ಟಂತೆ, ಅಂತರ್ಗತ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ನ ಕೊರತೆಯು ರನ್‌ಟೈಮ್ ದೋಷಗಳಿಗೆ, ಕಷ್ಟಕರವಾದ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್‌ಗೆ ಮತ್ತು ಸವಾಲಿನ ಡೆವಲಪರ್ ಅನುಭವಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.
ಇಲ್ಲಿಯೇ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ. ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸದೆ ವಿಶ್ಲೇಷಿಸುವ ಮೂಲಕ, ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಪರಿಕರಗಳು ಉತ್ಪಾದನೆಯನ್ನು ತಲುಪುವ ಮೊದಲೇ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳ ಒಂದು ದೊಡ್ಡ ಶ್ರೇಣಿಯನ್ನು ಪತ್ತೆಹಚ್ಚಬಲ್ಲವು. ಈ ಮಾರ್ಗದರ್ಶಿ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್‌ನ ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ರೂಪಗಳಲ್ಲಿ ಒಂದಾದ ಮಾಡ್ಯೂಲ್ ಟೈಪ್ ಚೆಕಿಂಗ್ ಬಗ್ಗೆ ಸಮಗ್ರ ಪರಿಶೋಧನೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಆಧುನಿಕ ಅಭಿವೃದ್ಧಿಗೆ ಏಕೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ಪ್ರಮುಖ ಪರಿಕರಗಳನ್ನು ವಿಭಜಿಸುತ್ತೇವೆ ಮತ್ತು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾಯೋಗಿಕ, ಕಾರ್ಯಸಾಧ್ಯವಾದ ಸಲಹೆಗಳನ್ನು ಒದಗಿಸುತ್ತೇವೆ, ನೀವು ಅಥವಾ ನಿಮ್ಮ ತಂಡದ ಸದಸ್ಯರು ಜಗತ್ತಿನಲ್ಲಿ ಎಲ್ಲೇ ಇರಲಿ.
ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಎಂದರೇನು ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಇದು ಏಕೆ ಮುಖ್ಯ?
ಮೂಲಭೂತವಾಗಿ, ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಎಂದರೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸದೆ, ಸಂಭಾವ್ಯ ದೋಷಗಳು, ಬಗ್‌ಗಳು ಮತ್ತು ಕೋಡಿಂಗ್ ಮಾನದಂಡಗಳಿಂದ ವಿಚಲನೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವ ಪ್ರಕ್ರಿಯೆ. ಇದನ್ನು ಸ್ವಯಂಚಾಲಿತ, ಅತ್ಯಾಧುನಿಕ ಕೋಡ್ ವಿಮರ್ಶೆ ಎಂದು ಭಾವಿಸಿ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಿದಾಗ, ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿವಿಧ ಭಾಗಗಳ ನಡುವಿನ 'ಒಪ್ಪಂದ'ಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ. ಒಂದು ಮಾಡ್ಯೂಲ್ ಫಂಕ್ಷನ್‌ಗಳು, ಕ್ಲಾಸ್‌ಗಳು ಅಥವಾ ವೇರಿಯಬಲ್‌ಗಳ ಗುಂಪನ್ನು ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಇತರ ಮಾಡ್ಯೂಲ್‌ಗಳು ಅವುಗಳನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿ ಬಳಸುತ್ತವೆ. ಟೈಪ್ ಚೆಕಿಂಗ್ ಇಲ್ಲದೆ, ಈ ಒಪ್ಪಂದವು ಊಹೆಗಳು ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನ್ನು ಆಧರಿಸಿದೆ. ಉದಾಹರಣೆಗೆ:
- ಮಾಡ್ಯೂಲ್ A `calculatePrice(quantity, pricePerItem)` ಎಂಬ ಫಂಕ್ಷನ್ ಅನ್ನು ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡುತ್ತದೆ.
- ಮಾಡ್ಯೂಲ್ B ಈ ಫಂಕ್ಷನ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿ ಅದನ್ನು `calculatePrice('5', '10.50')` ಎಂದು ಕರೆಯುತ್ತದೆ.
ವೆನಿಲ್ಲಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಇದು ಸಂಖ್ಯಾತ್ಮಕ ಲೆಕ್ಕಾಚಾರದ ಬದಲು ಅನಿರೀಕ್ಷಿತ ಸ್ಟ್ರಿಂಗ್ ಸಂಯೋಜನೆಗೆ (`"510.50"`) ಕಾರಣವಾಗಬಹುದು. ಈ ರೀತಿಯ ದೋಷವು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಗಂಭೀರವಾದ ಬಗ್ಗೆ ಕಾರಣವಾಗುವವರೆಗೂ ಗಮನಕ್ಕೆ ಬಾರದಿರಬಹುದು. ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ಚೆಕಿಂಗ್ ಈ ದೋಷವನ್ನು ನಿಮ್ಮ ಕೋಡ್ ಎಡಿಟರ್‌ನಲ್ಲಿಯೇ ಪತ್ತೆಹಚ್ಚುತ್ತದೆ, ಫಂಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಬದಲಿಗೆ ಸಂಖ್ಯೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಎಂದು ಹೈಲೈಟ್ ಮಾಡುತ್ತದೆ.
ಜಾಗತಿಕ ತಂಡಗಳಿಗೆ, ಪ್ರಯೋಜನಗಳು ಹೆಚ್ಚಾಗಿರುತ್ತವೆ:
- ಸಂಸ್ಕೃತಿಗಳು ಮತ್ತು ಸಮಯ ವಲಯಗಳಾದ್ಯಂತ ಸ್ಪಷ್ಟತೆ: ಟೈಪ್‌ಗಳು ನಿಖರವಾದ, ಅಸ್ಪಷ್ಟವಲ್ಲದ ದಸ್ತಾವೇಜಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಟೋಕಿಯೊದಲ್ಲಿರುವ ಡೆವಲಪರ್, ಬರ್ಲಿನ್‌ನಲ್ಲಿರುವ ಸಹೋದ್ಯೋಗಿ ಬರೆದ ಫಂಕ್ಷನ್‌ಗೆ ಅಗತ್ಯವಿರುವ ಡೇಟಾ ರಚನೆಯನ್ನು ಸಭೆ ಅಥವಾ ಸ್ಪಷ್ಟೀಕರಣದ ಅಗತ್ಯವಿಲ್ಲದೆ ತಕ್ಷಣವೇ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು.
- ಸುರಕ್ಷಿತ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್: ನೀವು ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್ ಅಥವಾ ಆಬ್ಜೆಕ್ಟ್ ಆಕಾರವನ್ನು ಬದಲಾಯಿಸಬೇಕಾದಾಗ, ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ಚೆಕರ್ ಕೋಡ್‌ಬೇಸ್‌ನಲ್ಲಿ ಅಪ್‌ಡೇಟ್ ಮಾಡಬೇಕಾದ ಪ್ರತಿಯೊಂದು ಸ್ಥಳವನ್ನು ತಕ್ಷಣವೇ ತೋರಿಸುತ್ತದೆ. ಇದು ತಂಡಗಳಿಗೆ ಏನನ್ನಾದರೂ ಮುರಿಯುವ ಭಯವಿಲ್ಲದೆ ಕೋಡ್ ಅನ್ನು ಸುಧಾರಿಸುವ ವಿಶ್ವಾಸವನ್ನು ನೀಡುತ್ತದೆ.
- ಸುಧಾರಿತ ಎಡಿಟರ್ ಟೂಲಿಂಗ್: ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಇಂಟೆಲಿಜೆಂಟ್ ಕೋಡ್ ಕಂಪ್ಲೀಷನ್ (IntelliSense), ಗೋ-ಟು-ಡೆಫಿನಿಷನ್, ಮತ್ತು ಇನ್‌ಲೈನ್ ಎರರ್ ರಿಪೋರ್ಟಿಂಗ್‌ನಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳಿಗೆ ಶಕ್ತಿ ನೀಡುತ್ತದೆ, ಇದು ಡೆವಲಪರ್ ಉತ್ಪಾದಕತೆಯನ್ನು ನಾಟಕೀಯವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳ ವಿಕಸನ: ಒಂದು ತ್ವರಿತ ಅವಲೋಕನ
ಮಾಡ್ಯೂಲ್ ಟೈಪ್ ಚೆಕಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮಾಡ್ಯೂಲ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನೇ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ಐತಿಹಾಸಿಕವಾಗಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಯಾವುದೇ ನೇಟಿವ್ ಮಾಡ್ಯೂಲ್ ಸಿಸ್ಟಮ್ ಇರಲಿಲ್ಲ, ಇದು ವಿವಿಧ ಸಮುದಾಯ-ಚಾಲಿತ ಪರಿಹಾರಗಳಿಗೆ ಕಾರಣವಾಯಿತು.
CommonJS (CJS)
Node.js ನಿಂದ ಜನಪ್ರಿಯಗೊಂಡ CommonJS, ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಲು `require()` ಮತ್ತು ಅವುಗಳನ್ನು ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡಲು `module.exports` ಅನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ಸಿಂಕ್ರೊನಸ್ ಆಗಿದೆ, ಅಂದರೆ ಇದು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಒಂದರ ನಂತರ ಒಂದರಂತೆ ಲೋಡ್ ಮಾಡುತ್ತದೆ, ಇದು ಸ್ಥಳೀಯ ಡಿಸ್ಕ್‌ನಿಂದ ಫೈಲ್‌ಗಳನ್ನು ಓದುವ ಸರ್ವರ್-ಸೈಡ್ ಪರಿಸರಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.
ಉದಾಹರಣೆ:
// utils.js
const PI = 3.14;
function circleArea(radius) {
return PI * radius * radius;
}
module.exports = { PI, circleArea };
// main.js
const { circleArea } = require('./utils.js');
console.log(circleArea(10));
ECMAScript Modules (ESM)
ESM ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಅಧಿಕೃತ, ಪ್ರಮಾಣೀಕೃತ ಮಾಡ್ಯೂಲ್ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ, ಇದನ್ನು ES2015 (ES6) ನಲ್ಲಿ ಪರಿಚಯಿಸಲಾಯಿತು. ಇದು `import` ಮತ್ತು `export` ಕೀವರ್ಡ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ESM ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿದೆ ಮತ್ತು ಬ್ರೌಸರ್‌ಗಳು ಹಾಗೂ Node.js ನಂತಹ ಸರ್ವರ್-ಸೈಡ್ ಪರಿಸರಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಇದು 'ಟ್ರೀ-ಶೇಕಿಂಗ್' ನಂತಹ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಪ್ರಯೋಜನಗಳನ್ನು ಸಹ ಅನುಮತಿಸುತ್ತದೆ — ಇದು ಅಂತಿಮ ಕೋಡ್ ಬಂಡಲ್‌ನಿಂದ ಬಳಕೆಯಾಗದ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದ್ದು, ಅದರ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಉದಾಹರಣೆ:
// utils.js
export const PI = 3.14;
export function circleArea(radius) {
return PI * radius * radius;
}
// main.js
import { circleArea } from './utils.js';
console.log(circleArea(10));
ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಯು ಬಹುಮಟ್ಟಿಗೆ ESM ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದರೆ ಅನೇಕ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳು ಮತ್ತು Node.js ಪ್ಯಾಕೇಜ್‌ಗಳು ಇನ್ನೂ CommonJS ಅನ್ನು ಬಳಸುತ್ತವೆ. ದೃಢವಾದ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಸೆಟಪ್ ಎರಡನ್ನೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ನಿರ್ವಹಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರಬೇಕು.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ಟೈಪ್ ಚೆಕಿಂಗ್‌ಗಾಗಿ ಪ್ರಮುಖ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಪರಿಕರಗಳು
ಹಲವಾರು ಶಕ್ತಿಶಾಲಿ ಪರಿಕರಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗೆ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ಚೆಕಿಂಗ್‌ನ ಪ್ರಯೋಜನಗಳನ್ನು ತರುತ್ತವೆ. ಅವುಗಳಲ್ಲಿ ಪ್ರಮುಖವಾದವುಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್: ವಾಸ್ತವಿಕ ಗುಣಮಟ್ಟ
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಒಂದು ಓಪನ್ ಸೋರ್ಸ್ ಭಾಷೆಯಾಗಿದ್ದು, ಇದು ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೇಲೆ ನಿರ್ಮಿತವಾಗಿದೆ. ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ 'ಸೂಪರ್‌ಸೆಟ್' ಆಗಿದೆ, ಅಂದರೆ ಯಾವುದೇ ಮಾನ್ಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಮಾನ್ಯ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಕೂಡ ಆಗಿದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಯಾವುದೇ ಬ್ರೌಸರ್ ಅಥವಾ Node.js ಪರಿಸರದಲ್ಲಿ ಚಲಾಯಿಸಬಹುದಾದ ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಟ್ರಾನ್ಸ್‌ಪೈಲ್ (ಕಂಪೈಲ್) ಮಾಡಲಾಗುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ನೀವು ನಿಮ್ಮ ವೇರಿಯಬಲ್‌ಗಳು, ಫಂಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಮತ್ತು ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೀರಿ. ನಂತರ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲರ್ (TSC) ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಈ ವ್ಯಾಖ್ಯಾನಗಳಿಗೆ ಹೋಲಿಸಿ ಪರಿಶೀಲಿಸುತ್ತದೆ.
ಮಾಡ್ಯೂಲ್ ಟೈಪಿಂಗ್‌ನೊಂದಿಗೆ ಉದಾಹರಣೆ:
// services/math.ts
export interface CalculationOptions {
precision?: number; // ಐಚ್ಛಿಕ ಪ್ರಾಪರ್ಟಿ
}
export function add(a: number, b: number, options?: CalculationOptions): number {
const result = a + b;
if (options?.precision) {
return parseFloat(result.toFixed(options.precision));
}
return result;
}
// main.ts
import { add } from './services/math';
const sum = add(5.123, 10.456, { precision: 2 }); // ಸರಿ: sum 15.58 ಆಗಿದೆ
const invalidSum = add('5', '10'); // ದೋಷ! ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಇದನ್ನು ಎಡಿಟರ್‌ನಲ್ಲಿ ಫ್ಲ್ಯಾಗ್ ಮಾಡುತ್ತದೆ.
// 'string' ಮಾದರಿಯ ಆರ್ಗ್ಯುಮೆಂಟ್ 'number' ಮಾದರಿಯ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ.
ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ ಕಾನ್ಫಿಗರೇಶನ್: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ನಡವಳಿಕೆಯನ್ನು `tsconfig.json` ಫೈಲ್‌ನಿಂದ ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ. ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಪ್ರಮುಖ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಸೇರಿವೆ:
"module": "esnext": ಇತ್ತೀಚಿನ ECMAScript ಮಾಡ್ಯೂಲ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಳುತ್ತದೆ. ಇತರ ಆಯ್ಕೆಗಳಲ್ಲಿ `"commonjs"`, `"amd"`, ಇತ್ಯಾದಿ ಸೇರಿವೆ."moduleResolution": "node": ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಸೆಟ್ಟಿಂಗ್. Node.js ರೆಸಲ್ಯೂಶನ್ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಅನುಕರಿಸುವ ಮೂಲಕ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಹೇಗೆ ಕಂಡುಹಿಡಿಯಬೇಕು ಎಂದು ಕಂಪೈಲರ್‌ಗೆ ಇದು ಹೇಳುತ್ತದೆ (`node_modules` ಅನ್ನು ಪರಿಶೀಲಿಸುವುದು, ಇತ್ಯಾದಿ)."strict": true: ಇದು ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪ್-ಚೆಕಿಂಗ್ ನಡವಳಿಕೆಗಳ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡಲಾದ ಸೆಟ್ಟಿಂಗ್ ಆಗಿದೆ, ಇದು ಅನೇಕ ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
JSDoc: ಟ್ರಾನ್ಸ್‌ಪಿಲೇಷನ್ ಇಲ್ಲದೆ ಟೈಪ್ ಸುರಕ್ಷತೆ
ಹೊಸ ಭಾಷೆ ಅಥವಾ ಬಿಲ್ಡ್ ಸ್ಟೆಪ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಲು ಸಿದ್ಧವಿಲ್ಲದ ತಂಡಗಳಿಗೆ, JSDoc ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾಮೆಂಟ್‌ಗಳಲ್ಲೇ ನೇರವಾಗಿ ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋ ಕೋಡ್‌ನಂತಹ ಆಧುನಿಕ ಕೋಡ್ ಎಡಿಟರ್‌ಗಳು ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲರ್‌ನಂತಹ ಪರಿಕರಗಳು ಈ JSDoc ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಓದಿ ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗಳಿಗೆ ಟೈಪ್ ಚೆಕಿಂಗ್ ಮತ್ತು ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಒದಗಿಸಬಲ್ಲವು.
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ವಿವರಿಸಲು ನೀವು `@param`, `@returns`, ಮತ್ತು `@type` ನಂತಹ ಟ್ಯಾಗ್‌ಗಳೊಂದಿಗೆ ವಿಶೇಷ ಕಾಮೆಂಟ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು (`/** ... */`) ಬಳಸುತ್ತೀರಿ.
ಮಾಡ್ಯೂಲ್ ಟೈಪಿಂಗ್‌ನೊಂದಿಗೆ ಉದಾಹರಣೆ:
// services/user-service.js
/**
* ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಬಳಕೆದಾರರನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
* @typedef {Object} User
* @property {number} id - ಅನನ್ಯ ಬಳಕೆದಾರ ಗುರುತು.
* @property {string} name - ಬಳಕೆದಾರರ ಪೂರ್ಣ ಹೆಸರು.
* @property {string} email - ಬಳಕೆದಾರರ ಇಮೇಲ್ ವಿಳಾಸ.
* @property {boolean} [isActive] - ಸಕ್ರಿಯ ಸ್ಥಿತಿಗಾಗಿ ಐಚ್ಛಿಕ ಫ್ಲ್ಯಾಗ್.
*/
/**
* ಬಳಕೆದಾರರನ್ನು ಅವರ ಐಡಿಯಿಂದ ಪಡೆಯುತ್ತದೆ.
* @param {number} userId - ಪಡೆಯಬೇಕಾದ ಬಳಕೆದಾರರ ಐಡಿ.
* @returns {Promise
ಈ ಪರಿಶೀಲನೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು, ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ರೂಟ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ವಿಷಯದೊಂದಿಗೆ `jsconfig.json` ಫೈಲ್ ಅನ್ನು ರಚಿಸಬಹುದು:
{
"compilerOptions": {
"checkJs": true,
"target": "es2020",
"module": "esnext"
},
"include": ["**/*.js"]
}
JSDoc ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ಬೇಸ್‌ಗೆ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಪರಿಚಯಿಸಲು ಅತ್ಯುತ್ತಮವಾದ, ಕಡಿಮೆ-ಘರ್ಷಣೆಯ ಮಾರ್ಗವಾಗಿದೆ, ಇದು ಲೆಗಸಿ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಅಥವಾ ಪ್ರಮಾಣಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹತ್ತಿರದಲ್ಲಿರಲು ಆದ್ಯತೆ ನೀಡುವ ತಂಡಗಳಿಗೆ ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.
Flow: ಒಂದು ಐತಿಹಾಸಿಕ ದೃಷ್ಟಿಕೋನ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು
ಫೇಸ್‌ಬುಕ್‌ನಿಂದ ಅಭಿವೃದ್ಧಿಪಡಿಸಲ್ಪಟ್ಟ, Flow ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಮತ್ತೊಂದು ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ಚೆಕರ್ ಆಗಿದೆ. ಆರಂಭದ ದಿನಗಳಲ್ಲಿ ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಪ್ರಬಲ ಸ್ಪರ್ಧಿಯಾಗಿತ್ತು. ಜಾಗತಿಕ ಡೆವಲಪರ್ ಸಮುದಾಯದಲ್ಲಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬಹುಪಾಲು ಜನಪ್ರಿಯತೆಯನ್ನು ಗಳಿಸಿದ್ದರೂ, Flow ಇನ್ನೂ ಸಕ್ರಿಯವಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗುತ್ತಿದೆ ಮತ್ತು ಕೆಲವು ಸಂಸ್ಥೆಗಳಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ರಿಯಾಕ್ಟ್ ನೇಟಿವ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಬಳಸಲ್ಪಡುತ್ತಿದೆ, ಅಲ್ಲಿ ಅದು ಆಳವಾದ ಬೇರುಗಳನ್ನು ಹೊಂದಿದೆ.
Flow ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್‌ಗೆ ಹೋಲುವ ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಅಥವಾ ಕೋಡ್‌ನಿಂದ ಟೈಪ್‌ಗಳನ್ನು ಊಹಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಒಂದು ಫೈಲ್‌ಗಾಗಿ ಇದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಫೈಲ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ `// @flow` ಎಂಬ ಕಾಮೆಂಟ್ ಅಗತ್ಯವಿದೆ.
ಇದು ಇನ್ನೂ ಸಮರ್ಥ ಸಾಧನವಾಗಿದ್ದರೂ, ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಅಥವಾ ಅತಿದೊಡ್ಡ ಸಮುದಾಯದ ಬೆಂಬಲ, ದಸ್ತಾವೇಜು ಮತ್ತು ಲೈಬ್ರರಿ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಬಯಸುವ ತಂಡಗಳಿಗೆ, ಇಂದು ಸಾಮಾನ್ಯವಾಗಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಶಿಫಾರಸು ಮಾಡಲಾದ ಆಯ್ಕೆಯಾಗಿದೆ.
ಪ್ರಾಯೋಗಿಕ ಆಳವಾದ ನೋಟ: ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ಚೆಕಿಂಗ್‌ಗಾಗಿ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು
ಸಿದ್ಧಾಂತದಿಂದ ಅಭ್ಯಾಸಕ್ಕೆ ಹೋಗೋಣ. ದೃಢವಾದ ಮಾಡ್ಯೂಲ್ ಟೈಪ್ ಚೆಕಿಂಗ್‌ಗಾಗಿ ನೀವು ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಹೇಗೆ ಹೊಂದಿಸಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ.
ಮೊದಲಿನಿಂದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಹೊಂದಿಸುವುದು
ಇದು ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಅಥವಾ ಪ್ರಮುಖ ರಿಫ್ಯಾಕ್ಟರ್‌ಗಳಿಗೆ ದಾರಿಯಾಗಿದೆ.
ಹಂತ 1: ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ
ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಅನ್ನು ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ತೆರೆಯಿರಿ ಮತ್ತು ಚಲಾಯಿಸಿ:
npm init -y
npm install typescript --save-dev
ಹಂತ 2: `tsconfig.json` ಅನ್ನು ರಚಿಸಿ
ಶಿಫಾರಸು ಮಾಡಲಾದ ಡೀಫಾಲ್ಟ್‌ಗಳೊಂದಿಗೆ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ:
npx tsc --init
ಹಂತ 3: ಆಧುನಿಕ ಪ್ರಾಜೆಕ್ಟ್‌ಗಾಗಿ `tsconfig.json` ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ
ರಚಿಸಲಾದ `tsconfig.json` ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಅದನ್ನು ಮಾರ್ಪಡಿಸಿ. ES ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸುವ ಆಧುನಿಕ ವೆಬ್ ಅಥವಾ Node.js ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಇಲ್ಲಿ ಒಂದು ದೃಢವಾದ ಆರಂಭಿಕ ಬಿಂದುವಿದೆ:
{
"compilerOptions": {
/* ಟೈಪ್ ಚೆಕಿಂಗ್ */
"strict": true, // ಎಲ್ಲಾ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪ್-ಚೆಕಿಂಗ್ ಆಯ್ಕೆಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ.
"noImplicitAny": true, // 'any' ಟೈಪ್ ಸೂಚಿಸುವ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಘೋಷಣೆಗಳ ಮೇಲೆ ದೋಷವನ್ನು ತೋರಿಸಿ.
"strictNullChecks": true, // ಕಟ್ಟುನಿಟ್ಟಾದ null ಚೆಕ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ.
/* ಮಾಡ್ಯೂಲ್‌ಗಳು */
"module": "esnext", // ಮಾಡ್ಯೂಲ್ ಕೋಡ್ ಉತ್ಪಾದನೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ.
"moduleResolution": "node", // Node.js ಶೈಲಿಯನ್ನು ಬಳಸಿ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಪರಿಹರಿಸಿ.
"esModuleInterop": true, // CommonJS ಮಾಡ್ಯೂಲ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
"baseUrl": "./src", // ಸಂಬಂಧವಿಲ್ಲದ ಮಾಡ್ಯೂಲ್ ಹೆಸರುಗಳನ್ನು ಪರಿಹರಿಸಲು ಮೂಲ ಡೈರೆಕ್ಟರಿ.
"paths": { // ಸ್ವಚ್ಛವಾದ ಇಂಪೋರ್ಟ್‌ಗಳಿಗಾಗಿ ಮಾಡ್ಯೂಲ್ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ರಚಿಸಿ.
"@components/*": ["components/*"],
"@services/*": ["services/*"]
},
/* ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬೆಂಬಲ */
"allowJs": true, // ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಅನುಮತಿಸಿ.
/* ಎಮಿಟ್ */
"outDir": "./dist", // ಔಟ್‌ಪುಟ್ ರಚನೆಯನ್ನು ಡೈರೆಕ್ಟರಿಗೆ ಮರುನಿರ್ದೇಶಿಸಿ.
"sourceMap": true, // ಅನುಗುಣವಾದ '.map' ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
/* ಭಾಷೆ ಮತ್ತು ಪರಿಸರ */
"target": "es2020", // ಹೊರಸೂಸುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿಸಿ.
"lib": ["es2020", "dom"] // ಬಂಡಲ್ ಮಾಡಿದ ಲೈಬ್ರರಿ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳ ಗುಂಪನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ.
},
"include": ["src/**/*"], // 'src' ಫೋಲ್ಡರ್‌ನಲ್ಲಿರುವ ಫೈಲ್‌ಗಳನ್ನು ಮಾತ್ರ ಕಂಪೈಲ್ ಮಾಡಿ.
"exclude": ["node_modules"]
}
ಈ ಕಾನ್ಫಿಗರೇಶನ್ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪಿಂಗ್ ಅನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ, ಆಧುನಿಕ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಹಳೆಯ ಪ್ಯಾಕೇಜ್‌ಗಳೊಂದಿಗೆ ಪರಸ್ಪರ ಕಾರ್ಯಸಾಧ್ಯತೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅನುಕೂಲಕರ ಇಂಪೋರ್ಟ್ ಅಲಿಯಾಸ್‌ಗಳನ್ನು ಸಹ ರಚಿಸುತ್ತದೆ (ಉದಾ., `import MyComponent from '@components/MyComponent'`).
ಮಾಡ್ಯೂಲ್ ಟೈಪ್ ಚೆಕಿಂಗ್‌ನಲ್ಲಿ ಸಾಮಾನ್ಯ ಮಾದರಿಗಳು ಮತ್ತು ಸವಾಲುಗಳು
ನೀವು ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಅನ್ನು ಸಂಯೋಜಿಸಿದಂತೆ, ನೀವು ಹಲವಾರು ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶಗಳನ್ನು ಎದುರಿಸುತ್ತೀರಿ.
ಡೈನಾಮಿಕ್ ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು (`import()`)
ಡೈನಾಮಿಕ್ ಇಂಪೋರ್ಟ್‌ಗಳು ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ಇದು ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಕೋಡ್-ಸ್ಪ್ಲಿಟಿಂಗ್ ಮತ್ತು ಆರಂಭಿಕ ಪೇಜ್ ಲೋಡ್ ಸಮಯವನ್ನು ಸುಧಾರಿಸಲು ಅತ್ಯುತ್ತಮವಾಗಿದೆ. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಂತಹ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪ್ ಚೆಕರ್‌ಗಳು ಇದನ್ನು ನಿರ್ವಹಿಸಲು ಸಾಕಷ್ಟು ಬುದ್ಧಿವಂತವಾಗಿವೆ.
// utils/formatter.ts
export function formatDate(date: Date): string {
return date.toLocaleDateString('en-US');
}
// main.ts
async function showDate() {
if (userNeedsDate) {
const formatterModule = await import('./utils/formatter'); // ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ formatterModule ನ ಟೈಪ್ ಅನ್ನು ಊಹಿಸುತ್ತದೆ
const formatted = formatterModule.formatDate(new Date());
console.log(formatted);
}
}
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ `import()` ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಮಾಡ್ಯೂಲ್‌ನ ನೇಮ್‌ಸ್ಪೇಸ್‌ಗೆ ಪರಿಹರಿಸುವ ಪ್ರಾಮಿಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತದೆ. ಇದು `formatterModule` ಅನ್ನು ಸರಿಯಾಗಿ ಟೈಪ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದರ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಳಿಗಾಗಿ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಥರ್ಡ್-ಪಾರ್ಟಿ ಲೈಬ್ರರಿಗಳನ್ನು ಟೈಪ್ ಮಾಡುವುದು (DefinitelyTyped)
NPM ನಲ್ಲಿನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳ ವಿಶಾಲವಾದ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವುದು ಅತಿದೊಡ್ಡ ಸವಾಲುಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಅನೇಕ ಜನಪ್ರಿಯ ಲೈಬ್ರರಿಗಳನ್ನು ಈಗ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ ಮತ್ತು ಅವುಗಳ ಸ್ವಂತ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಬಂಡಲ್ ಮಾಡುತ್ತವೆ. ಹಾಗೆ ಮಾಡದವುಗಳಿಗಾಗಿ, ಜಾಗತಿಕ ಡೆವಲಪರ್ ಸಮುದಾಯವು DefinitelyTyped ಎಂಬ ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳ ಬೃಹತ್ ಭಂಡಾರವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
ನೀವು ಈ ಟೈಪ್‌ಗಳನ್ನು ಡೆವಲಪ್‌ಮೆಂಟ್ ಡಿಪೆಂಡೆನ್ಸಿಗಳಾಗಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ಜನಪ್ರಿಯ `lodash` ಲೈಬ್ರರಿಯನ್ನು ಟೈಪ್‌ಗಳೊಂದಿಗೆ ಬಳಸಲು:
npm install lodash
npm install @types/lodash --save-dev
ಇದರ ನಂತರ, ನೀವು ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗೆ `lodash` ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿದಾಗ, ಅದರ ಎಲ್ಲಾ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಸಂಪೂರ್ಣ ಟೈಪ್-ಚೆಕಿಂಗ್ ಮತ್ತು ಸ್ವಯಂಪೂರ್ಣತೆ ಲಭ್ಯವಾಗುತ್ತದೆ. ಬಾಹ್ಯ ಕೋಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಇದು ಒಂದು ಗೇಮ್-ಚೇಂಜರ್ ಆಗಿದೆ.
ಅಂತರವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು: ES ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು CommonJS ನಡುವಿನ ಪರಸ್ಪರ ಕಾರ್ಯಸಾಧ್ಯತೆ
ನೀವು ಆಗಾಗ್ಗೆ ES ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು (`import`/`export`) ಬಳಸುವ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಇರುತ್ತೀರಿ, ಆದರೆ CommonJS ನಲ್ಲಿ (`require`/`module.exports`) ಬರೆಯಲಾದ ಡಿಪೆಂಡೆನ್ಸಿಯನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಇದು ಗೊಂದಲಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಡೀಫಾಲ್ಟ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಳ ಸುತ್ತ.
`tsconfig.json` ನಲ್ಲಿನ `"esModuleInterop": true` ಫ್ಲ್ಯಾಗ್ ಇಲ್ಲಿ ನಿಮ್ಮ ಉತ್ತಮ ಸ್ನೇಹಿತ. ಇದು CJS ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿ ಸಿಂಥೆಟಿಕ್ ಡೀಫಾಲ್ಟ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ, ಸ್ವಚ್ಛ, ಪ್ರಮಾಣಿತ ಇಂಪೋರ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ:
// esModuleInterop ಇಲ್ಲದೆ, ನೀವು ಹೀಗೆ ಮಾಡಬೇಕಾಗಬಹುದು:
import * as moment from 'moment';
// esModuleInterop: true ನೊಂದಿಗೆ, ನೀವು ಹೀಗೆ ಮಾಡಬಹುದು:
import moment from 'moment';
ಈ ಮಾಡ್ಯೂಲ್-ಫಾರ್ಮ್ಯಾಟ್ ಅಸಂಗತತೆಗಳನ್ನು ಸರಾಗಗೊಳಿಸಲು ಯಾವುದೇ ಆಧುನಿಕ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಈ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.
ಟೈಪ್ ಚೆಕಿಂಗ್ ಆಚೆಗೆ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್: ಲಿಂಟರ್‌ಗಳು ಮತ್ತು ಫಾರ್ಮ್ಯಾಟರ್‌ಗಳು
ಟೈಪ್ ಚೆಕಿಂಗ್ ಮೂಲಭೂತವಾಗಿದ್ದರೂ, ಸಂಪೂರ್ಣ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ತಂತ್ರವು ನಿಮ್ಮ ಟೈಪ್ ಚೆಕರ್‌ನೊಂದಿಗೆ ಸಾಮರಸ್ಯದಿಂದ ಕೆಲಸ ಮಾಡುವ ಇತರ ಪರಿಕರಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
ESLint ಮತ್ತು TypeScript-ESLint ಪ್ಲಗಿನ್
ESLint ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಪ್ಲಗ್ ಮಾಡಬಹುದಾದ ಲಿಂಟಿಂಗ್ ಯುಟಿಲಿಟಿಯಾಗಿದೆ. ಇದು ಟೈಪ್ ದೋಷಗಳನ್ನು ಮೀರಿ ಶೈಲಿಯ ನಿಯಮಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು, ಆಂಟಿ-ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಹುಡುಕಲು ಮತ್ತು ಟೈಪ್ ಸಿಸ್ಟಮ್ ತಪ್ಪಿಸಬಹುದಾದ ತಾರ್ಕಿಕ ದೋಷಗಳನ್ನು ಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. `typescript-eslint` ಪ್ಲಗಿನ್‌ನೊಂದಿಗೆ, ಇದು ಇನ್ನೂ ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ ಪರಿಶೀಲನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಟೈಪ್ ಮಾಹಿತಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು.
ಉದಾಹರಣೆಗೆ, ನೀವು ESLint ಅನ್ನು ಹೀಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು:
- ಸ್ಥಿರವಾದ ಇಂಪೋರ್ಟ್ ಕ್ರಮವನ್ನು ಜಾರಿಗೊಳಿಸಿ (`import/order` ನಿಯಮ).
- ರಚಿಸಲಾದ ಆದರೆ ನಿರ್ವಹಿಸದ `Promise` ಗಳ ಬಗ್ಗೆ ಎಚ್ಚರಿಸಿ (ಉದಾ., await ಮಾಡದಿರುವುದು).
- `any` ಟೈಪ್ ಬಳಕೆಯನ್ನು ತಡೆಯಿರಿ, ಡೆವಲಪರ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿರಲು ಒತ್ತಾಯಿಸಿ.
ಸ್ಥಿರವಾದ ಕೋಡ್ ಶೈಲಿಗಾಗಿ Prettier
ಜಾಗತಿಕ ತಂಡದಲ್ಲಿ, ಡೆವಲಪರ್‌ಗಳು ಕೋಡ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ಗಾಗಿ ವಿಭಿನ್ನ ಆದ್ಯತೆಗಳನ್ನು ಹೊಂದಿರಬಹುದು (ಟ್ಯಾಬ್‌ಗಳು vs. ಸ್ಪೇಸ್‌ಗಳು, ಉಲ್ಲೇಖ ಶೈಲಿ, ಇತ್ಯಾದಿ). ಈ ಸಣ್ಣ ವ್ಯತ್ಯಾಸಗಳು ಕೋಡ್ ವಿಮರ್ಶೆಗಳಲ್ಲಿ ಗೊಂದಲವನ್ನು ಸೃಷ್ಟಿಸಬಹುದು. Prettier ಒಂದು ಅಭಿಪ್ರಾಯಯುಕ್ತ ಕೋಡ್ ಫಾರ್ಮ್ಯಾಟರ್ ಆಗಿದ್ದು, ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ಸ್ಥಿರವಾದ ಶೈಲಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುವ ಮೂಲಕ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಇದನ್ನು ನಿಮ್ಮ ವರ್ಕ್‌ಫ್ಲೋಗೆ ಸಂಯೋಜಿಸುವ ಮೂಲಕ (ಉದಾ., ನಿಮ್ಮ ಎಡಿಟರ್‌ನಲ್ಲಿ ಸೇವ್ ಮಾಡಿದಾಗ ಅಥವಾ ಪ್ರಿ-ಕಮಿಟ್ ಹುಕ್ ಆಗಿ), ನೀವು ಶೈಲಿಯ ಬಗ್ಗೆ ಎಲ್ಲಾ ಚರ್ಚೆಗಳನ್ನು ನಿವಾರಿಸುತ್ತೀರಿ ಮತ್ತು ಕೋಡ್‌ಬೇಸ್ ಎಲ್ಲರಿಗೂ ಏಕರೂಪವಾಗಿ ಓದಬಲ್ಲದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತೀರಿ.
ವ್ಯವಹಾರದ ಪ್ರಕರಣ: ಜಾಗತಿಕ ತಂಡಗಳಿಗೆ ಸ್ಟ್ಯಾಟಿಟಿಕ್ ಅನಾಲಿಸಿಸ್‌ನಲ್ಲಿ ಏಕೆ ಹೂಡಿಕೆ ಮಾಡಬೇಕು?
ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವುದು ಕೇವಲ ತಾಂತ್ರಿಕ ನಿರ್ಧಾರವಲ್ಲ; ಇದು ಹೂಡಿಕೆಯ ಮೇಲೆ ಸ್ಪಷ್ಟವಾದ ಲಾಭವನ್ನು ಹೊಂದಿರುವ ಒಂದು ಕಾರ್ಯತಂತ್ರದ ವ್ಯವಹಾರ ನಿರ್ಧಾರವಾಗಿದೆ.
- ಕಡಿಮೆ ಬಗ್‌ಗಳು ಮತ್ತು ನಿರ್ವಹಣಾ ವೆಚ್ಚಗಳು: ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಅವುಗಳನ್ನು ಸರಿಪಡಿಸುವುದಕ್ಕಿಂತ ಘಾತೀಯವಾಗಿ ಅಗ್ಗವಾಗಿದೆ. ಸ್ಥಿರ, ಊಹಿಸಬಹುದಾದ ಕೋಡ್‌ಬೇಸ್‌ಗೆ ಡೀಬಗ್ಗಿಂಗ್ ಮತ್ತು ನಿರ್ವಹಣೆಗೆ ಕಡಿಮೆ ಸಮಯ ಬೇಕಾಗುತ್ತದೆ.
- ಸುಧಾರಿತ ಡೆವಲಪರ್ ಆನ್‌ಬೋರ್ಡಿಂಗ್ ಮತ್ತು ಸಹಯೋಗ: ಹೊಸ ತಂಡದ ಸದಸ್ಯರು, ಅವರ ಭೌಗೋಳಿಕ ಸ್ಥಳವನ್ನು ಲೆಕ್ಕಿಸದೆ, ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ವೇಗವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು ಏಕೆಂದರೆ ಟೈಪ್‌ಗಳು ಸ್ವಯಂ-ದಾಖಲಿಸುವ ಕೋಡ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಇದು ಉತ್ಪಾದಕತೆಗೆ ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
- ವರ್ಧಿತ ಕೋಡ್‌ಬೇಸ್ ಸ್ಕೇಲೆಬಿಲಿಟಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ತಂಡವು ಬೆಳೆದಂತೆ, ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಸಂಕೀರ್ಣತೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಾದ ರಚನಾತ್ಮಕ ಸಮಗ್ರತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ದೊಡ್ಡ-ಪ್ರಮಾಣದ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ಕಾರ್ಯಸಾಧ್ಯ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿಸುತ್ತದೆ.
- "ಸತ್ಯದ ಏಕೈಕ ಮೂಲ"ವನ್ನು ರಚಿಸುವುದು: ನಿಮ್ಮ API ಪ್ರತಿಕ್ರಿಯೆಗಳು ಅಥವಾ ಹಂಚಿದ ಡೇಟಾ ಮಾದರಿಗಳಿಗಾಗಿ ಟೈಪ್ ವ್ಯಾಖ್ಯಾನಗಳು ಫ್ರಂಟ್-ಎಂಡ್ ಮತ್ತು ಬ್ಯಾಕ್-ಎಂಡ್ ತಂಡಗಳೆರಡಕ್ಕೂ ಸತ್ಯದ ಏಕೈಕ ಮೂಲವಾಗುತ್ತವೆ, ಇದು ಏಕೀಕರಣ ದೋಷಗಳು ಮತ್ತು ತಪ್ಪು ತಿಳುವಳಿಕೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ತೀರ್ಮಾನ: ದೃಢವಾದ, ಸ್ಕೇಲೆಬಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕ್ರಿಯಾತ್ಮಕ, ನಮ್ಯ ಸ್ವಭಾವವು ಅದರ ದೊಡ್ಡ ಶಕ್ತಿಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಆದರೆ ಇದು ಸ್ಥಿರತೆ ಮತ್ತು ಊಹಿಸುವಿಕೆಯ ವೆಚ್ಚದಲ್ಲಿ ಬರಬೇಕಾಗಿಲ್ಲ. ಮಾಡ್ಯೂಲ್ ಟೈಪ್ ಚೆಕಿಂಗ್‌ಗಾಗಿ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಡೆವಲಪರ್ ಅನುಭವವನ್ನು ಮತ್ತು ಅಂತಿಮ ಉತ್ಪನ್ನದ ಗುಣಮಟ್ಟವನ್ನು ಪರಿವರ್ತಿಸುವ ಶಕ್ತಿಯುತ ಸುರಕ್ಷತಾ ಜಾಲವನ್ನು ಪರಿಚಯಿಸುತ್ತೀರಿ.
ಆಧುನಿಕ, ಜಾಗತಿಕವಾಗಿ-ವಿತರಿಸಿದ ತಂಡಗಳಿಗೆ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು JSDoc ನಂತಹ ಪರಿಕರಗಳು ಇನ್ನು ಮುಂದೆ ಐಷಾರಾಮಿ ಅಲ್ಲ - ಅವು ಅವಶ್ಯಕತೆ. ಅವು ಸಾಂಸ್ಕೃತಿಕ ಮತ್ತು ಭಾಷಾ ಅಡೆತಡೆಗಳನ್ನು ಮೀರಿದ ಡೇಟಾ ರಚನೆಗಳ ಸಾಮಾನ್ಯ ಭಾಷೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸಂಕೀರ್ಣ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ವಿಶ್ವಾಸದಿಂದ ನಿರ್ಮಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ. ದೃಢವಾದ ಸ್ಟ್ಯಾಟಿಕ್ ಅನಾಲಿಸಿಸ್ ಸೆಟಪ್‌ನಲ್ಲಿ ಹೂಡಿಕೆ ಮಾಡುವ ಮೂಲಕ, ನೀವು ಕೇವಲ ಉತ್ತಮ ಕೋಡ್ ಬರೆಯುತ್ತಿಲ್ಲ; ನೀವು ಹೆಚ್ಚು ದಕ್ಷ, ಸಹಯೋಗಿ ಮತ್ತು ಯಶಸ್ವಿ ಇಂಜಿನಿಯರಿಂಗ್ ಸಂಸ್ಕೃತಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದೀರಿ.