TypeScript में for लूप के लिए सर्वोत्तम प्रथाएं

यह लेख TypeScript में for लूप के उपयोग के लिए सर्वोत्तम प्रथाओं को समझाता है।

YouTube Video

TypeScript में for लूप के लिए सर्वोत्तम प्रथाएं

for कथन दोहराव ऑपरेशनों को करने के लिए एक मौलिक और शक्तिशाली सिंटैक्स है। TypeScript में, प्रकार की सुरक्षा का लाभ उठाना और पठनीयता और अनुरक्षणशीलता को ध्यान में रखकर कोड लिखना आपको कम त्रुटियों के साथ कुशल कोड लिखने की अनुमति देता है।

सही लूप प्रकार का चयन करना

TypeScript कई प्रकार के लूप संरचनाएँ प्रदान करता है, और प्रत्येक विशिष्ट उपयोग मामलों के लिए उपयुक्त होता है। कोड की स्पष्टता और प्रदर्शन के लिए उपयुक्त लूप चुनना महत्वपूर्ण है।

मानक for लूप

1for (let i = 0; i < 10; i++) {
2    console.log(i);
3}

मानक for लूप तब आदर्श है जब आपको पुनरावृत्ति सूचकांक पर सटीक नियंत्रण की आवश्यकता हो।

सर्वोत्तम प्रथाएं

1const maxIterations = 10;
2for (let i = 0; i < maxIterations; i++) {
3    console.log(i);
4}

for कथन लिखते समय निम्न बिंदुओं को ध्यान में रखना आपको अधिक सुरक्षित और पठनीय कोड लिखने में मदद कर सकता है।

• इंडेक्स वेरिएबल्स के लिए let का उपयोग करें
  • var के बजाय let का उपयोग करने से स्कोप ब्लॉक तक सीमित हो जाता है, जो अनपेक्षित व्यवहार को रोकता है।
• लूप की सीमाओं को स्पष्ट करने के लिए स्थिरांक और वर्णनात्मक चरों के नामों का उपयोग करें।
  • जादुई संख्याओं से बचना और अर्थपूर्ण चर नामों का उपयोग करना पठनीयता में सुधार करता है।

for...of लूप

1const array = [1, 2, 3];
2for (let value of array) {
3    console.log(value);
4}

for...of लूप उन वस्तुओं (जैसे एरे और स्ट्रिंग) पर पुनरावृत्ति के लिए उपयुक्त है जिन्हें आइटेर्बल किया जा सकता है।

सर्वोत्तम प्रथाएं

1const array = [1, 2, 3];
2for (const value of array) {
3    console.log(value);
4}

for...of लूप लिखते समय निम्नलिखित बिंदुओं पर ध्यान देना आपको अधिक सुरक्षित कोड लिखने में मदद कर सकता है।

• लूप वेरिएबल्स के लिए const का उपयोग करें
  • यदि लूप के भीतर मान संशोधित नहीं किए जाते हैं, तो const का उपयोग आकस्मिक पुनः असाइनमेंट को रोकने में मदद करता है।

for...in लूप

1const obj = { a: 1, b: 2, c: 3 };
2for (const key in obj) {
3    console.log(`${key}: ${obj[key]}`);
4}

for...in लूप किसी वस्तु की गिनने योग्य प्रॉपर्टीज़ पर पुनरावृत्ति करता है।

सर्वोत्तम प्रथाएं

1const obj = { a: 1, b: 2, c: 3 };
2for (const key in obj) {
3    if (obj.hasOwnProperty(key)) {
4        console.log(`${key}: ${obj[key]}`);
5    }
6}

for...in लूप लिखते समय, आप निम्नलिखित बिंदुओं पर विचार कर सकते हैं।

• प्रॉपर्टीज़ को फ़िल्टर करें
  • यदि आपको विरासत में मिली प्रॉपर्टियों से बचने की आवश्यकता हो, तो आप hasOwnProperty का उपयोग कर सकते हैं।
• श्रृंखलाओं (arrays) के साथ for...in का उपयोग न करें। ऐरे के साथ for...in का उपयोग करने से बचें। यह सभी सूचीबद्ध प्रॉपर्टीज़ पर इटरेट कर सकता है, जिनमें वे भी शामिल हैं जो ऐरे इंडेक्स नहीं हैं।

forEach विधि

1const array = [1, 2, 3];
2array.forEach((value, index) => {
3    console.log(`Index: ${index}, Value: ${value}`);
4});

एरे पर पुनरावृत्ति करते समय, forEach संक्षिप्त है और इंडेक्स को प्रबंधित करने की आवश्यकता को समाप्त करता है।

सर्वोत्तम प्रथाएं

forEach विधि का उपयोग करते समय, आप निम्नलिखित बिंदुओं पर विचार कर सकते हैं।

• एरो फंक्शन्स का उपयोग करें
  • रीडेबिलिटी बढ़ाने के लिए संक्षिप्त एरो फंक्शन्स का उपयोग करें।
• बाधाओं से बचें
  • forEach break या continue का समर्थन नहीं करता है। for...of या for लूप्स का उपयोग आवश्यकतानुसार करें:।

टाइप सुरक्षा और त्रुटि रोकथाम

TypeScript के टाइप सिस्टम का लाभ उठाकर, आप इटरेशन के दौरान रनटाइम त्रुटियों को रोक सकते हैं:।

लूप वैरिएबल्स के लिए सख्त प्रकार परिभाषित करें

1const items = [1, 2, 3];
2items.forEach(item => {
3    console.log(item * 2);
4});

1const items: number[] = [1, 2, 3];
2items.forEach((item: number) => {
3    console.log(item * 2);
4});

लूप चरों के लिए प्रकार स्पष्ट रूप से निर्दिष्ट करके, आप प्रकार असंगतताओं का शीघ्र पता लगा सकते हैं।

अनकहे any से बचें

1{
2  "compilerOptions": {
3    "noImplicitAny": true
4  }
5}

tsconfig.json में noImplicitAny को सक्षम करने से आप उन वेरिएबल्स को अवांछित रूप से any प्रकार आबंटित होने से रोक सकते हैं जिनके स्पष्ट प्रकार निर्दिष्ट नहीं किए गए हैं।

आवश्यक होने पर ReadonlyArray का उपयोग करें

1const numbers: ReadonlyArray<number> = [1, 2, 3];
2for (const value of numbers) {
3    console.log(value);
4}

यदि आप एक ऐसे ऐरे पर पुनरावृति कर रहे हैं जिसे संशोधित नहीं किया जाना चाहिए, तो आप ReadonlyArray का उपयोग कर सकते हैं।

प्रदर्शन पर विचार

बड़े डेटासेट या बार-बार निष्पादित होने वाले लूप्स के लिए दक्षता महत्वपूर्ण है:।

इष्टतम लूप कार्यान्वयन विधि चुनें।

लूप्स को लागू करने के विभिन्न तरीके हैं, जिनमें पठनीयता और निष्पादन क्षमता के मामले में भिन्नताएं होती हैं।

 1// Prepare input data (an array from 1 to 1000000)
 2const input: number[] = Array.from({ length: 1000000 }, (_, i) => i + 1);
 3
 4// --- for ---
 5console.time('for loop');
 6const squaresFor: number[] = [];
 7for (let i = 0; i < input.length; i++) {
 8    squaresFor.push(input[i] * input[i]);
 9}
10console.timeEnd('for loop');
11
12// --- while ---
13console.time('while loop');
14const squaresWhile: number[] = [];
15let i: number = 0;
16while (i < input.length) {
17    squaresWhile.push(input[i] * input[i]);
18    i++;
19}
20console.timeEnd('while loop');
21
22// --- for-of ---
23console.time('for-of loop');
24const squaresForOf: number[] = [];
25for (const num of input) {
26    squaresForOf.push(num * num);
27}
28console.timeEnd('for-of loop');
29
30// --- forEach ---
31console.time('forEach loop');
32const squaresForEach: number[] = [];
33input.forEach((num: number): void => {
34    squaresForEach.push(num * num);
35});
36console.timeEnd('forEach loop');
37
38// --- map ---
39console.time('map');
40const squaresMap: number[] = input.map((value: number): number => value * value);
41console.timeEnd('map');

कार्य निष्पादन वातावरण के आधार पर दक्षता भिन्न होती है, लेकिन उदाहरण के लिए, एक लूप को एक मिलियन बार चलाते समय, अंतर स्पष्ट रूप से ध्यान देने योग्य हो सकता है। रखरखाव और प्रदर्शन को ध्यान में रखते हुए सबसे उपयुक्त लूप विधि चुनें।

मूल इटरेशन विधियों का उपयोग करें

 1const squares = [1, 2, 3].map(value => value * value);
 2console.log(squares);
 3
 4const numbers = [1, 2, 3, 4, 5, 6];
 5const evenNumbers = numbers.filter(value => value % 2 === 0);
 6console.log(evenNumbers); // [2, 4, 6]
 7
 8const squaredEvens = numbers
 9    .filter(value => value % 2 === 0) // Keep only even numbers
10    .map(value => value * value);     // Square the remaining values
11
12console.log(squaredEvens); // [4, 16, 36]

map और filter जैसी विधियाँ कुछ मामलों में अधिक पठनीय हो सकती हैं।

पठनीयता के लिए for...of को प्राथमिकता दें

प्रदर्शन को केवल सीमित मामलों में प्राथमिकता दी जानी चाहिए; आमतौर पर पठनीय कोड लिखना अधिक महत्वपूर्ण होता है। उदाहरण के लिए, for...of को प्राथमिकता देना पठनीयता में सुधार कर सकता है।

1const fruits = ["apple", "banana", "cherry"];
2
3for (let i = 0; i < fruits.length; i++) {
4    console.log(`${i}: ${fruits[i]}`);
5}

सर्वोत्तम प्रथाएं

1const fruits = ["apple", "banana", "cherry"];
2
3for (const [index, fruit] of fruits.entries()) {
4    console.log(`${index}: ${fruit}`);
5}

for...of लूप को प्राथमिकता देकर, आप अधिक पठनीय और त्रुटि-प्रतिरोधी कोड लिख सकते हैं। जैसा कि इस उदाहरण में दिखाया गया है, यदि आपको श्रृंखला (array) सूचकांक की भी आवश्यकता है, तो entries() को for...of के साथ संयोजित करना प्रभावी है।

आम गलतियों से बचाव

इटरेशन के दौरान संग्रह को संशोधित करना

1const array = [1, 2, 3];
2for (const value of [...array]) {
3    if (value === 2) {
4        array.push(4); // Avoid this!
5    }
6}
7console.log(array);

इटरेशन के दौरान एक ऐरे को संशोधित करना अप्रत्याशित व्यवहार का कारण बन सकता है:। आवश्यक होने पर एक प्रति का उपयोग करें।

किनारे के मामलों पर विचार करें

1const array: number[] = [];
2for (const value of array) {
3    console.log(value); // No output, but no errors
4}

यह कोड ठीक काम करता है, लेकिन यदि आपको खाली ऐरे को संभालने की ज़रूरत है, तो आप इसे इस प्रकार सुधार सकते हैं।

1const array: number[] = [];
2if (array.length === 0) {
3    console.log("The array is empty.");
4} else {
5    for (const value of array) {
6        console.log(value);
7    }
8}

किनारे के मामलों पर विचार करना बाद के कोड में त्रुटियों को रोकने में मदद कर सकता है।

निष्कर्ष

for स्टेटमेंट को TypeScript में निपुण बनाने के लिए विभिन्न लूप संरचनाओं को समझना, टाइप-सुरक्षित प्रथाओं का पालन करना और प्रदर्शन को अनुकूलित करना महत्वपूर्ण है। ये सर्वोत्तम प्रथाएँ आपको साफ, अधिक विश्वसनीय, और अधिक रखरखाव योग्य कोड लिखने में मदद करती हैं।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video