सवाल जावास्क्रिप्ट में एक सरणी के माध्यम से लूप


जावा में आप एक का उपयोग कर सकते हैं for निम्नानुसार एक सरणी में वस्तुओं को पार करने के लिए लूप:

String[] myStringArray = {"Hello", "World"};
for (String s : myStringArray)
{
    // Do something
}

क्या आप जावास्क्रिप्ट में ऐसा ही कर सकते हैं?


2421
2018-06-10 00:04


मूल


ठीक है, तो मैं थोड़ा उलझन में हूं, जब आप वस्तुओं तक पहुंच रहे हों तो लूप के लिए बढ़ाया जाना ठीक है? और एक भरने के लिए एक अनुक्रमिक का उपयोग करें? क्या ये सही है? - Mark Szymanski
नहीं, यह वास्तव में सरल है, सरणी वस्तुओं में संख्यात्मक अनुक्रमणिका होती है, इसलिए आप चाहते हैं पुनरावृति संख्यात्मक क्रम में उन इंडेक्स पर, अनुक्रमिक पाश सुनिश्चित करता है कि, बढ़ाया  for-in पाश विश्लेषण करता है ऑब्जेक्ट गुण, एक विशिष्ट क्रम के बिना, और यह विरासत गुणों को भी समझाता है ... के लिए बार-बार दोहराना सरणी अनुक्रमिक loops पर हमेशा अनुशंसा की जाती है ... - CMS
सम्बंधित - stackoverflow.com/questions/5349425/... - jondavidjohn
सम्बंधित - stackoverflow.com/q/6208964/31671 - alex
jsben.ch/#/Q9oD5 <= यहां सरणी के माध्यम से लूपिंग के लिए समाधान के समूह का एक बेंचमार्क - EscapeNetscape


जवाब:


अनुक्रमिक का प्रयोग करें for पाश:

var myStringArray = ["Hello","World"];
var arrayLength = myStringArray.length;
for (var i = 0; i < arrayLength; i++) {
    alert(myStringArray[i]);
    //Do something
}

@zipcodeman का उपयोग करने का सुझाव देता है for...in बयान, लेकिन पुनरावृत्त सरणी के लिए for-in टालना चाहिए, उस कथन का मतलब है एक एक करके बताना वस्तु गुण।

इसका उपयोग सरणी जैसी वस्तुओं के लिए नहीं किया जाना चाहिए क्योंकि:

  • पुनरावृत्ति के क्रम की गारंटी नहीं है, सरणी अनुक्रमणिका को संख्यात्मक क्रम में नहीं देखा जा सकता है।
  • विरासत गुण भी गिने गए हैं।

दूसरा मुद्दा यह है कि यह आपको बहुत सारी समस्याएं दे सकता है, उदाहरण के लिए, यदि आप विस्तार करते हैं Array.prototype वहां एक विधि शामिल करने के लिए ऑब्जेक्ट, उस संपत्ति को भी समझा जाएगा।

उदाहरण के लिए:

Array.prototype.foo = "foo!";
var array = ['a', 'b', 'c'];

for (var i in array) {
  alert(array[i]);
}

उपर्युक्त कोड सतर्क होगा, "ए", "बी", "सी" और "फू!"।

यह विशेष रूप से एक समस्या है यदि आप कुछ लाइब्रेरी का उपयोग करते हैं जो मूल प्रोटोटाइप संवर्द्धन (उदाहरण के लिए म्यूटूल) पर भारी निर्भर करता है।

for-in जैसा कि मैंने पहले कहा था बयान है एक एक करके बताना वस्तु गुण, उदाहरण के लिए:

var obj = {
  "a": 1,
  "b": 2,
  "c": 3
};

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) { 
  // or if (Object.prototype.hasOwnProperty.call(obj,prop)) for safety...
    alert("prop: " + prop + " value: " + obj[prop])
  }
}

उपर्युक्त उदाहरण में hasOwnProperty विधि आपको केवल गणना करने की अनुमति देती है अपने गुण, यही वह गुण है, जो भौतिक रूप से वस्तु है, कोई विरासत गुण नहीं है।

मैं आपको निम्नलिखित लेख पढ़ने की सलाह दूंगा:


3060
2018-06-10 00:07



डाउन वोट क्यों? for...in होना चाहिए बचा ऐरे की तरह वस्तुओं के लिए! - CMS
यही कारण है (सीएमएस स्वयं स्वयं द्वारा) stackoverflow.com/questions/1885317/... - OscarRyz
@DoubleGras, मुझे लगता है कि यह एक राय है जिसे हर किसी द्वारा साझा नहीं किया जाता है। देख: stackoverflow.com/questions/5752906/... या groups.google.com/forum/?fromgroups#!topic/jsmentors/... - Matthijs Wessels
@StijndeWitt नहीं, क्योंकि यदि आपके पास कोई ब्रेक है तो वह टूट जाता है "Falsey" आपके सरणी में मान: false, undefined, 0, "", NaN। - Phrogz
jsperf.com/caching-array-length/4  यह देखने के लिए एक परीक्षण है कि जावास्क्रिप्ट लूप में सरणी की लंबाई कैशिंग करना उचित है या नहीं - Enrico


हां, लेकिन केवल तभी जब आपके कार्यान्वयन में शामिल है for...of सुविधा में पेश किया गया ईसीएमएस्क्रिप्ट 2015 ("सद्भावना" रिलीज)।

यह इस तरह काम करता है:

// REQUIRES ECMASCRIPT 2015+
var s, myStringArray = ["Hello", "World"];
for (s of myStringArray) {
  // ... do something with s ...
}

या बेहतर अभी तक, क्योंकि ईसीएमएस्क्रिप्ट 2015 भी ब्लॉक-स्कोप्ड चर के माध्यम से प्रदान करता है let तथा const:

// REQUIRES ECMASCRIPT 2015+
const myStringArray = ["Hello", "World"];
for (const s of myStringArray) {
  // ... do something with s ...
}
// s is no longer defined here

कई जावास्क्रिप्ट डेवलपर्स अभी भी ऐसे माहौल में काम कर रहे हैं जो अभी तक नहीं है, हालांकि - विशेष रूप से यदि वेब ब्राउज़र में चलाने के लिए कोड लिखना है, जहां साइट डेवलपर अक्सर यह सुनिश्चित नहीं कर सकते कि उनके क्लाइंट का कौन सा ब्राउज़र / संस्करण उपयोग करेगा।

यदि आप मान सकते हैं कि जावास्क्रिप्ट दुभाषिया के अनुरूप है पिछला ईसीएमएस्क्रिप्ट विनिर्देश का संस्करण (जो नियम, उदाहरण के लिए, इंटरनेट एक्सप्लोरर के संस्करण 9 से पहले), तो आप इसका उपयोग कर सकते हैं forEach एक लूप के बजाय इटरेटर विधि। उस स्थिति में, आप सरणी में प्रत्येक आइटम पर एक फ़ंक्शन को कॉल करने के लिए पास करते हैं:

var myStringArray = [ "Hello", "World" ];
myStringArray.forEach( function(s) { 
     // ... do something with s ...
} );

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

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  if (i in myStringArray) {
    s = myStringArray[i];
    // ... do something with s ...
  }
}

स्थानीय चर में लंबाई मान असाइन करना (पूर्ण सहित शामिल करने के विपरीत myStringArray.length लूप स्थिति में अभिव्यक्ति) प्रदर्शन में महत्वपूर्ण अंतर डाल सकती है क्योंकि यह हर बार एक संपत्ति लुकअप छोड़ देती है; मेरी मशीन पर राइनो का उपयोग करके, गति 43% है।

आप अक्सर लूप प्रारंभिक खंड में किए गए लम्बाई कैशिंग देखेंगे, जैसे:

var i, len, myStringArray = [ "Hello", "World" ];
for (len = myStringArray.length, i=0; i<len; ++i) {

for...in दूसरों द्वारा उल्लिखित वाक्यविन्यास किसी वस्तु के गुणों पर लूपिंग के लिए है; चूंकि जावास्क्रिप्ट में एक ऐरे केवल संख्यात्मक संपत्ति नामों वाला एक ऑब्जेक्ट है (और स्वचालित रूप से अपडेट किया गया है lengthसंपत्ति), आप सैद्धांतिक रूप से इसके साथ एक ऐरे पर लूप कर सकते हैं। लेकिन समस्या यह है कि यह खुद को संख्यात्मक संपत्ति मूल्यों तक सीमित नहीं करता है (याद रखें कि यहां तक ​​कि विधियां वास्तव में केवल वे गुण हैं जिनके मूल्य बंद हैं), न ही यह संख्यात्मक क्रम में उन पर निर्भर करता है। इसलिए for...in वाक्यविन्यास चाहिए नहीं Arrays के माध्यम से लूपिंग के लिए इस्तेमाल किया जाना चाहिए।


871
2018-04-16 02:03



ध्यान दें कि कुछ दुभाषिया (उदा। वी 8) स्वचालित रूप से सरणी की लंबाई को कैश करेंगे अगर कोड को पर्याप्त समय कहा जाता है और यह पता लगाता है कि लंबाई लूप द्वारा संशोधित नहीं है। लंबाई को कैशिंग करना अभी भी अच्छा है, लेकिन जब आपका कोड वास्तव में एक अंतर बनाने के लिए पर्याप्त समय लगाया जा रहा है तो यह गति वृद्धि प्रदान नहीं कर सकता है। - Phrogz
@ मार्क-रीड क्या आप कृपया बता सकते हैं कि आपने क्यों उपयोग किया i in myStringArray आपके उदाहरण में? यह कैसे गलत हो सकता है? - Denis V
@ डेनिसवी: झूठी। a=[1,2,3,4]; delete a[2]; for (j in a) { console.log(j); }  आउटपुट 0, 1, 3, और 4। a.length अभी भी 5 है - Mark Reed
मैं सुझाव नहीं दे रहा हूँ for j in a। मैं यह दिखा रहा हूं कि in चेक अनावश्यक नहीं है, जैसा कि आपने दावा किया था कि यह सभी इंडेक्स दिखाकर और दिखा रहा है कि 0 और उसके बीच एक है length-1 वह वहां नहीं है। मैं अभी भी मुद्रित कर सकता था 2 in a, जो वास्तव में है false, इस तथ्य के बावजूद कि आपने कहा कि असंभव था। - Mark Reed
@GrijeshChauhan - सही। उदाहरण के लिए, संस्करण 8 के माध्यम से आईई इसका समर्थन नहीं करता है। देख यह प्रश्न। - Mark Reed


आप उपयोग कर सकते हैं map, जो एक कार्यात्मक प्रोग्रामिंग तकनीक है जो अन्य भाषाओं में भी उपलब्ध है अजगर तथा हास्केल

[1,2,3,4].map( function(item) {
     alert(item);
})

सामान्य वाक्यविन्यास है:

array.map(func)

सामान्य रूप में func एक पैरामीटर लेगा, जो सरणी का एक आइटम है। लेकिन जावास्क्रिप्ट के मामले में, यह दूसरा पैरामीटर ले सकता है जो आइटम की अनुक्रमणिका है, और एक तीसरा पैरामीटर जो सरणी है।

का वापसी मूल्य array.map एक और सरणी है, इसलिए आप इसे इस तरह उपयोग कर सकते हैं:

var x = [1,2,3,4].map( function(item) {return item * 10;});

और अब एक्स है [10,20,30,40]

आपको फ़ंक्शन इनलाइन लिखना नहीं है। यह एक अलग समारोह हो सकता है।

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

जो कि इसके बराबर होगा:

 for (item in my_list) {item_processor(item);}

सिवाय इसके कि आपको नहीं मिलता है new_list


392
2018-06-10 00:09



नहीं, लेकिन यह और अधिक शक्तिशाली हो सकता है। इसकी जांच करें: joelonsoftware.com/items/2006/08/01.html - hasen
वह विशेष उदाहरण शायद बेहतर ढंग से लागू किया गया है Array.forEach। map एक नई सरणी पैदा करने के लिए है। - harto
@ हसन, द Array.prototype.map विधि ईसीएमएस्क्रिप्ट 5 वें संस्करण मानक का हिस्सा है, अभी तक सभी कार्यान्वयन पर उपलब्ध नहीं है (उदा। आईई की कमी है), इसके लिए भी बार-बार दोहराना एक सरणी पर मुझे लगता है कि Array.prototype.forEach विधि अधिक है शब्दार्थ सही ... कृपया भी इन-इन कथन का सुझाव न दें, अधिक जानकारी के लिए मेरा उत्तर देखें :) - CMS
के बीच भिन्नता forEach तथा map यह है कि पूर्व पुनरावृत्ति के परिणाम वापस नहीं करता है। map (कभी-कभी ए.के.ए. collect, लेकिन से बहुत अलग है apply) एक सरणी के प्रत्येक तत्व को इसी परिणाम में बदलने के लिए स्पष्ट रूप से है; यह 1 से 1 है मानचित्रण, इसके कारण नाम। यह संचालन के पूरे परिवार का हिस्सा है जिसमें शामिल हैं reduce (जो पूरे सरणी से एक परिणाम उत्पन्न करता है) और filter (जो मूल सरणी का सबसेट उत्पन्न करता है) और इसी तरह। जहाँ तक forEachबस प्रत्येक तत्व के साथ कुछ करता है, अर्थशास्त्र अनिर्धारित। - Mark Reed
डाउनवोट क्योंकि अगर आप वास्तव में कुछ मैपिंग नहीं कर रहे हैं, तो [] .map का उपयोग भ्रामक है। [] .forEach अर्थपूर्ण भावना बनाता है और समारोह में वही तीन तर्क भी पास करता है। - gengkev


जावास्क्रिप्ट में फॉर-इन लूप के साथ एक ऐरे के माध्यम से लूप को सलाह नहीं दी जाती है, लेकिन यह लूप के लिए बेहतर है जैसे कि:

for(var i=0, len=myArray.length; i < len; i++){}

यह भी अनुकूलित है (सरणी लंबाई "कैशिंग")। यदि आप और जानना चाहते हैं, विषय पर मेरी पोस्ट पढ़ें


102
2017-12-07 07:24



myArray.forEach (फ़ंक्शन (obj) {}); अभी भी सबसे अच्छा है - Jan Sverre
एक छोटा सुधार: आप उपयोग कर सकते हैं ++i के बजाय i++ - roberkules
++i एक पुराना स्कूल अनुकूलन है कि आधुनिक कंपेलर आपके लिए लंबे समय से लूप में आपके लिए करते हैं :) stackoverflow.com/a/1547433/1033348 - ngryman
@Jannis .forEach इसके खिलाफ कई चीजें हैं। 1) मूल नहीं 2) प्रत्येक सूचकांक के लिए एक नया निष्पादन संदर्भ आवश्यक है जो कि महंगा है और ओवरकिल जैसा दिखता है (देखें dmitrysoshnikov.com/ecmascript/chapter-1-execution-contexts) - Jose
आपको इस लूप का उपयोग करके सावधान रहना होगा। मैंने इसका उपयोग करना शुरू कर दिया और एक गलती के कारण बग को ट्रैक करना मुश्किल था। यदि आप इस तरह दो loops घोंसला: jsfiddle.net/KQwmL/1। आपको दो लूपों में अलग-अलग वैर लेन का नाम देने के लिए सावधान रहना होगा, अन्यथा दूसरा लूप पहले लेन को ओवरराइट करेगा। - Rui Marques


के लिए (myStringArray के var s) {

(सीधे अपने प्रश्न का उत्तर दें: अब आप कर सकते हैं!)

अधिकांश अन्य उत्तरों सही हैं, लेकिन वे उल्लेख नहीं करते हैं (इस लेखन के रूप में) ईसीएमए स्क्रिप्ट 6 2015 पुनरावृत्ति करने के लिए एक नया तंत्र ला रहा है, for..of पाश।

जावास्क्रिप्ट में एक सरणी को फिर से चलाने के लिए यह नया वाक्यविन्यास सबसे शानदार तरीका है (जब तक आपको पुनरावृत्ति सूचकांक की आवश्यकता नहीं है), लेकिन यह अभी तक ब्राउज़र द्वारा व्यापक रूप से समर्थित नहीं है।

यह वर्तमान में फ़ायरफ़ॉक्स 13+, क्रोम 37+ के साथ काम करता है और यह अन्य ब्राउज़रों के साथ काम नहीं करता है (नीचे ब्राउज़र संगतता देखें)। सौभाग्य से हमारे पास जेएस कंपाइलर हैं (जैसे कोलाहल) जो आज हमें अगली पीढ़ी की सुविधाओं का उपयोग करने की अनुमति देता है।

यह नोड पर भी काम करता है (मैंने इसे संस्करण 0.12.0 पर परीक्षण किया)।

एक सरणी Iterating

// You could also use "let" instead of "var" for block scope.
for (var letter of ["a", "b", "c"]) { 
   console.log(letter); 
}

वस्तुओं की एक सरणी Iterating

var band = [
  {firstName : 'John', lastName: 'Lennon'}, 
  {firstName : 'Paul', lastName: 'McCartney'}
];

for(var member of band){
  console.log(member.firstName + ' ' + member.lastName); 
}

जनरेटर को इटरेट करना:

(उदाहरण से निकाला गया https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of)

function* fibonacci() { // a generator function
  let [prev, curr] = [1, 1];
  while (true) {
    [prev, curr] = [curr, prev + curr];
    yield curr;
  }
}

for (let n of fibonacci()) {
  console.log(n);
  // truncate the sequence at 1000
  if (n >= 1000) {
    break;
  }
}

संगतता तालिका: http://kangax.github.io/es5-compat-table/es6/#For..of loops

युक्ति:  http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}


92
2017-08-11 15:54



यदि आप ES6 का उपयोग कर रहे हैं, तो मैं सुझाव दूंगा const s के बजाय var s - joeytwiddle


ओपेरा, सफारी, फ़ायरफ़ॉक्स और क्रोम अब सभी कई सामान्य लूप को अनुकूलित करने के लिए उन्नत ऐरे विधियों का एक सेट साझा करते हैं।

आपको उन सभी की आवश्यकता नहीं हो सकती है, लेकिन वे बहुत उपयोगी हो सकते हैं, या यदि प्रत्येक ब्राउज़र ने उन्हें समर्थन दिया होगा।

मोज़िला लैब्स ने एल्गोरिदम प्रकाशित किए और वे वेबकिट दोनों का उपयोग करें, ताकि आप उन्हें स्वयं जोड़ सकें।

फिल्टर कुछ शर्त या परीक्षण को संतुष्ट करने वाली वस्तुओं की एक सरणी देता है।

प्रत्येक अगर प्रत्येक सरणी सदस्य परीक्षा पास करता है तो सच हो जाता है।

कुछ अगर कोई परीक्षा पास करता है तो सच हो जाता है।

प्रत्येक के लिए प्रत्येक सरणी सदस्य पर एक फ़ंक्शन चलाता है और कुछ भी वापस नहीं करता है।

नक्शा प्रत्येक के लिए पसंद है, लेकिन यह प्रत्येक तत्व के लिए ऑपरेशन के परिणामों की एक सरणी देता है।

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

इसे तब तक अनदेखा करें जब तक आपको इसकी आवश्यकता न हो।

के सूचकांक तथा lastIndexOf पहले या अंतिम तत्व की उपयुक्त स्थिति पाएं जो इसके तर्क से मेल खाती है।

(function(){
    var p, ap= Array.prototype, p2={
        filter: function(fun, scope){
            var L= this.length, A= [], i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        val= this[i];
                        if(fun.call(scope, val, i, this)){
                            A[A.length]= val;
                        }
                    }
                    ++i;
                }
            }
            return A;
        },
        every: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && !fun.call(scope, this[i], i, this))
                        return false;
                    ++i;
                }
                return true;
            }
            return null;
        },
        forEach: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
            }
            return this;
        },
        indexOf: function(what, i){
            i= i || 0;
            var L= this.length;
            while(i< L){
                if(this[i]=== what)
                    return i;
                ++i;
            }
            return -1;
        },
        lastIndexOf: function(what, i){
            var L= this.length;
            i= i || L-1;
            if(isNaN(i) || i>= L)
                i= L-1;
            else
                if(i< 0) i += L;
            while(i> -1){
                if(this[i]=== what)
                    return i;
                --i;
            }
            return -1;
        },
        map: function(fun, scope){
            var L= this.length, A= Array(this.length), i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        A[i]= fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
                return A;
            }
        },
        some: function(fun, scope){
            var i= 0, L= this.length;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && fun.call(scope, this[i], i, this))
                        return true;
                    ++i;
                }
                return false;
            }
        }
    }
    for(p in p2){
        if(!ap[p])
            ap[p]= p2[p];
    }
    return true;
})();

81
2018-06-10 02:43



अतिरिक्त: संस्करण 9 के बाद से आईई का समर्थन करता है, देखें प्रत्येक विधि एमएसडीएन के लिए - rwitzel


जबकि लूप का प्रयोग करें ...

var i=0, item, items = ['one','two','three'];
while(item = items[i++]){
    console.log(item);
}

लॉग: 'एक', 'दो', 'तीन'

और रिवर्स ऑर्डर के लिए, एक और अधिक कुशल पाश

var items = ['one','two','three'], i = items.length;
while(i--){
    console.log(items[i]);
}

लॉग: 'तीन', 'दो', 'एक'

या शास्त्रीय for पाश

var items = ['one','two','three']
for(var i=0, l = items.length; i < l; i++){
    console.log(items[i]);
}

लॉग: 'एक', 'दो', 'तीन'

संदर्भ: http://www.sitepoint.com/google-closure-how-not-to-write-javascript/


62
2018-01-05 09:15



"जबकि" वाक्यविन्यास का पहला उदाहरण काम नहीं करेगा यदि सरणी तत्वों में से कोई भी गलत है। - Chris Cooper
... और यह जबकि लूप समकक्ष है: के लिए (var i = 0, आइटम; आइटम = आइटम [i]; i ++), जो पहले से इंडेक्स और आइटम चर घोषित करने की आवश्यकता को दूर करता है ... - Stijn de Witt
@StijndeWitt लेकिन इसके लिए लागू होता है: अगर मूल्य है falsy, यह काम नहीं करेगा... - yckart
संग्रह पर पुनरावृत्ति करते समय, आपको अनुकूलन की परवाह करनी चाहिए। क्योंकि यह पृष्ठ प्रदर्शन को प्रभावित कर सकता है। - Zaheer Ahmed


पहचान

कॉलेज में मेरा समय के बाद से, मैंने जावा, जावास्क्रिप्ट, पास्कल में प्रोग्राम किया है, ABAP, पीएचपी, प्रगति 4 जीएल, सी / सी ++ और संभवतः कुछ अन्य भाषाओं में मैं अभी नहीं सोच सकता।

जबकि उनके सभी में अपनी भाषाई idiosyncrasies है, इन भाषाओं में से प्रत्येक एक ही बुनियादी अवधारणाओं को साझा करते हैं। ऐसी अवधारणाओं में प्रक्रियाएं / कार्य शामिल हैं, IF-statements, FOR-लोप्स, और WHILE-loops।


पारंपरिक for-loop

पारंपरिक for लूप में तीन घटक हैं:

  1. प्रारंभिकरण: देखो ब्लॉक को पहली बार निष्पादित करने से पहले निष्पादित किया गया है
  2. शर्त: लूप ब्लॉक निष्पादित होने से पहले हर बार एक शर्त की जांच करता है, और झूठ अगर लूप छोड़ देता है
  3. बाद विचार: लूप ब्लॉक निष्पादित होने के बाद हर बार प्रदर्शन किया जाता है

ये तीन घटक एक-दूसरे से अलग होते हैं ; प्रतीक। इन तीनों घटकों में से प्रत्येक के लिए सामग्री वैकल्पिक है, जिसका अर्थ है कि निम्नलिखित सबसे न्यूनतम है for लूप संभव:

for (;;) {
    // Do stuff
}

बेशक, आपको एक शामिल करने की आवश्यकता होगी if(condition === true) { break; }  या एक if(condition === true) { return; } उसमें कहीं अंदर forचलने से रोकने के लिए इसे छोड़ दें।

आम तौर पर, हालांकि, प्रारंभिकरण का उपयोग इंडेक्स घोषित करने के लिए किया जाता है, स्थिति का उपयोग उस सूचकांक की तुलना न्यूनतम या अधिकतम मूल्य के साथ करने के लिए किया जाता है, और बाद में विचार सूचकांक में वृद्धि के लिए उपयोग किया जाता है:

for (var i = 0, length = 10; i < length; i++) {
    console.log(i);
}

पारंपरिक का उपयोग करना for एक सरणी के माध्यम से लूप करने के लिए लूप

एक सरणी के माध्यम से लूप करने का पारंपरिक तरीका यह है:

for (var i = 0, length = myArray.length; i < length; i++) {
    console.log(myArray[i]);
}

या, यदि आप पीछे की तरफ लूप करना पसंद करते हैं, तो आप यह करते हैं:

for (var i = myArray.length - 1; i > -1; i--) {
    console.log(myArray[i]);
}

हालांकि, कई भिन्नताएं संभव हैं, उदाहरण के लिए यह एक:

for (var key = 0, value = myArray[key], length = myArray.length; key < length; value = myArray[++key]) {
    console.log(value);
}

... या यह एक ...

var i = 0, length = myArray.length;
for (; i < length;) {
    console.log(myArray[i]);
    i++;
}

... या यह एक:

var key = 0, value;
for (; value = myArray[key++];){
    console.log(value);
}

जो भी सबसे अच्छा काम करता है वह काफी हद तक व्यक्तिगत स्वाद और विशिष्ट उपयोग के मामले का विषय है जो आप कार्यान्वित कर रहे हैं।

ध्यान दें कि इनमें से प्रत्येक भिन्नता सभी ब्राउज़रों द्वारा समर्थित है, जिनमें बहुत पुराने हैं!


while पाश

ए के लिए एक विकल्प for लूप एक है whileपाश। एक सरणी के माध्यम से लूप करने के लिए, आप यह कर सकते हैं:

var key = 0;
while(value = myArray[key++]){
    console.log(value);
}

पारंपरिक की तरह for छोरों, while loops भी ब्राउज़र के सबसे पुराने द्वारा समर्थित हैं।

साथ ही, ध्यान दें कि प्रत्येक जबकि लूप को एक के रूप में फिर से लिखा जा सकता है for पाश। उदाहरण के लिए, while यहां लूप इस तरह से वैसे ही व्यवहार करता है for-loop:

for(var key = 0; value = myArray[key++];){
    console.log(value);
}

For...in तथा for...of

जावास्क्रिप्ट में, आप यह भी कर सकते हैं:

for (i in myArray) {
    console.log(myArray[i]);
}

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

एक विकल्प के रूप में for...in, अब भी इसके लिए है for...of। निम्नलिखित उदाहरण ए के बीच का अंतर दिखाता है for...of लूप और ए for...in पाश:

var myArray = [3, 5, 7];
myArray.foo = "hello";

for (var i in myArray) {
  console.log(i); // logs 0, 1, 2, "foo"
}

for (var i of myArray) {
  console.log(i); // logs 3, 5, 7
}

इसके अतिरिक्त, आपको यह विचार करने की आवश्यकता है कि इंटरनेट एक्सप्लोरर का कोई संस्करण समर्थित नहीं है for...of (एज 12+ करता है) और वह for...in कम से कम इंटरनेट एक्सप्लोरर 10 की आवश्यकता है।


Array.prototype.forEach()

एक विकल्प for-लोप्स है Array.prototype.forEach(), जो निम्नलिखित वाक्यविन्यास का उपयोग करता है:

myArray.forEach(function(value, key, myArray) {
    console.log(value);
});

Array.prototype.forEach() सभी आधुनिक ब्राउज़रों के साथ-साथ इंटरनेट एक्सप्लोरर 9 और बाद में समर्थित है।


पुस्तकालय

अंत में, कई उपयोगिता पुस्तकालयों का भी अपना स्वयं का होता है foreach भिन्नता। AFAIK, तीन सबसे लोकप्रिय हैं ये हैं:

jQuery.each()में jQuery:

$.each(myArray, function(key, value) {
    console.log(value);
});

_.each()में Underscore.js:

_.each(myArray, function(value, key, myArray) {
    console.log(value);
});

_.forEach()में Lodash.js:

_.forEach(myArray, function(value, key) {
    console.log(value);
});

48
2018-02-29 18:56





यदि आप फास्ट लूप लिखने के लिए एक रास्ता चाहते हैं तथा आप विपरीत में पुन: प्रयास कर सकते हैं:

for (var i=myArray.length;i--;){
  var item=myArray[i];
}

इसका लंबाई लंबाई कैश करने का लाभ है (इसी तरह for (var i=0, len=myArray.length; i<len; ++i) और विपरीत for (var i=0; i<myArray.length; ++i)) टाइप करने के लिए कम वर्ण होने के दौरान।

यहां तक ​​कि कुछ बार भी होते हैं जब आपको विपरीत में पुनरावृत्ति करना चाहिए, जैसे कि जब एक पर पुनरावृत्ति होती है लाइव नोडलिस्ट जहां आप पुनरावृत्ति के दौरान डीओएम से वस्तुओं को हटाने की योजना बनाते हैं।


35
2018-06-04 16:26



उन लोगों के लिए जो इतनी सरल नहीं हैं: i-- अभिव्यक्ति का पहले मूल्यांकन किया जाता है और लूप को जारी रखने की अनुमति देता है जब यह गलत नहीं होता है ... बाद में काउंटर कम हो जाता है। जैसे ही मैं शून्य हो जाता हूं, यह लूप से बाहर हो जाएगा क्योंकि शून्य जावास्क्रिप्ट में एक झूठा मूल्य है। - Stijn de Witt
falsish? तुम्हारा मतलब झूठा है। चलो भ्रम से बचने के लिए सभी उचित शब्दावली को छूएं;) - danwellman
मैंने उन लोगों द्वारा गलत शब्द का उपयोग किया है जिन्हें मैं गुरु मानता हूं। यदि यह उनके लिए पर्याप्त है तो यह मेरे लिए काफी अच्छा है। यह भी देखने के लिए निराश है कि मेरी टिप्पणी वास्तव में परोपकारी है और स्पष्टीकरण / अंतर्दृष्टि जोड़ती है 0 अपवॉट्स, लेकिन मेरी टिप्पणी में एक शब्द पर नाइटपिक्स टिप्पणी है 4. आह अच्छी तरह से मुझे लगता है कि प्राथमिकताओं का मामला है। - Stijn de Witt
"लंबाई कैशिंग"? लंबाई को सरणी में एक पूर्णांक के रूप में संग्रहीत किया जाता है, यह हर बार जब आप इसे एक्सेस करते हैं तो इसे मापा नहीं जाता है। लंबाई के मूल्य को किसी अन्य चर में कॉपी करने में यहां कोई लाभ नहीं है। - Mouscellaneous
@Mouscellaneous इन दिनों निश्चित रूप से नहीं है; पिछले कुछ वर्षों में जावास्क्रिप्ट पक्ष पर लंबाई को कैश करने वाले जावास्क्रिप्ट एरे (कार्यान्वयन में पहुंचने की बजाय) एक स्पष्ट perf लाभ था (जब microoptimizing)। उदाहरण के लिए, for (var i=0,len=array.length;i<len;++i) लिखने के लिए एक आम, समझदार पाश था। - Phrogz


ऐसा करने का एक तरीका है जहां आपके लूप में बहुत कम अंतर्निहित दायरा है और अतिरिक्त चर से दूर रहें।

var i = 0,
     item;

// note this is weak to sparse arrays or falsey values
for ( ; item = myStringArray[i++] ; ){ 
    item; // This is the string at the index.
}

या यदि आप वास्तव में आईडी प्राप्त करना चाहते हैं और वास्तव में शास्त्रीय है for पाश:

var i = 0,
    len = myStringArray.length; // cache the length

for ( ; i < len ; i++ ){
    myStringArray[i]; // Don't use this if you plan on changing the length of the array
}

आधुनिक ब्राउज़र सभी इटरेटर विधियों का समर्थन करते हैं forEach, map, reduce, filter और कई अन्य विधियों पर ऐरे प्रोटोटाइप


26
2018-05-16 22:52



ध्यान दें कि कुछ दुभाषिया (उदा। वी 8) स्वचालित रूप से सरणी की लंबाई को कैश कर देंगे यदि कोड को पर्याप्त समय कहा जाता है और यह पता लगाता है कि लंबाई लूप द्वारा संशोधित नहीं है। - Phrogz
@Phrogz की जानकारी के लिए धन्यवाद यह सच है कि वीएम बना सकते हैं कि बहुत से अनुकूलन हैं, लेकिन चूंकि पुराने ब्राउज़र में यह नहीं है, इसलिए यह अभी भी सस्ती होने के बाद से अनुकूलित करने का सबसे अच्छा अभ्यास होगा। - Gabriel
@ गैब्रियल: क्यों? कृपया असली दुनिया के उदाहरण दें जो दिखाते हैं कि लंबाई को कैशिंग नहीं करना वास्तव में एक प्रदर्शन बाधा है। मैं 'समयपूर्व अनुकूलन सभी बुराई' दृष्टिकोण की जड़ का पालन करता हूं। मैं उस लूप को ठीक कर दूंगा जो वास्तव में एक समस्या का सामना कर लेता है ... - Stijn de Witt
@StijndeWitt imo यह सिर्फ एक स्टाइलिस्ट मुद्दा है। ईमानदारी से मैं इन चीजों को करने के लिए _.each, _.map इत्यादि जैसी चीज़ों के लिए अंडरस्कोर पर भरोसा करने के बजाय लूप के लिए भी उपयोग नहीं करता हूं। जब मैंने इस तरह के लूप लिखते थे तो मैंने मुख्य रूप से लंबाई को कैश किया ताकि मेरे सभी चरम घोषणा मेरे कार्य के शीर्ष पर एक ही स्थान पर हो। इस संबंध में मेरी सलाह के बाद किसी वास्तविक दुनिया के आवेदन के लिए अपरिहार्य है। समयपूर्व अनुकूलन बहुत खराब है, लेकिन यदि स्टाइलिस्ट निर्णयों के परिणामस्वरूप ऑप्टिमाइज़ेशन होता है तो मुझे नहीं लगता कि यह वास्तव में मायने रखता है। - Gabriel
@ गैब्रियल मेरा मानना ​​है कि जावास्क्रिप्ट पहले से ही सरणी पर मानचित्र फ़ंक्शन का समर्थन करता है, इसके लिए अतिरिक्त lib को पेश करने की आवश्यकता नहीं है। - Noz


जावास्क्रिप्ट में सरणी के माध्यम से लूप करने के लिए कई तरीके हैं।

सामान्य लूप:

var i;
for (i = 0; i < substr.length; ++i) {
    // Do something with `substr[i]`
}

ईएस 5 के लिए प्रत्येक:

substr.forEach(function(item) {
    // Do something with `item`
});

jQuery.each:

jQuery.each(substr, function(index, item) {
    // Do something with `item` (or `this` is also `item` if you like)
});

एक नज़र देख लो इस विस्तृत जानकारी के लिए या आप भी जांच सकते हैं MDN जावास्क्रिप्ट में एक सरणी के माध्यम से लूपिंग और jQuery जांच का उपयोग कर प्रत्येक के लिए jQuery


26
2017-07-23 12:59



यह एक शर्म की बात है कि ईएस 5 के लिए उत्तर उत्तर के शीर्ष पर नहीं है क्योंकि ओपी क्या पूछ रहा था उससे सबसे करीबी मिलान करता है। - Pete