JavaScript
लूप्स

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

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

टिप्पणियों

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

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 लॉग नहीं करता है और लूप किया जाता है

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

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

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

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

const uniqueNames = new Set(names);

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

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
*/

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