खोज…


वाक्य - विन्यास

  • ( आरंभीकरण के लिए ; स्थिति ; अंतिम_अवसाद ) {}
  • के लिए ( वस्तु में कुंजी ) {}
  • के लिए ( चलने के चर ) {}
  • जबकि ( स्थिति ) {}
  • {} करें जबकि ( स्थिति )
  • XML के लिए प्रत्येक ( ऑब्जेक्ट में चर ) {} // ECMAScript

टिप्पणियों

जावास्क्रिप्ट में लूप आमतौर पर उन समस्याओं को हल करने में मदद करते हैं जिनमें विशिष्ट कोड x राशि को बार-बार दोहराना शामिल है। मान लें कि आपको 5 बार संदेश दर्ज करने की आवश्यकता है। आप ऐसा कर सकते हैं:

console.log("a message");
console.log("a message");
console.log("a message");
console.log("a message");
console.log("a message");

लेकिन यह सिर्फ समय लेने वाली और हास्यास्पद की तरह है। इसके अलावा, क्या होगा अगर आपको 300 से अधिक संदेशों को लॉग इन करने की आवश्यकता है? आपको एक पारंपरिक "लूप" के लिए कोड को बदलना चाहिए:

for(var i = 0; i < 5; i++){
    console.log("a message");
}

मानक "छोरों" के लिए

मानक उपयोग

for (var i = 0; i < 100; i++) {
    console.log(i);
}

अपेक्षित उत्पादन:

0
1
...
99

एकाधिक घोषणाएँ

आमतौर पर एक सरणी की लंबाई को कैश करने के लिए उपयोग किया जाता है।

var array = ['a', 'b', 'c'];
for (var i = 0; i < array.length; i++) {
    console.log(array[i]);
}

अपेक्षित उत्पादन:

'ए'
'बी'
'सी'

वेतन वृद्धि

for (var i = 0; i < 100; i += 2 /* Can also be: i = i + 2 */) {
    console.log(i);
}

अपेक्षित उत्पादन:

0
2
4
...
98

घटा हुआ लूप

for (var i = 100; i >=0; i--) {
    console.log(i);
}

अपेक्षित उत्पादन:

100
99
98
...
0

"जबकि" लूप्स

मानक जबकि लूप

एक मानक जबकि लूप निष्पादित करेगा जब तक कि दी गई स्थिति झूठी न हो:

var i = 0;
while (i < 100) {
    console.log(i);
    i++;
}

अपेक्षित उत्पादन:

0
1
...
99

घटा हुआ लूप

var i = 100;
while (i > 0) {
    console.log(i);
    i--; /* equivalent to i=i-1 */
}

अपेक्षित उत्पादन:

100
99
98
...
1

करो ... जबकि लूप

एक करो ... जबकि लूप हमेशा कम से कम एक बार निष्पादित होगा, भले ही यह शर्त सही हो या गलत हो:

var i = 101;
do {
    console.log(i);
} while (i < 100);

अपेक्षित उत्पादन:

101

एक लूप से "ब्रेक"

थोड़ी देर लूप से बाहर निकलना

var i = 0;
while(true) {
    i++;
    if(i === 42) {
        break;
    }
}
console.log(i);

अपेक्षित उत्पादन:

42

एक पाश के लिए बाहर तोड़कर

var i;
for(i = 0; i < 100; i++) {
    if(i === 42) {
        break;
    }
}
console.log(i);

अपेक्षित उत्पादन:

42

"जारी रखें" एक लूप

"लूप" के लिए जारी रखना

जब आप continue कीवर्ड को लूप में रखते हैं, तो निष्पादन अपडेट अभिव्यक्ति (उदाहरण में i++ ) पर कूद जाता है:

for (var i = 0; i < 3; i++) {
    if (i === 1) {
        continue;
    }
    console.log(i);
}

अपेक्षित उत्पादन:

0
2

थोड़ी देर के लिए जारी है

जब आप थोड़ी देर लूप में continue , तो निष्पादन स्थिति के लिए कूदता है (उदाहरण में i < 3 ):

var i = 0;
while (i < 3) {
    if (i === 1) {
        i = 2;
        continue;
    }
    console.log(i);
    i++;
}

अपेक्षित उत्पादन:

0
2

"करते हैं ... जबकि" पाश

var availableName;
do {
    availableName = getRandomName();
} while (isNameUsed(name));

एक do while पाश में कम से कम एक बार के रूप में यह की हालत केवल एक यात्रा के अंत में चेक किया गया है चलाने के लिए गारंटी है। एक पारंपरिक while लूप शून्य या अधिक बार चल सकता है क्योंकि इसकी स्थिति पुनरावृत्ति की शुरुआत में जाँच की जाती है।

विशिष्ट नेस्टेड छोरों को तोड़ें

हम अपने छोरों को नाम दे सकते हैं और आवश्यक होने पर विशिष्ट को तोड़ सकते हैं।

outerloop:
for (var i = 0;i<3;i++){
    innerloup:
    for (var j = 0;j <3; j++){
        console.log(i);
        console.log(j);
        if (j == 1){
            break outerloop;    
        }
    }
}

आउटपुट:

0
0
0
1

लेबल तोड़ें और जारी रखें

एक वैकल्पिक लेबल द्वारा विराम और जारी बयान का अनुसरण किया जा सकता है जो किसी प्रकार के गोटो कथन की तरह काम करता है, लेबल संदर्भित स्थिति से निष्पादन फिर से शुरू करता है

for(var i = 0; i < 5; i++){
  nextLoop2Iteration:
  for(var j = 0; j < 5; j++){
    if(i == j) break nextLoop2Iteration;
    console.log(i, j);
  }
}

i = 0 j = 0 स्किप वैल्यू ऑफ जे वैल्यू
१ ०
i = 1 j = 1 j मानों के बाकी को छोड़ देता है
२ ०
2 1 i = 2 j = 2 स्किप बाकी j मान
३ ०
३ १
३ २
i = 3 j = 3 स्किप बाकी j मान
४ ०
४ १
४ २
४ ३
i = 4 j = 4 लॉग नहीं करता है और लूप किया जाता है

"के लिए ..." पाश

6
const iterable = [0, 1, 2];
for (let i of iterable) {
    console.log(i);
}

अपेक्षित उत्पादन:

0
1
2

पाश के लिए ... से लाभ हैं:

  • यह सरणी तत्वों के माध्यम से लूपिंग के लिए सबसे संक्षिप्त, प्रत्यक्ष वाक्यविन्यास है
  • यह ... के सभी नुकसान से बचा जाता है ... में
  • forEach() विपरीत, यह ब्रेक, जारी और वापसी के साथ काम करता है

अन्य संग्रह में ... के लिए समर्थन

स्ट्रिंग्स

के लिए ... यूनिकोड वर्णों के अनुक्रम के रूप में एक स्ट्रिंग का इलाज करेगा:

const string = "abc";
for (let chr of string) {
  console.log(chr);
}

अपेक्षित उत्पादन:

a b c

सेट

सेट ऑब्जेक्ट्स पर काम करता है ... के लिए।

नोट :

const names = ['bob', 'alejandro', 'zandra', 'anna', 'bob'];

const uniqueNames = new Set(names);

for (let name of uniqueNames) {
  console.log(name);
}

अपेक्षित उत्पादन:

बॉब
Alejandro
Zandra
अन्ना

मैप्स

आप मानचित्रों पर पुनरावृति करने के लिए लूप्स के लिए भी ... का उपयोग कर सकते हैं। यह एरियर्स और सेट्स के समान कार्य करता है, सिवाय इसके कि इरिगेशन वैरिएबल कुंजी और मान दोनों को स्टोर करता है।

const map = new Map()
  .set('abc', 1)
  .set('def', 2)

for (const iteration of map) {
  console.log(iteration) //will log ['abc', 1] and then ['def', 2]
}

आप कुंजी और मूल्य को अलग-अलग पकड़ने के लिए विनाशकारी असाइनमेंट का उपयोग कर सकते हैं:

const map = new Map()
  .set('abc', 1)
  .set('def', 2)

for (const [key, value] of map) {
  console.log(key + ' is mapped to ' + value)
}
/*Logs:
  abc is mapped to 1
  def is mapped to 2
*/

वस्तुओं

के लिए ... लूप सीधे सादे वस्तुओं पर काम नहीं करते हैं; लेकिन, किसी वस्तु के गुणों पर स्विच करने के लिए संभव है ... पाश, या Object.keys() का उपयोग करके:

const someObject = { name: 'Mike' };

for (let key of Object.keys(someObject)) {
  console.log(key + ": " + someObject[key]);
}

अपेक्षित उत्पादन:

नाम: माइक

"फॉर ... इन" लूप

चेतावनी
के लिए ... ऑब्जेक्ट कुंजियों पर पुनरावृत्ति के लिए अभिप्रेत है, सरणी अनुक्रमित नहीं। सरणी के माध्यम से लूप का उपयोग करना आमतौर पर हतोत्साहित करता है । इसमें प्रोटोटाइप से गुण भी शामिल हैं, इसलिए यह जांचने के लिए आवश्यक हो सकता है कि क्या hasOwnProperty का उपयोग करके ऑब्जेक्ट के भीतर है। यदि ऑब्जेक्ट में कोई भी विशेषताएँ defineProperty/defineProperties मेथड द्वारा परिभाषित की गई हैं और परम को defineProperty/defineProperties किया गया है enumerable: false , तो वे defineProperty/defineProperties दुर्गम होंगे।

var object = {"a":"foo", "b":"bar", "c":"baz"};
// `a` is inaccessible
Object.defineProperty(object , 'a', {
        enumerable: false,
});
for (var key in object) {
    if (object.hasOwnProperty(key)) {
      console.log('object.' + key + ', ' + object[key]);
    }
}

अपेक्षित उत्पादन:

ऑब्जेक्ट। बी, बार
object.c, baz



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow