दिलचस्प पोस्ट
प्रेषण_असिनक को समझना प्रत्येक दूसरे पर निर्भर गुणों को कैसे प्रारंभ करें जावा और सेलेनियम वेबड्रायवर का इस्तेमाल करते हुए फ़ॉर्म और आइफ्रेम के तत्वों को ढूंढें प्रोग्रामेटिक रूप से एलेप्से प्लग-इन से एक दृश्य दिखा रहा है SQL स्क्रिप्ट से सीएसवी खोल स्क्रिप्ट का उपयोग करें इंटेल सरणी के लिए स्विफ्ट में हाशनीय प्रोटोकॉल कैसे लागू करें (कस्टम स्ट्रिंग स्ट्रेट) ऑन-चेंज इवेंट हैंडलर रेडियो बटन (INPUT प्रकार = "रेडियो") के लिए एक मान के रूप में काम नहीं करता है मैं एक कैरेक्टर का यूनिकोड कोड बिंदु कैसे प्राप्त करूं? मैं कैसे पता लगा सकता है कि एक बाहरी कीबोर्ड एक आईपैड पर मौजूद है या नहीं? htaccess redirects https: // www स्वामित्व वाली वस्तु की विधि के लिए अस्थायी स्वयं संदर्भ पास करना Google Plus लॉगिन के एकीकरण के साथ "एक आंतरिक त्रुटि हुई" *, /, +, -,% ऑपरेटरों का उपयोग किए बिना 3 से संख्या विभाजित करें कैसे std :: chrono :: time_point को बदलने के लिए आंशिक सेकंड के साथ दिनचर्या स्ट्रिंग कैलेंडर? एसक्यूएल: बनाम <= और> =

JavaScript में सरणी के माध्यम से लूप

जावा में आप एक एप में ऑब्जेक्ट्स को आज़माने के for लूप का उपयोग निम्नानुसार कर सकते हैं:

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

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

वेब के समाधान से एकत्रित समाधान "JavaScript में सरणी के माध्यम से लूप"

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

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

@ ज़िपोडैमन के for...in बयान for...in का उपयोग करने का सुझाव है, लेकिन फिर से चलने वाली सरणियों के for-in बचा जाना चाहिए, यह कथन ऑब्जेक्ट गुणों को बताने के लिए है

इसका उपयोग सरणी-जैसी ऑब्जेक्ट के लिए नहीं किया जाना चाहिए क्योंकि:

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

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

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

 Array.prototype.foo = "foo!"; var array = ['a', 'b', 'c']; for (var i in array) { alert(array[i]); } 

उपरोक्त कोड चेतावनी देगा, "a", "b", "c" और "foo!"

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

के 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 विधि आपको केवल अपनी संपत्तियों की गणना करने की अनुमति देती है, वह यह है, केवल उस गुण जो भौतिक रूप से मौजूद हैं, कोई विरासत नहीं गुण हैं।

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

  • गणना वी.एस. परिवर्तन

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

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

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

या बेहतर अभी तक, ECMAScript 2015 के बाद से ब्लॉक और स्कॉच चर के माध्यम से let और const प्रदान करता है:

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

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

यदि आप जावास्क्रिप्ट अनुवादक ग्रहण कर सकते हैं तो ईसीएमएस्क्रिप्ट विनिर्देश के पिछले संस्करण के अनुरूप है (उदाहरण के लिए, उदाहरण के लिए, 9 से पहले Internet Explorer के संस्करण), तो आप लूप के बजाय 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) { 

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

आप 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 नहीं मिलती

जावास्क्रिप्ट में लूप के लिए लूप के लिए सलाह नहीं दी जाती है, जिसमें लूप के साथ एक अर्रे है, लेकिन लूप के लिए यह बेहतर है जैसे कि:

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

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

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

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

अधिकांश अन्य उत्तर सही हैं, लेकिन वे (इस लेखन के रूप में) का उल्लेख नहीं करते हैं कि ईसीएमए स्क्रिप्ट 6 2015 चलना करने के लिए एक नई तंत्र ला रहा है, लूप के लिए …

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

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

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

एक सरणी बदलना

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

ऑब्जेक्ट्स की एक सरणी बदलना

 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/ # लूप के लिए

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

}

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

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

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

फ़िल्टर कुछ ऐसी चीज़ें प्रदान करता है जो कुछ स्थिति या परीक्षण को संतुष्ट करते हैं।

हर रिटर्न सच है अगर हर सरणी सदस्य परीक्षा उत्तीर्ण करता है।

अगर कोई परीक्षा पास करता है तो कुछ रिटर्न सही होता है।

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

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

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

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

indexOf और 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; })(); 

जबकि लूप का उपयोग करें …

 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/

यदि आप एक तेज लूप लिखने के लिए एक संक्षिप्त तरीका चाहते हैं और आप रिवर्स में दोहरा सकते हैं:

 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) ) टाइप करने के लिए कम वर्ण होने के दौरान।

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

पहचान

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

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


के लिए एक पारंपरिक -loop

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

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

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

 for (;;) { // Do stuff } 

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

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

 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 छोरों को ब्राउज़र का सबसे पुराना भी समर्थन मिलता है।

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

 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 लूप for...in for...of बीच के अंतर को दर्शाता है:

 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 } 

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


Array.prototype.forEach()

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

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

Array.prototype.forEach() सभी आधुनिक ब्राउज़रों द्वारा समर्थित है, साथ ही साथ Internet Explorer 9 और बाद में।


पुस्तकालय

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

jQuery.each() , jQuery में :

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

_.each() , _.each() में:

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

_.forEach() , लोदाश.जेएस में :

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

ऐसा करने का एक तरीका है जहां आप अपने लूप में बहुत कम अंतर्निहित गुंजाइश रखते हैं और अतिरिक्त चर के साथ दूर करते हैं

 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 और अन्य विधियों के लिए forEach तरीके का समर्थन करते हैं।

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

सामान्य लूप:

 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) }); 

विस्तृत जानकारी के लिए इस पर एक नज़र डालें या आप एमडीएन को जावा में एक सरणी के माध्यम से पाशन और प्रत्येक के लिए jQuery के चेक jQuery का उपयोग कर सकते हैं ।

मैं अच्छी तरह से underscore.js पुस्तकालय का उपयोग करने की सिफारिश करेंगे। यह आपको विभिन्न फ़ंक्शन प्रदान करता है जो कि आप सरणियों / संग्रहों को पुनरावृत्त करने के लिए उपयोग कर सकते हैं।

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

 _.each([1, 2, 3], function(num){ alert(num); }); => alerts each number in turn... 

ऐरे लूप:

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

ऑब्जेक्ट पाश:

 for(var prop in obj){ var propValue = obj[prop]; console.log(propValue); } 

यदि आप jQuery लाइब्रेरी का उपयोग कर रहे हैं, तो http://api.jquery.com/jQuery.each/ का उपयोग करने पर विचार करें

प्रलेखन से:

jQuery.each( collection, callback(indexInArray, valueOfElement) )

रिटर्न: ऑब्जेक्ट

विवरण: एक जेनेरिक इटरेटर फ़ंक्शन, जिसका उपयोग दोनों ऑब्जेक्ट्स और एरेज़ों पर सीमांत रूप से पुनरावृति करने के लिए किया जा सकता है। सरणी और सरणी-जैसी वस्तुओं की लंबाई वाली संपत्ति (जैसे कि फ़ंक्शन के आर्गुमेंट ऑब्जेक्ट) के साथ संख्यात्मक इंडेक्स द्वारा 0 से लंबाई-1 तक चलती हैं। अन्य ऑब्जेक्ट्स उनके नामांकित गुणों के माध्यम से चलती हैं

$.each() फ़ंक्शन $(selector).each() के समान नहीं है, जो कि jQuery ऑब्जेक्ट पर पुनरावृत्त करने के लिए उपयोग किया जाता है। $.each() फ़ंक्शन का उपयोग किसी भी संग्रह से पुनरावृति करने के लिए किया जा सकता है, चाहे वह एक मानचित्र (जावास्क्रिप्ट ऑब्जेक्ट) या एक सरणी है। एक सरणी के मामले में, कॉलबैक प्रत्येक बार एक सरणी अनुक्रमणिका और एक संगत सरणी मान पारित किया जाता है। (मान को this खोजशब्द के माध्यम से भी एक्सेस किया जा सकता है, लेकिन जावास्क्रिप्ट हमेशा एक Object रूप में this मान को लपेटता है, भले ही यह एक साधारण स्ट्रिंग या संख्या मान है।) विधि अपनी पहली तर्क देता है, जिस ऑब्जेक्ट को पुनरावृत्त किया गया था

मैंने अभी तक इस भिन्नता को नहीं देखा, जिसे मैं व्यक्तिगत रूप से सर्वश्रेष्ठ पसंद करता हूं:

एक सरणी को देखते हुए:

 var someArray = ["some", "example", "array"]; 

आप कभी भी लंबाई की संपत्ति तक बिना बिना पाश कर सकते हैं:

 for (var i=0, item; item=someArray[i]; i++) { // item is "some", then "example", then "array" // i is the index of item in the array alert("someArray[" + i + "]: " + item); } 

इस जेएसएफडियल को यह दर्शाते हुए देखें कि: http://jsfiddle.net/prvzk/

यह केवल सरणियों के लिए काम करता है जो विरल नहीं हैं। इसका अर्थ है कि वास्तव में प्रत्येक सूचकांक में सरणी में मूल्य होता है। हालांकि, मुझे पता चला कि प्रथा में मैं शायद ही कभी जावास्क्रिप्ट में विरल सरणियों का उपयोग करता हूं … ऐसे मामलों में यह आमतौर पर किसी वस्तु के नक्शे / हैशटेबल के रूप में उपयोग करने में बहुत आसान होता है यदि आपके पास कोई विरल सरणी है, और 0 पर लूप करना चाहते हैं .. लंबाई -1, आपको (var i = 0; i <someArray.length; ++ i) के लिए निर्माण की आवश्यकता है, लेकिन आपको अभी भी इसकी आवश्यकता है जांचने के लिए कि वर्तमान सूचकांक में तत्व वास्तव में परिभाषित है या नहीं।

इसके अलावा, जैसा कि सीएमएस नीचे एक टिप्पणी में उल्लिखित है, आप इसका उपयोग केवल उन सरणियों पर कर सकते हैं, जिनमें कोई भी गलत मूल्य नहीं है। उदाहरण से स्ट्रिंग्स की सरणी काम करती है, लेकिन यदि आपके पास खाली स्ट्रिंग हैं, या 0 या NaN नंबर आदि हैं, तो लूप समयपूर्व से बंद हो जाएगा। फिर से व्यवहार में यह शायद ही कभी मेरे लिए एक समस्या है, लेकिन यह ध्यान में रखना कुछ है, जो इससे पहले कि आप इसे इस्तेमाल करने से पहले सोचने के लिए एक लूप बनाते हैं … यह कुछ लोगों के लिए इसे अयोग्य ठहराएगा 🙂

इस लूप के बारे में मुझे क्या पसंद है:

  • यह लिखने के लिए कम है
  • लंबाई की संपत्ति का उपयोग करने के लिए (कैश अकेले छोड़ दें) की आवश्यकता नहीं है
  • आपके द्वारा चुने गए नाम के तहत पहुंच के लिए आइटम स्वचालित रूप से लूप बॉडी के भीतर परिभाषित किया गया है।
  • Array.push और array.splice के साथ बहुत स्वाभाविक रूप से संयोजित होता है ताकि सूचियों / स्टैक जैसी सरणियों का उपयोग किया जा सके

The reason this works is that the array specification mandates that when you read an item from an index >= the array's length, it will return undefined. When you write to such a location it will actually update the length.

For me, this construct most closely emulates the Java 5 syntax that I love:

 for (String item : someArray) { } 

… with the added benefit of also knowing about the current index inside the loop

There are a couple of ways to do it in JavaScript. The first two examples are JavaScript samples. The third one makes use of a JavaScript library, that is, jQuery making use of the .each() function.

 var myStringArray = ["hello", "World"]; for(var i in myStringArray) { alert(myStringArray[i]); } 

The most elegant and fast way

 var arr = [1, 2, 3, 1023, 1024]; for (var value; value = arr.pop();) { value + 1 } 

http://jsperf.com/native-loop-performance/8


Edited (because I was wrong)


Comparing methods for looping through an array of 100000 items and do a minimal operation with the new value each time.

Preparation:

 <script src="//code.jquery.com/jquery-2.1.0.min.js"></script> <script src="//cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.js"></script> <script> Benchmark.prototype.setup = function() { // Fake function with minimal action on the value var tmp = 0; var process = function(value) { tmp = value; // Hold a reference to the variable (prevent engine optimisation?) }; // Declare the test Array var arr = []; for (var i = 0; i < 100000; i++) arr[i] = i; }; </script> 

Tests:

 <a href="http://jsperf.com/native-loop-performance/16" title="http://jsperf.com/native-loop-performance/16" ><img src="http://img.hiwab.com/for-loop/YTrO68E.png" title="Hosted by imgur.com" /></a> 

There's a method to iterate over only own object properties, not including prototype's ones:

 for (var i in array) if (array.hasOwnProperty(i)) { // do something with array[i] } 

but it still will iterate over custom-defined properties.

In javascript any custom property could be assigned to any object including array.

If one wants to iterate over sparsed array, for (var i = 0; i < array.length; i++) if (i in array) or array.forEach with es5shim should be used.

In JavaScript, there are so many solutions to loop an array.

The code below are popular ones

 /** Declare inputs */ const items = ['Hello', 'World'] /** Solution 1. Simple for */ console.log('solution 1. simple for') for (let i = 0; i < items.length; i++) { console.log(items[i]) } console.log() console.log() /** Solution 2. Simple while */ console.log('solution 2. simple while') let i = 0 while (i < items.length) { console.log(items[i++]) } console.log() console.log() /** Solution 3. forEach*/ console.log('solution 3. forEach') items.forEach(item => { console.log(item) }) console.log() console.log() /** Solution 4. for-of*/ console.log('solution 4. for-of') for (const item of items) { console.log(item) } console.log() console.log() 

Yes, you can do the same in JavaScript using loop, but not limited to that, many ways to do loop over arrays in JavaScrip, imagine you have this array below and you'd like to do a loop over it:

 var arr = [1, 2, 3, 4, 5]; 

These are the solutions:

1) For loop

For loop is a common way looping through arrays in JavaScript, but no considered as the fastest solutions for large arrays:

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

2) While loop

While loop considered as the fastest way to loop through long arrays, but usually less used in the JavaScript:

 var i=0; while (arr.length>i) { console.log(arr[i]); i++; } 

3) Do while
Do while doing the same thing as while with some syntax difference as below:

 var i=0; do { console.log(arr[i]); i++; } while (arr.length>i); 

These are the main ways to do javascript loops, but there are few more ways to do that.

Also we use for in loop for looping over objects in javascript.

Also look at map() , filter() , reduce() etc functions on Array in JavaScript. They may do things much faster and better than using while and for .

This is good article if you like to learn more about the async functions over arrays in JavaScript.

Functional programming has been making quite a splash in the development world these days. And for good reason: Functional techniques can help you write more declarative code that is easier to understand at a glance, refactor, and test.

One of the cornerstones of functional programming is its special use of lists and list operations. And those things are exactly what the sound like they are: arrays of things, and the stuff you do to them. But the functional mindset treats them a bit differently than you might expect.

This article will take a close look at what I like to call the "big three" list operations: map, filter, and reduce. Wrapping your head around these three functions is an important step towards being able to write clean functional code, and opens the doors to the vastly powerful techniques of functional and reactive programming.

It also means you'll never have to write a for loop again.

Read more>> here :

The optimized approach is to cache the length of array and using single var pattern initializing all variables with single var keyword.

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

If order of iteration does not matter than you should try reversed loop, it is fastest as it reduce overhead condition testing and decrement is in one statement:

 var i,myStringArray = ["item1","item2"]; for (i = myStringArray.length; i--) { alert(myStringArray[i]); } 

or better and cleaner to use while loop:

 var myStringArray = ["item1","item2"],i = myStringArray.length; while(i--) { // do something with fruits[i] } 

The best way in my opinion is to use the Array.forEach function. If you cannot use that I would suggest to get the polyfill from MDN to make i available, it is certainly the safest way to iterate over an array in JavaScript.

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach

So as others has suggested, this is almost always what you want:

 var numbers = [1,11,22,33,44,55,66,77,88,99,111]; var sum = 0; numbers.forEach(function(n){ sum += n; }); 

This ensures that anything you need in the scope of processing the array stays within that scope, and that you are only processing the values of the array, not the object properties and other members, which is what for .. in does.

using a regular c style for loop works in most cases, it is just important to remember that everything within the loop shares it's scope with the rest of your program, the { } does not create a new scope.

Hence:

 var sum = 0; var numbers = [1,11,22,33,44,55,66,77,88,99,111]; for(var i = 0; i<numbers.length; ++i){ sum += numbers[i]; } alert(i); 

will output "11" – which may or may not be what you want.

Working jsFiddle example: https://jsfiddle.net/workingClassHacker/pxpv2dh5/7/

For example, I used in a Firefox console:

 [].forEach.call(document.getElementsByTagName('pre'), function(e){ console.log(e); }) 

Short answer: yes. You can do with this:

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

In a browser console, you can see something like "element1", "element2", etc., printed.

 var x = [4, 5, 6]; for (i = 0, j = x[i]; i < x.length; j = x[++i]) { console.log(i,j); } 

A lot cleaner…

Well, how about this:

 for (var key in myStringArray) { console.log(myStringArray[key]); } 
 var myStringArray = ["hello", "World"]; myStringArray.forEach(function(val, index){ console.log(val, index); }) 

Sure it's inefficient and many despise it, but it's one of the closest to the mentioned:

 var myStringArray = ["Hello","World"]; myStringArray.forEach(function(f){ // Do something }) 
 var obj = ["one","two","three"]; for(x in obj){ console.log(obj[x]); } 

It is better to use a sequential for loop:

 for (var i = 0; i < myStringArray.length; i++) { // Do something }