ಯಾವುದೇ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗೆ ಟೈಪ್ ಸುರಕ್ಷತೆ ಮತ್ತು ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಅನ್‌ಲಾಕ್ ಮಾಡಲು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು (.d.ts) ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ. @types ಬಳಸುವುದು, ನಿಮ್ಮ ಸ್ವಂತ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಥರ್ಡ್-ಪಾರ್ಟಿ ಕೋಡ್ ಅನ್ನು ವೃತ್ತಿಪರರಂತೆ ನಿರ್ವಹಿಸುವುದನ್ನು ಕಲಿಯಿರಿ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯನ್ನು ಅನ್‌ಲಾಕ್ ಮಾಡುವುದು: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳ ಬಗ್ಗೆ ಆಳವಾದ ನೋಟ
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಡೈನಾಮಿಕ್ ಜಗತ್ತಿಗೆ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್ ಅನ್ನು ತರುವ ಮೂಲಕ ಆಧುನಿಕ ವೆಬ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಕ್ರಾಂತಿಯನ್ನುಂಟುಮಾಡಿದೆ. ಈ ಟೈಪ್ ಸುರಕ್ಷತೆಯು ಅದ್ಭುತ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ಕಂಪೈಲ್-ಟೈಮ್‌ನಲ್ಲಿ ದೋಷಗಳನ್ನು ಹಿಡಿಯುವುದು, ಶಕ್ತಿಯುತ ಎಡಿಟರ್ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು, ಮತ್ತು ದೊಡ್ಡ ಕೋಡ್‌ಬೇಸ್‌ಗಳನ್ನು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚು ನಿರ್ವಹಣಾ ಯೋಗ್ಯವಾಗಿಸುವುದು. ಆದಾಗ್ಯೂ, ನಾವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳ ವ್ಯಾಪಕ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಲು ಬಯಸಿದಾಗ ಒಂದು ಪ್ರಮುಖ ಸವಾಲು ಉದ್ಭವಿಸುತ್ತದೆ—ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟಿಲ್ಲ. ನಮ್ಮ ಕಟ್ಟುನಿಟ್ಟಾಗಿ-ಟೈಪ್ ಮಾಡಿದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್, ಟೈಪ್ ಮಾಡದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಯಿಂದ ಬರುವ ಆಕಾರಗಳು, ಫಂಕ್ಷನ್‌ಗಳು ಮತ್ತು ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಹೇಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತದೆ?
ಇದಕ್ಕೆ ಉತ್ತರ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳಲ್ಲಿದೆ. ಈ ಫೈಲ್‌ಗಳು ತಮ್ಮ .d.ts ವಿಸ್ತರಣೆಯಿಂದ ಗುರುತಿಸಲ್ಪಡುತ್ತವೆ, ಮತ್ತು ಇವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಪಂಚಗಳ ನಡುವಿನ ಅತ್ಯಗತ್ಯ ಸೇತುವೆಯಾಗಿವೆ. ಅವು ಒಂದು ಬ್ಲೂಪ್ರಿಂಟ್ ಅಥವಾ API ಕಾಂಟ್ರಾಕ್ಟ್‌ನಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಥರ್ಡ್-ಪಾರ್ಟಿ ಲೈಬ್ರರಿಯ ಯಾವುದೇ ನೈಜ ಅನುಷ್ಠಾನವನ್ನು ಹೊಂದಿರದೆ ಅದರ ಟೈಪ್‌ಗಳನ್ನು ವಿವರಿಸುತ್ತವೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ ಯಾವುದೇ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಾಗಿ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ನಿರ್ವಹಿಸಲು ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಎಲ್ಲವನ್ನೂ ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳು ಅಂದರೇನು?
ನೀವು ಬೇರೆ ಭಾಷೆಯನ್ನು ಮಾತ್ರ ಮಾತನಾಡುವ ಗುತ್ತಿಗೆದಾರರನ್ನು ನೇಮಿಸಿಕೊಂಡಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಅವರೊಂದಿಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು, ನಿಮಗೆ ಅನುವಾದಕ ಅಥವಾ ನೀವಿಬ್ಬರೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಭಾಷೆಯಲ್ಲಿ ವಿವರವಾದ ಸೂಚನೆಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ. ಒಂದು ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲರ್‌ಗೆ (ಗುತ್ತಿಗೆದಾರ) ನಿಖರವಾಗಿ ಇದೇ ಉದ್ದೇಶವನ್ನು ಪೂರೈಸುತ್ತದೆ.
ಒಂದು .d.ts ಫೈಲ್ ಕೇವಲ ಟೈಪ್ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಅದು ಒಳಗೊಂಡಿರುತ್ತದೆ:
- ಫಂಕ್ಷನ್‌ಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳಿಗಾಗಿ ಸಿಗ್ನೇಚರ್‌ಗಳು (ಪ್ಯಾರಾಮೀಟರ್ ಟೈಪ್‌ಗಳು, ರಿಟರ್ನ್ ಟೈಪ್‌ಗಳು).
- ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಟೈಪ್‌ಗಳಿಗಾಗಿ ಡೆಫಿನಿಷನ್‌ಗಳು.
- ಸಂಕೀರ್ಣ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗಾಗಿ ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ಟೈಪ್ ಅಲಿಯಾಸ್‌ಗಳು.
- ಕ್ಲಾಸ್ ಡೆಫಿನಿಷನ್‌ಗಳು, ಅವುಗಳ ಪ್ರಾಪರ್ಟಿಗಳು ಮತ್ತು ಮೆಥಡ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ.
- ನೇಮ್‌ಸ್ಪೇಸ್ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ರಚನೆಗಳು.
ಮುಖ್ಯವಾಗಿ, ಈ ಫೈಲ್‌ಗಳಲ್ಲಿ ಯಾವುದೇ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಇರುವುದಿಲ್ಲ. ಅವು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಟ್ಯಾಟಿಕ್ ವಿಶ್ಲೇಷಣೆಗಾಗಿವೆ. ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ನೀವು Lodash ನಂತಹ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಯನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿದಾಗ, ಕಂಪೈಲರ್ ಅದಕ್ಕೆ ಅನುಗುಣವಾದ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ. ಅದು ಒಂದನ್ನು ಕಂಡುಕೊಂಡರೆ, ಅದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸಬಹುದು, ಬುದ್ಧಿವಂತ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಒದಗಿಸಬಹುದು, ಮತ್ತು ನೀವು ಲೈಬ್ರರಿಯನ್ನು ಸರಿಯಾಗಿ ಬಳಸುತ್ತಿರುವಿರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು. ಅದು ಸಿಗದಿದ್ದರೆ, ಅದು Could not find a declaration file for module 'lodash'. ನಂತಹ ದೋಷವನ್ನು ನೀಡುತ್ತದೆ.
ವೃತ್ತಿಪರ ಅಭಿವೃದ್ಧಿಗೆ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳು ಏಕೆ ಅತ್ಯಗತ್ಯ
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಸರಿಯಾದ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳಿಲ್ಲದೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುವುದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುವ ಮೂಲ ಕಾರಣವನ್ನೇ ದುರ್ಬಲಗೊಳಿಸುತ್ತದೆ. ಜನಪ್ರಿಯ ಯುಟಿಲಿಟಿ ಲೈಬ್ರರಿ, Lodash ಅನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಸರಳ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸೋಣ.
ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳಿಲ್ಲದ ಜಗತ್ತು
ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಇಲ್ಲದಿದ್ದರೆ, lodash ಅಂದರೇನು ಅಥವಾ ಅದರಲ್ಲಿ ಏನಿದೆ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ. ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು, ನೀವು ಈ ರೀತಿಯ ತ್ವರಿತ ಪರಿಹಾರವನ್ನು ಬಳಸಲು ಪ್ರಚೋದಿತರಾಗಬಹುದು:
const _: any = require('lodash');
const users = [{ 'user': 'barney' }, { 'user': 'fred' }];
// ಸ್ವಯಂಪೂರ್ಣತೆ? ಇಲ್ಲಿ ಯಾವುದೇ ಸಹಾಯವಿಲ್ಲ.
// ಟೈಪ್ ಪರಿಶೀಲನೆ? ಇಲ್ಲ. 'username' ಸರಿಯಾದ ಪ್ರಾಪರ್ಟಿಯೇ?
// ಕಂಪೈಲರ್ ಇದನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಇದು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ವಿಫಲವಾಗಬಹುದು.
_.find(users, { username: 'fred' });
ಈ ಸಂದರ್ಭದಲ್ಲಿ, _ ವೇರಿಯಬಲ್ any ಟೈಪ್‌ನದ್ದಾಗಿದೆ. ಇದು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ "ಈ ವೇರಿಯಬಲ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಯಾವುದನ್ನೂ ಪರಿಶೀಲಿಸಬೇಡ" ಎಂದು ಹೇಳುತ್ತದೆ. ನೀವು ಎಲ್ಲಾ ಪ್ರಯೋಜನಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತೀರಿ: ಸ್ವಯಂಪೂರ್ಣತೆ ಇಲ್ಲ, ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಮೇಲೆ ಟೈಪ್ ಪರಿಶೀಲನೆ ಇಲ್ಲ, ಮತ್ತು ರಿಟರ್ನ್ ಟೈಪ್ ಬಗ್ಗೆ ಯಾವುದೇ ಖಚಿತತೆ ಇಲ್ಲ. ಇದು ರನ್‌ಟೈಮ್ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳಿರುವ ಜಗತ್ತು
ಈಗ, ನಾವು ಅಗತ್ಯವಾದ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಒದಗಿಸಿದಾಗ ಏನಾಗುತ್ತದೆ ಎಂದು ನೋಡೋಣ. ಟೈಪ್‌ಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ ನಂತರ (ಅದನ್ನು ನಾವು ಮುಂದೆ ಚರ್ಚಿಸುತ್ತೇವೆ), ಅನುಭವವು ರೂಪಾಂತರಗೊಳ್ಳುತ್ತದೆ:
import _ from 'lodash';
interface User {
user: string;
active?: boolean;
}
const users: User[] = [{ 'user': 'barney' }, { 'user': 'fred' }];
// 1. ಎಡಿಟರ್ 'find' ಮತ್ತು ಇತರ lodash ಫಂಕ್ಷನ್‌ಗಳಿಗಾಗಿ ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
// 2. 'find' ಮೇಲೆ ಹೋವರ್ ಮಾಡಿದಾಗ ಅದರ ಪೂರ್ಣ ಸಿಗ್ನೇಚರ್ ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ತೋರಿಸುತ್ತದೆ.
// 3. ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ `users` ಎಂಬುದು `User` ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಅರೇ ಎಂದು ನೋಡುತ್ತದೆ.
// 4. `User[]` ಮೇಲಿನ `find` ಗಾಗಿ ಪ್ರಿಡಿಕೇಟ್ `user` ಅಥವಾ `active` ಅನ್ನು ಒಳಗೊಂಡಿರಬೇಕು ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ತಿಳಿದಿದೆ.
// ಸರಿ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸಂತೋಷವಾಗಿದೆ.
const fred = _.find(users, { user: 'fred' });
// ದೋಷ: ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ತಪ್ಪನ್ನು ಹಿಡಿಯುತ್ತದೆ!
// 'User' ಟೈಪ್‌ನಲ್ಲಿ 'username' ಎಂಬ ಪ್ರಾಪರ್ಟಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.
const betty = _.find(users, { username: 'betty' });
ವ್ಯತ್ಯಾಸವು ಹಗಲು-ರಾತ್ರಿಯಂತಿದೆ. ನಾವು ಪೂರ್ಣ ಟೈಪ್ ಸುರಕ್ಷತೆ, ಟೂಲಿಂಗ್ ಮೂಲಕ ಉತ್ತಮ ಡೆವಲಪರ್ ಅನುಭವ, ಮತ್ತು ಸಂಭಾವ್ಯ ಬಗ್‌ಗಳಲ್ಲಿ ನಾಟಕೀಯ ಇಳಿಕೆಯನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವೃತ್ತಿಪರ ಗುಣಮಟ್ಟವಾಗಿದೆ.
ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಹುಡುಕುವ ಶ್ರೇಣಿ
ಹಾಗಾದರೆ, ನಿಮ್ಮ ನೆಚ್ಚಿನ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ ಈ ಮಾಂತ್ರಿಕ .d.ts ಫೈಲ್‌ಗಳನ್ನು ನೀವು ಹೇಗೆ ಪಡೆಯುತ್ತೀರಿ? ಬಹುಪಾಲು ಸನ್ನಿವೇಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಸುಸ್ಥಾಪಿತ ಪ್ರಕ್ರಿಯೆಯಿದೆ.
ಹಂತ 1: ಲೈಬ್ರರಿಯು ತನ್ನದೇ ಆದ ಟೈಪ್‌ಗಳನ್ನು ಬಂಡಲ್ ಮಾಡುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
ಅತ್ಯುತ್ತಮ ಸನ್ನಿವೇಶವೆಂದರೆ, ಒಂದು ಲೈಬ್ರರಿಯನ್ನು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದ್ದರೆ ಅಥವಾ ಅದರ ನಿರ್ವಾಹಕರು ಅದೇ ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಅಧಿಕೃತ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸಿದಾಗ. ಆಧುನಿಕ, ಉತ್ತಮವಾಗಿ ನಿರ್ವಹಿಸಲ್ಪಡುವ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಿಗೆ ಇದು ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗುತ್ತಿದೆ.
ಹೇಗೆ ಪರಿಶೀಲಿಸುವುದು:
- ಲೈಬ್ರರಿಯನ್ನು ಎಂದಿನಂತೆ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ:
npm install axios node_modules/axiosನಲ್ಲಿ ಲೈಬ್ರರಿಯ ಫೋಲ್ಡರ್ ಒಳಗೆ ನೋಡಿ. ನೀವು ಯಾವುದೇ.d.tsಫೈಲ್‌ಗಳನ್ನು ನೋಡುತ್ತೀರಾ?- ಲೈಬ್ರರಿಯ
package.jsonಫೈಲ್‌ನಲ್ಲಿ"types"ಅಥವಾ"typings"ಫೀಲ್ಡ್ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ. ಈ ಫೀಲ್ಡ್ ನೇರವಾಗಿ ಮುಖ್ಯ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗೆ ಸೂಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, Axios ನpackage.jsonಫೈಲ್‌ನಲ್ಲಿ:"types": "index.d.ts"ಇದೆ.
ಈ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಿದರೆ, ನಿಮ್ಮ ಕೆಲಸ ಮುಗಿದಿದೆ! ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಬಂಡಲ್ ಮಾಡಿದ ಟೈಪ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹುಡುಕುತ್ತದೆ ಮತ್ತು ಬಳಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಕ್ರಮದ ಅಗತ್ಯವಿಲ್ಲ.
ಹಂತ 2: ಡೆಫಿನಿಟ್ಲಿಟೈಪ್ಡ್ ಪ್ರಾಜೆಕ್ಟ್ (@types)
ತಮ್ಮದೇ ಆದ ಟೈಪ್‌ಗಳನ್ನು ಬಂಡಲ್ ಮಾಡದ ಸಾವಿರಾರು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ, ಜಾಗತಿಕ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸಮುದಾಯವು ಒಂದು ಅದ್ಭುತ ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸಿದೆ: ಡೆಫಿನಿಟ್ಲಿಟೈಪ್ಡ್ (DefinitelyTyped).
ಡೆಫಿನಿಟ್ಲಿಟೈಪ್ಡ್ ಎಂಬುದು GitHub ನಲ್ಲಿನ ಒಂದು ಕೇಂದ್ರೀಕೃತ, ಸಮುದಾಯ-ನಿರ್ವಹಣೆಯ ರೆಪೊಸಿಟರಿಯಾಗಿದ್ದು, ಇದು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ಯಾಕೇಜ್‌ಗಳಿಗಾಗಿ ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಹೋಸ್ಟ್ ಮಾಡುತ್ತದೆ. ಈ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು npm ರಿಜಿಸ್ಟ್ರಿಗೆ @types ಸ್ಕೋಪ್ ಅಡಿಯಲ್ಲಿ ಪ್ರಕಟಿಸಲಾಗುತ್ತದೆ.
ಅದನ್ನು ಹೇಗೆ ಬಳಸುವುದು:
ಒಂದು ವೇಳೆ lodash ನಂತಹ ಲೈಬ್ರರಿಯು ತನ್ನದೇ ಆದ ಟೈಪ್‌ಗಳನ್ನು ಬಂಡಲ್ ಮಾಡದಿದ್ದರೆ, ನೀವು ಅದರ ಅನುಗುಣವಾದ @types ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಡೆವಲಪ್ಮೆಂಟ್ ಡಿಪೆಂಡೆನ್ಸಿಯಾಗಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದರೆ ಸಾಕು:
npm install --save-dev @types/lodash
ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯವು ಸರಳ ಮತ್ತು ಊಹಿಸಬಹುದಾದಂತಿದೆ: package-name ಹೆಸರಿನ ಪ್ಯಾಕೇಜ್‌ಗಾಗಿ, ಅದರ ಟೈಪ್‌ಗಳು ಬಹುತೇಕ ಯಾವಾಗಲೂ @types/package-name ನಲ್ಲಿ ಇರುತ್ತವೆ. ನೀವು ಲಭ್ಯವಿರುವ ಟೈಪ್‌ಗಳನ್ನು npm ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ಅಥವಾ ನೇರವಾಗಿ ಡೆಫಿನಿಟ್ಲಿಟೈಪ್ಡ್ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಹುಡುಕಬಹುದು.
ಏಕೆ --save-dev? ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳು ಕೇವಲ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಸಂಕಲನ ಸಮಯದಲ್ಲಿ ಮಾತ್ರ ಬೇಕಾಗುತ್ತವೆ. ಅವು ಯಾವುದೇ ರನ್‌ಟೈಮ್ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ನಿಮ್ಮ ಅಂತಿಮ ಪ್ರೊಡಕ್ಷನ್ ಬಂಡಲ್‌ನಲ್ಲಿ ಸೇರಿಸಬಾರದು. ಅವುಗಳನ್ನು devDependency ಆಗಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುವುದು ಈ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಹಂತ 3: ಯಾವುದೇ ಟೈಪ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದಾಗ - ನಿಮ್ಮದೇ ಆದದ್ದನ್ನು ಬರೆಯುವುದು
ನೀವು ಹಳೆಯ, ಅಪರೂಪದ, ಅಥವಾ ಆಂತರಿಕ ಖಾಸಗಿ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಅದು ಟೈಪ್‌ಗಳನ್ನು ಬಂಡಲ್ ಮಾಡುವುದಿಲ್ಲ ಮತ್ತು ಡೆಫಿನಿಟ್ಲಿಟೈಪ್ಡ್‌ನಲ್ಲಿಲ್ಲದಿದ್ದರೆ ಏನು ಮಾಡುವುದು? ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಶ್ರಮವಹಿಸಿ ನಿಮ್ಮದೇ ಆದ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗುತ್ತದೆ. ಇದು ಬೆದರಿಸುವಂತೆ ತೋರಬಹುದಾದರೂ, ನೀವು ಸರಳವಾಗಿ ಪ್ರಾರಂಭಿಸಬಹುದು ಮತ್ತು ಅಗತ್ಯವಿರುವಂತೆ ಹೆಚ್ಚಿನ ವಿವರಗಳನ್ನು ಸೇರಿಸಬಹುದು.
ತ್ವರಿತ ಪರಿಹಾರ: ಶಾರ್ಟ್‌ಹ್ಯಾಂಡ್ ಆಂಬಿಯೆಂಟ್ ಮಾಡ್ಯೂಲ್ ಡಿಕ್ಲರೇಶನ್
ಕೆಲವೊಮ್ಮೆ, ನೀವು ಸರಿಯಾದ ಟೈಪಿಂಗ್ ತಂತ್ರವನ್ನು ಕಂಡುಕೊಳ್ಳುವಾಗ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ದೋಷಗಳಿಲ್ಲದೆ ಕಂಪೈಲ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ನೀವು ಒಂದು ಫೈಲ್ ಅನ್ನು ರಚಿಸಬಹುದು (ಉದಾ., declarations.d.ts ಅಥವಾ types/global.d.ts) ಮತ್ತು ಶಾರ್ಟ್‌ಹ್ಯಾಂಡ್ ಡಿಕ್ಲರೇಶನ್ ಅನ್ನು ಸೇರಿಸಬಹುದು:
// ಒಂದು .d.ts ಫೈಲ್‌ನಲ್ಲಿ
declare module 'some-untyped-library';
ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಳುತ್ತದೆ, "ನನ್ನನ್ನು ನಂಬು, 'some-untyped-library' ಹೆಸರಿನ ಮಾಡ್ಯೂಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಅದರಿಂದ ಇಂಪೋರ್ಟ್ ಮಾಡಿದ ಎಲ್ಲವನ್ನೂ any ಟೈಪ್ ಎಂದು ಪರಿಗಣಿಸು." ಇದು ಕಂಪೈಲರ್ ದೋಷವನ್ನು ಮೌನಗೊಳಿಸುತ್ತದೆ, ಆದರೆ ನಾವು ಚರ್ಚಿಸಿದಂತೆ, ಇದು ಆ ಲೈಬ್ರರಿಗಾಗಿ ಎಲ್ಲಾ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ತ್ಯಾಗ ಮಾಡುತ್ತದೆ. ಇದು ತಾತ್ಕಾಲಿಕ ಪರಿಹಾರ, ದೀರ್ಘಕಾಲೀನ ಪರಿಹಾರವಲ್ಲ.
ಮೂಲಭೂತ ಕಸ್ಟಮ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸುವುದು
ಉತ್ತಮ ವಿಧಾನವೆಂದರೆ ನೀವು ನಿಜವಾಗಿಯೂ ಬಳಸುವ ಲೈಬ್ರರಿಯ ಭಾಗಗಳಿಗೆ ಟೈಪ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಪ್ರಾರಂಭಿಸುವುದು. ನಾವು `string-utils` ಎಂಬ ಸರಳ ಲೈಬ್ರರಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಭಾವಿಸೋಣ, ಅದು ಒಂದೇ ಫಂಕ್ಷನ್ ಅನ್ನು ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡುತ್ತದೆ.
// node_modules/string-utils/index.js ನಲ್ಲಿ
module.exports.capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
ನಾವು ನಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನ ರೂಟ್‌ನಲ್ಲಿರುವ `types` ಎಂಬ ಮೀಸಲಾದ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ string-utils.d.ts ಫೈಲ್ ಅನ್ನು ರಚಿಸಬಹುದು.
// my-project/types/string-utils.d.ts ನಲ್ಲಿ
declare module 'string-utils' {
export function capitalize(str: string): string;
// ನೀವು ಬಳಸುವಂತೆ ಇತರ ಫಂಕ್ಷನ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಇಲ್ಲಿ ಸೇರಿಸಬಹುದು
// export function slugify(str: string): string;
}
ಈಗ, ನಮ್ಮ ಕಸ್ಟಮ್ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಎಲ್ಲಿ ಹುಡುಕಬೇಕೆಂದು ನಾವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಳಬೇಕು. ನಾವು ಇದನ್ನು tsconfig.json ನಲ್ಲಿ ಮಾಡುತ್ತೇವೆ:
{
"compilerOptions": {
// ... ಇತರ ಆಯ್ಕೆಗಳು
"baseUrl": ".",
"paths": {
"*": ["types/*"]
}
}
}
ಈ ಸೆಟಪ್‌ನೊಂದಿಗೆ, ನೀವು import { capitalize } from 'string-utils' ಮಾಡಿದಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ನಿಮ್ಮ ಕಸ್ಟಮ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಹುಡುಕುತ್ತದೆ ಮತ್ತು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಟೈಪ್ ಸುರಕ್ಷತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಲೈಬ್ರರಿಯ ಹೆಚ್ಚಿನ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿದಂತೆ ಈ ಫೈಲ್ ಅನ್ನು ಕ್ರಮೇಣವಾಗಿ ನಿರ್ಮಿಸಬಹುದು.
ಆಳವಾಗಿ ತಿಳಿಯೋಣ: ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುವುದು
ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಬರೆಯುವಾಗ ಅಥವಾ ಓದುವಾಗ ನೀವು ಎದುರಿಸುವ ಕೆಲವು ಮುಂದುವರಿದ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.
ವಿವಿಧ ರೀತಿಯ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಳನ್ನು ಘೋಷಿಸುವುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳು ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ವಸ್ತುಗಳನ್ನು ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡಬಹುದು. ನಿಮ್ಮ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಲೈಬ್ರರಿಯ ಎಕ್ಸ್‌ಪೋರ್ಟ್ ರಚನೆಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು.
- ನೇಮ್ಡ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಳು: ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾಗಿದೆ. ನಾವು ಇದನ್ನು ಮೇಲೆ `export function capitalize(...)` ಜೊತೆ ನೋಡಿದ್ದೇವೆ. ನೀವು ಕಾನ್ಸ್ಟಂಟ್‌ಗಳು, ಇಂಟರ್ಫೇಸ್‌ಗಳು ಮತ್ತು ಕ್ಲಾಸ್‌ಗಳನ್ನು ಸಹ ಎಕ್ಸ್‌ಪೋರ್ಟ್ ಮಾಡಬಹುದು.
- ಡೀಫಾಲ್ಟ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್: `export default` ಬಳಸುವ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ.
- UMD ಗ್ಲೋಬಲ್‌ಗಳು:
<script>ಟ್ಯಾಗ್ ಮೂಲಕ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಹಳೆಯ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ, ಅವುಗಳು ಸಾಮಾನ್ಯವಾಗಿ ತಮ್ಮನ್ನು ಗ್ಲೋಬಲ್ `window` ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಲಗತ್ತಿಸುತ್ತವೆ. ನೀವು ಈ ಗ್ಲೋಬಲ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಘೋಷಿಸಬಹುದು. - `export =` ಮತ್ತು `import = require()`: ಈ ಸಿಂಟ್ಯಾಕ್ಸ್ `module.exports = ...` ಬಳಸುವ ಹಳೆಯ CommonJS ಮಾಡ್ಯೂಲ್‌ಗಳಿಗಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದು ಲೈಬ್ರರಿ `module.exports = myClass;` ಮಾಡಿದರೆ.
declare module 'my-lib' {
export const version: string;
export interface Options { retries: number; }
export function doSomething(options: Options): Promise
declare module 'my-default-lib' {
// ಒಂದು ಫಂಕ್ಷನ್ ಡೀಫಾಲ್ಟ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಾಗಿ
export default function myCoolFunction(): void;
// ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಡೀಫಾಲ್ಟ್ ಎಕ್ಸ್‌ಪೋರ್ಟ್‌ಗಾಗಿ
// const myLib = { name: 'lib', version: '1.0' };
// export default myLib;
}
// ಒಂದು ನಿರ್ದಿಷ್ಟ ಟೈಪ್‌ನ '$' ಗ್ಲೋಬಲ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ
declare var $: JQueryStatic;
// my-class.d.ts ನಲ್ಲಿ
declare class MyClass { constructor(name: string); }
export = MyClass;
// ನಿಮ್ಮ app.ts ನಲ್ಲಿ
import MyClass = require('my-class');
const instance = new MyClass('test');
ಆಧುನಿಕ ES ಮಾಡ್ಯೂಲ್‌ಗಳೊಂದಿಗೆ ಇದು ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದ್ದರೂ, ಅನೇಕ ಹಳೆಯ ಆದರೆ ಇನ್ನೂ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುವ Node.js ಪ್ಯಾಕೇಜ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಗಾಗಿ ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
ಮಾಡ್ಯೂಲ್ ಆಗ್ಮೆಂಟೇಶನ್: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೈಪ್‌ಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು
ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಒಂದೆಂದರೆ ಮಾಡ್ಯೂಲ್ ಆಗ್ಮೆಂಟೇಶನ್ (ಡಿಕ್ಲರೇಶನ್ ಮರ್ಜಿಂಗ್ ಎಂದೂ ಕರೆಯುತ್ತಾರೆ). ಇದು ಮತ್ತೊಂದು ಪ್ಯಾಕೇಜ್‌ನ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಇಂಟರ್ಫೇಸ್‌ಗಳಿಗೆ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು Express ಅಥವಾ Fastify ನಂತಹ ಪ್ಲಗಿನ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಹೊಂದಿರುವ ಲೈಬ್ರರಿಗಳಿಗೆ ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ.
ನೀವು Express ನಲ್ಲಿ ಒಂದು ಮಿಡಲ್‌ವೇರ್ ಬಳಸುತ್ತಿರುವಿರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ, ಅದು `Request` ಆಬ್ಜೆಕ್ಟ್‌ಗೆ `user` ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸುತ್ತದೆ. ಆಗ್ಮೆಂಟೇಶನ್ ಇಲ್ಲದಿದ್ದರೆ, `Request` ಮೇಲೆ `user` ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ದೂರು ನೀಡುತ್ತದೆ.
ಈ ಹೊಸ ಪ್ರಾಪರ್ಟಿಯ ಬಗ್ಗೆ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಗೆ ಹೇಳಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:
// ನಿಮ್ಮ types/express.d.ts ಫೈಲ್‌ನಲ್ಲಿ
// ಅದನ್ನು ಆಗ್ಮೆಂಟ್ ಮಾಡಲು ನಾವು ಮೂಲ ಟೈಪ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಬೇಕು
import { UserProfile } from './auth'; // ನಿಮ್ಮ ಬಳಿ UserProfile ಟೈಪ್ ಇದೆ ಎಂದು ಭಾವಿಸಿ
// ನಾವು 'express-serve-static-core' ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಗ್ಮೆಂಟ್ ಮಾಡುತ್ತಿದ್ದೇವೆ ಎಂದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಳಿ
declare module 'express-serve-static-core' {
// ಆ ಮಾಡ್ಯೂಲ್‌ನೊಳಗಿನ 'Request' ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಗುರಿಯಾಗಿಸಿ
interface Request {
// ನಮ್ಮ ಕಸ್ಟಮ್ ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸೇರಿಸಿ
user?: UserProfile;
}
}
ಈಗ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ, Express `Request` ಆಬ್ಜೆಕ್ಟ್ ಐಚ್ಛಿಕ `user` ಪ್ರಾಪರ್ಟಿಯೊಂದಿಗೆ ಸರಿಯಾಗಿ ಟೈಪ್ ಆಗಿರುತ್ತದೆ, ಮತ್ತು ನೀವು ಪೂರ್ಣ ಟೈಪ್ ಸುರಕ್ಷತೆ ಮತ್ತು ಸ್ವಯಂಪೂರ್ಣತೆಯನ್ನು ಪಡೆಯುತ್ತೀರಿ.
ಟ್ರಿಪಲ್-ಸ್ಲ್ಯಾಶ್ ಡೈರೆಕ್ಟಿವ್ಸ್
ಕೆಲವೊಮ್ಮೆ ನೀವು .d.ts ಫೈಲ್‌ಗಳ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಮೂರು ಸ್ಲ್ಯಾಶ್‌ಗಳಿಂದ (///) ಪ್ರಾರಂಭವಾಗುವ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ನೋಡಬಹುದು. ಇವು ಟ್ರಿಪಲ್-ಸ್ಲ್ಯಾಶ್ ಡೈರೆಕ್ಟಿವ್ಸ್, ಇವು ಕಂಪೈಲರ್ ಸೂಚನೆಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.
/// <reference types="..." />: ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾಗಿದೆ. ಇದು ಮತ್ತೊಂದು ಪ್ಯಾಕೇಜ್‌ನ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಡಿಪೆಂಡೆನ್ಸಿಯಾಗಿ ಸೇರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, WebdriverIO ಪ್ಲಗಿನ್‌ಗಾಗಿ ಟೈಪ್‌ಗಳು/// <reference types="webdriverio" />ಅನ್ನು ಒಳಗೊಂಡಿರಬಹುದು ಏಕೆಂದರೆ ಅದರ ಸ್ವಂತ ಟೈಪ್‌ಗಳು ಕೋರ್ WebdriverIO ಟೈಪ್‌ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿವೆ./// <reference path="..." />: ಇದನ್ನು ಅದೇ ಪ್ರಾಜೆಕ್ಟ್‌ನೊಳಗಿನ ಮತ್ತೊಂದು ಫೈಲ್‌ನ ಮೇಲೆ ಡಿಪೆಂಡೆನ್ಸಿಯನ್ನು ಘೋಷಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಹಳೆಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ಆಗಿದ್ದು, ಹೆಚ್ಚಾಗಿ ES ಮಾಡ್ಯೂಲ್ ಇಂಪೋರ್ಟ್‌ಗಳಿಂದ ಬದಲಾಯಿಸಲ್ಪಟ್ಟಿದೆ.
ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
- ಬಂಡಲ್ ಮಾಡಿದ ಟೈಪ್‌ಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಿ: ಲೈಬ್ರರಿಗಳ ನಡುವೆ ಆಯ್ಕೆ ಮಾಡುವಾಗ, ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬರೆಯಲಾದ ಅಥವಾ ತಮ್ಮದೇ ಆದ ಅಧಿಕೃತ ಟೈಪ್ ಡೆಫಿನಿಷನ್‌ಗಳನ್ನು ಬಂಡಲ್ ಮಾಡುವ ಲೈಬ್ರರಿಗಳಿಗೆ ಆದ್ಯತೆ ನೀಡಿ. ಇದು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗೆ ಬದ್ಧತೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.
@typesಅನ್ನುdevDependenciesನಲ್ಲಿ ಇರಿಸಿ: ಯಾವಾಗಲೂ@typesಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು--save-devಅಥವಾ-Dನೊಂದಿಗೆ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ. ಅವು ನಿಮ್ಮ ಪ್ರೊಡಕ್ಷನ್ ಕೋಡ್‌ಗೆ ಅಗತ್ಯವಿಲ್ಲ.- ಆವೃತ್ತಿಗಳನ್ನು ಹೊಂದಿಸಿ: ಲೈಬ್ರರಿ ಆವೃತ್ತಿ ಮತ್ತು ಅದರ
@typesಆವೃತ್ತಿಯ ನಡುವಿನ ಹೊಂದಾಣಿಕೆಯಿಲ್ಲದಿರುವುದು ದೋಷಗಳ ಸಾಮಾನ್ಯ ಮೂಲವಾಗಿದೆ. ಒಂದು ಲೈಬ್ರರಿಯಲ್ಲಿ ಪ್ರಮುಖ ಆವೃತ್ತಿಯ ಬದಲಾವಣೆ (ಉದಾಹರಣೆಗೆ, v2 ರಿಂದ v3) ಅದರ API ನಲ್ಲಿ ಬ್ರೇಕಿಂಗ್ ಬದಲಾವಣೆಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಅದು@typesಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ ಪ್ರತಿಫಲಿಸಬೇಕು. ಅವುಗಳನ್ನು ಸಿಂಕ್‌ನಲ್ಲಿಡಲು ಪ್ರಯತ್ನಿಸಿ. - ನಿಯಂತ್ರಣಕ್ಕಾಗಿ
tsconfig.jsonಬಳಸಿ: ನಿಮ್ಮtsconfig.jsonನಲ್ಲಿನtypeRootsಮತ್ತುtypesಕಂಪೈಲರ್ ಆಯ್ಕೆಗಳು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಎಲ್ಲಿ ಹುಡುಕಬೇಕು ಎಂಬುದರ ಮೇಲೆ ಸೂಕ್ಷ್ಮ-ನಿಯಂತ್ರಿತ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ.typeRootsಕಂಪೈಲರ್‌ಗೆ ಯಾವ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕೆಂದು ಹೇಳುತ್ತದೆ (ಡೀಫಾಲ್ಟ್ ಆಗಿ, ಇದು./node_modules/@types), ಮತ್ತುtypesಯಾವ ಟೈಪ್ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸೇರಿಸಬೇಕೆಂದು ಸ್ಪಷ್ಟವಾಗಿ ಪಟ್ಟಿ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. - ಕೊಡುಗೆ ನೀಡಿ: ನೀವು ಒಂದು ಲೈಬ್ರರಿಗಾಗಿ ಸಮಗ್ರ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್ ಬರೆದರೆ, ಅದಕ್ಕೆ ಈಗಾಗಲೇ ಒಂದಿಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ಡೆಫಿನಿಟ್ಲಿಟೈಪ್ಡ್ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಕೊಡುಗೆ ನೀಡಲು ಪರಿಗಣಿಸಿ. ಇದು ಜಾಗತಿಕ ಡೆವಲಪರ್ ಸಮುದಾಯಕ್ಕೆ ಮರಳಿ ನೀಡಲು ಮತ್ತು ಸಾವಿರಾರು ಇತರರಿಗೆ ಸಹಾಯ ಮಾಡಲು ಒಂದು ಅದ್ಭುತ ಮಾರ್ಗವಾಗಿದೆ.
ತೀರ್ಮಾನ: ಟೈಪ್ ಸುರಕ್ಷತೆಯ ತೆರೆಮರೆಯ ನಾಯಕರು
ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಫೈಲ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಡೈನಾಮಿಕ್, ವಿಸ್ತಾರವಾದ ಜಗತ್ತನ್ನು ಒಂದು ದೃಢವಾದ, ಟೈಪ್-ಸುರಕ್ಷಿತ ಅಭಿವೃದ್ಧಿ ಪರಿಸರಕ್ಕೆ ಮನಬಂದಂತೆ ಸಂಯೋಜಿಸಲು ಸಾಧ್ಯವಾಗಿಸುವ ತೆರೆಮರೆಯ ನಾಯಕರು. ಅವು ನಮ್ಮ ಉಪಕರಣಗಳನ್ನು ಸಶಕ್ತಗೊಳಿಸುವ, ಅಸಂಖ್ಯಾತ ದೋಷಗಳನ್ನು ತಡೆಯುವ, ಮತ್ತು ನಮ್ಮ ಕೋಡ್‌ಬೇಸ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಸ್ಥಿತಿಸ್ಥಾಪಕ ಮತ್ತು ಸ್ವಯಂ-ದಾಖಲಿಸುವಂತೆ ಮಾಡುವ ನಿರ್ಣಾಯಕ ಕೊಂಡಿಗಳಾಗಿವೆ.
ನಿಮ್ಮದೇ ಆದ .d.ts ಫೈಲ್‌ಗಳನ್ನು ಹೇಗೆ ಹುಡುಕುವುದು, ಬಳಸುವುದು ಮತ್ತು ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಕೇವಲ ಕಂಪೈಲರ್ ದೋಷವನ್ನು ಸರಿಪಡಿಸುತ್ತಿಲ್ಲ—ನೀವು ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಅಭಿವೃದ್ಧಿ ಕಾರ್ಯಪ್ರವಾಹವನ್ನು ಉನ್ನತೀಕರಿಸುತ್ತಿದ್ದೀರಿ. ನೀವು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಲೈಬ್ರರಿಗಳ ಶ್ರೀಮಂತ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗಳ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್‌ಲಾಕ್ ಮಾಡುತ್ತಿದ್ದೀರಿ, ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಉತ್ತಮ, ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ರಚಿಸುವ ಪ್ರಬಲ ಸಮನ್ವಯವನ್ನು ಸೃಷ್ಟಿಸುತ್ತಿದ್ದೀರಿ.