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

Question

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

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

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

Comments

ठीक है, इसलिए मैं थोड़ा भ्रमित हूं, जब आप वस्तुओं तक पहुंच रहे हैं तो लूप के लिए बढ़ाया का उपयोग करना ठीक है? और एक भरने के लिए एक अनुक्रमिक का उपयोग करें? क्या ये सही है?

— मार्क Szymanski

नहीं, यह वास्तव में सरल है, सरणी वस्तुओं में संख्यात्मक अनुक्रमित होते हैं, इसलिए आप संख्यात्मक क्रम में उन अनुक्रमितों पर पुनरावृति करना चाहते हैं , एक अनुक्रमिक लूप सुनिश्चित करता है कि, बढ़ाया for-in लूप एक विशिष्ट आदेश के बिना, ऑब्जेक्ट गुणों को एन्यूमरेट करता है, और यह विरासत में मिली संपत्तियों की गणना भी करता है। .. सरणियों से अधिक के लिए अनुक्रमिक छोरों की हमेशा सिफारिश की जाती है ...

— CMS

संबंधित - stackoverflow.com/questions/5349425/…

— jondavidjohn

jsben.ch/#/Q9oD5 <= यहां एरेज़ के माध्यम से लूपिंग के लिए समाधानों के एक समूह का एक बेंचमार्क है

— एस्केपनेटस्केप

@ सीएमएस नहीं, यह वास्तव में सरल नहीं है। यह वास्तव में हर दूसरी भाषा में सरल है। यह जेएस में हास्यास्पद रूप से जटिल है, जहां आपके पास है inऔर ofजिसका उपयोग किया जा सकता है और दोनों अलग-अलग काम कर सकते हैं। तो फिर तुम भी है forEachऔर बदसूरत और कष्टप्रद सूचकांक आधारित पाशन। हर दूसरी आधुनिक भाषा संग्रह को सरल और सरल बनाती है, जिसमें कोई आश्चर्य या भ्रम नहीं होता। जेएस, भी सकता है, लेकिन यह नहीं है।

— jpmc26

Answer 1

आपके पास कई विकल्प हैं:

1. अनुक्रमिक forलूप:

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

पेशेवरों

• हर पर्यावरण पर काम करता है
• आप नियंत्रण कथनों का उपयोग breakऔर continueप्रवाह कर सकते हैं

विपक्ष

• बहुत अधिक क्रिया
• अनिवार्य
• आसान करने के लिए बंद-एक करके त्रुटियों (कभी कभी कहा जाता बाड़ पोस्ट त्रुटि )

2. Array.prototype.forEach

ES5 विनिर्देश ने कई लाभदायक सरणी विधियाँ प्रस्तुत कीं, उनमें से एक, Array.prototype.forEachऔर यह हमें एक सरणी पर पुनरावृति करने का संक्षिप्त तरीका देती है:

const array = ["one", "two", "three"]
array.forEach(function (item, index) {
  console.log(item, index);
});

लेखन के समय के रूप में लगभग दस साल होने के नाते कि ईएस 5 विनिर्देश जारी किया गया था (दिसंबर 2009), इसे लगभग सभी आधुनिक इंजनों द्वारा डेस्कटॉप, सर्वर और मोबाइल वातावरण में लागू किया गया है, इसलिए उनका उपयोग करना सुरक्षित है।

और ES6 तीर फ़ंक्शन सिंटैक्स के साथ, यह और भी अधिक संक्षिप्त है:

array.forEach(item => console.log(item));

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

पेशेवरों

• बहुत छोटा और रसीला।
• कथात्मक

विपक्ष

• उपयोग नहीं कर सकते break/continue

आम तौर पर, आप breakउदाहरण के लिए, उन्हें पुनरावृत्त करने से पहले सरणी तत्वों को फ़िल्टर करके अनिवार्य छोरों से बाहर निकलने की आवश्यकता को प्रतिस्थापित कर सकते हैं :

array.filter(item => item.condition < 10)
     .forEach(item => console.log(item))

ध्यान रखें कि यदि आप इसमें से एक और सरणी बनाने के लिए एक सरणी को पुनरावृत्त कर रहे हैं , तो आपको इसका उपयोग करना चाहिए map, मैंने इस विरोधी पैटर्न को कई बार देखा है।

विरोधी पैटर्न:

const numbers = [1,2,3,4,5], doubled = [];

numbers.forEach((n, i) => { doubled[i] = n * 2 });

मानचित्र का उचित उपयोग मामला :

const numbers = [1,2,3,4,5];
const doubled = numbers.map(n => n * 2);

console.log(doubled);

इसके अलावा, यदि आप किसी मान को सरणी को कम करने की कोशिश कर रहे हैं , उदाहरण के लिए, आप संख्याओं की एक राशि का योग करना चाहते हैं, तो आपको कम विधि का उपयोग करना चाहिए ।

विरोधी पैटर्न:

const numbers = [1,2,3,4,5];
const sum = 0;
numbers.forEach(num => { sum += num });

कम उपयोग का उचित उपयोग :

const numbers = [1,2,3,4,5];
const sum = numbers.reduce((total, n) => total + n, 0);

console.log(sum);

3. ईएस 6 for-ofबयान

ईएस 6 मानक चलने योग्य वस्तुओं की अवधारणा का परिचय देता है और डेटा, ट्रैवर्सिंग for...ofकथन के लिए एक नए निर्माण को परिभाषित करता है ।

यह कथन किसी भी प्रकार की चलने वाली वस्तु के लिए और जनरेटर के लिए भी काम करता है (ऐसी कोई भी वस्तु जिसके पास कोई [Symbol.iterator]संपत्ति हो)।

सरणी ऑब्जेक्ट ES6 में अंतर्निहित पुनरावृत्तियों द्वारा होती हैं, इसलिए आप उन पर इस कथन का उपयोग कर सकते हैं:

let colors = ['red', 'green', 'blue'];
for (const color of colors){
    console.log(color);
}

पेशेवरों

• यह वस्तुओं की एक विशाल विविधता पर पुनरावृति कर सकता है।
• सामान्य प्रवाह नियंत्रण बयान ( break/ continue) का उपयोग कर सकते हैं ।
• क्रमिक रूप से अतुल्यकालिक मूल्यों को पुनरावृत्त करने के लिए उपयोगी है।

विपक्ष

• यदि आप पुराने ब्राउज़रों को लक्षित कर रहे हैं, तो ट्रांसप्लैड आउटपुट आपको आश्चर्यचकित कर सकता है ।

प्रयोग नहीं करें for...in

@zipcodeman ने for...inस्टेटमेंट के इस्तेमाल का सुझाव दिया है, लेकिन एररेटिंग एरे for-inसे बचना चाहिए, यह स्टेटमेंट ऑब्जेक्ट प्रॉपर्टीज को एन्यूमरेट करने के लिए है ।

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

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

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

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

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

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

उपरोक्त कोड "a", "b", "c", और "foo!" लॉग करेगा।

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

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...
        console.log("prop: " + prop + " value: " + obj[prop])
    }
}

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

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

• गणना वी.एस.

Comments

यही कारण है (सीएमएस उसे स्वयं के द्वारा) है stackoverflow.com/questions/1885317/...

— OscarRyz

@DoubleGras, मुझे लगता है कि यह एक राय है जो हर किसी के द्वारा साझा नहीं की जाती है। देखें: stackoverflow.com/questions/5752906/… या group.google.com/forum/?fromgroups# .topic

— Matthijs Wessels

किसी को भी आपको लंबाई को कैश करने की आवश्यकता है ... कृपया मेरा उत्तर देखें, आपको इसे एक बार एक्सेस करने की आवश्यकता नहीं है, इसे केवल कैश करने दें: (var i = 0, item; item = myStringArray [i] के लिए; i ++) {/ * यहां आइटम का उपयोग करें * /}

— Stijn de Witt

@StijndeWitt नहीं, क्योंकि है कि टूट जाता है आप किसी भी है, तो "falsey" अपने सरणी में मान: false, undefined, 0, "", NaN।

— फ्रॉग्ज

jsperf.com/caching-array-length/4 यह देखने के लिए एक परीक्षण है कि क्या यह एक जावास्क्रिप्ट लूप में एक सरणी की लंबाई को कैशिंग करने के लायक है

— Enrico

Answer 2

हां, आपके कार्यान्वयन को शामिल करते हुए for... ofECMAScript 2015 ("हार्मनी" रिलीज़) में शुरू की गई सुविधा ... जो इन दिनों एक बहुत ही सुरक्षित धारणा है।

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

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

या फिर अभी तक बेहतर है, क्योंकि ECMAScript 2015 भी ब्लॉक-स्कोप किए गए चर प्रदान करता है:

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

(चर sप्रत्येक पुनरावृत्ति पर भिन्न होता है, लेकिन constलूप बॉडी के अंदर तब भी घोषित किया जा सकता है, जब तक इसे वहां संशोधित नहीं किया जाता है।)

विरल सरणियों पर एक नोट: जावास्क्रिप्ट में एक सरणी वास्तव में इसके द्वारा बताई गई कई वस्तुओं को संग्रहीत नहीं कर सकती है length; उस रिपोर्ट की गई संख्या उस उच्चतम सूचकांक की तुलना में एक अधिक है, जिस पर एक मूल्य संग्रहीत है। यदि सरणी अपनी लंबाई से इंगित की तुलना में कम तत्व रखती है, तो इसके विरल होने के लिए कहा जाता है । उदाहरण के लिए, केवल अनुक्रमित 3, 12 और 247 पर आइटम के साथ एक सरणी होना पूरी तरह से वैध है; इस lengthतरह के एक सरणी 248 के रूप में बताया गया है, हालांकि यह केवल 3 मूल्यों को संग्रहीत कर रहा है। यदि आप किसी अन्य इंडेक्स पर किसी आइटम को एक्सेस करने की कोशिश करते हैं, तो ऐरे को undefinedवहां वैल्यू दिखाई देगी । इसलिए जब आप एक सरणी के माध्यम से "लूप" करना चाहते हैं, तो आपके पास जवाब देने के लिए एक प्रश्न है: क्या आप अपनी लंबाई और प्रक्रिया द्वारा इंगित पूर्ण सीमा पर लूप करना चाहते हैंundefinedकिसी भी लापता तत्वों के लिए, या क्या आप केवल उन तत्वों को संसाधित करना चाहते हैं जो वास्तव में मौजूद हैं? दोनों दृष्टिकोणों के लिए बहुत सारे अनुप्रयोग हैं; यह सिर्फ इस बात पर निर्भर करता है कि आप किस सरणी के लिए उपयोग कर रहे हैं।

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

बेशक, कुछ डेवलपर्स कोई विकल्प नहीं है, बल्कि इसलिए जो भी कारण वे कहते हैं कि अभी तक का समर्थन नहीं करता जावास्क्रिप्ट का एक संस्करण लक्षित कर रहे हैं वैसे भी एक अलग दृष्टिकोण का उपयोग करने के for... of।

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

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

इसके विपरीत for... of, .forEachकेवल उन तत्वों के लिए फ़ंक्शन को कॉल करता है जो वास्तव में सरणी में मौजूद हैं। यदि हमारे काल्पनिक सरणी को तीन तत्वों और 248 की लंबाई के साथ पास किया गया है, तो यह केवल फ़ंक्शन को तीन बार कॉल करेगा, 248 बार नहीं। यह लापता तत्वों और उन तत्वों के बीच भी अंतर करता है जो वास्तव में सेट होते हैं undefined; उत्तरार्द्ध के लिए, यह अभी भी फ़ंक्शन undefinedको तर्क के रूप में पारित करेगा। यदि यह है कि कैसे आप विरल सरणियों हैंडल करना चाहते है, .forEachयहां तक कि अपने दुभाषिया का समर्थन करता है, तो जाने के लिए तरीका हो सकता है for... of।

अंतिम विकल्प, जो जावास्क्रिप्ट के सभी संस्करणों में काम करता है , एक स्पष्ट गणना लूप है । आप बस 0 से एक तक की लंबाई से कम की गिनती करते हैं और एक इंडेक्स के रूप में काउंटर का उपयोग करते हैं। मूल लूप इस तरह दिखता है:

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

इस दृष्टिकोण का एक फायदा यह है कि आप चुन सकते हैं कि विरल सरणियों को कैसे संभालना है; उपरोक्त कोड पाश पूर्ण के शरीर चलेंगे lengthसाथ, कई बार sकरने के लिए सेट undefinedकी तरह किसी भी लापता तत्वों के लिए, for.. of। यदि आप इसके बजाय केवल विरल सरणी के वास्तव में मौजूद तत्वों को संभालना चाहते हैं, जैसे .forEach, आप inसूचकांक पर एक साधारण परीक्षण जोड़ सकते हैं :

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) {

स्पष्ट गणना लूप का मतलब यह भी है कि आपके पास प्रत्येक मूल्य के सूचकांक तक पहुंच है, क्या आपको यह चाहिए। इंडेक्स को उस फ़ंक्शन के अतिरिक्त पैरामीटर के रूप में भी पास किया जाता है जिसे आप पास करते हैं forEach, इसलिए आप इसे इस तरह से भी एक्सेस कर सकते हैं:

myStringArray.forEach( function(s, i) {
   // ... do something with s and i ...
});

for... ofआपको प्रत्येक ऑब्जेक्ट से जुड़ा इंडेक्स नहीं देता है, लेकिन जब तक आप जिस ऑब्जेक्ट को देख रहे हैं, वह वास्तव में एक Array( for.. ofअन्य चलने योग्य प्रकारों के लिए काम करता है, जिसमें यह विधि नहीं हो सकती है), आप ऐरे का उपयोग कर सकते हैं #entries विधि इसे [सूचकांक, आइटम] जोड़े की एक सरणी में बदलने के लिए, और फिर उस पर पुन: व्यवस्थित करें :

for (const [i, s] of myStringArray.entries()) {
  // ... do something with s and i ...
}

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

Comments

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

— फ्रॉग्ज

@ चिह्न-रीड आप कृपया बता सकते हैं कि आपने i in myStringArrayअपने उदाहरण में क्यों इस्तेमाल किया ? वह झूठा कैसे हो सकता है?

— डेनिस वी

@ डेनिसवी: झूठा। a=[1,2,3,4]; delete a[2]; for (j in a) { console.log(j); } आउटपुट 0, 1, 3, और 4. a.lengthअभी भी 5. है

— मार्क रीड ने

मैं सुझाव नहीं दे रहा हूं for j in a। मैं प्रदर्शित कर रहा हूं कि inचेक निरर्थक नहीं है, जैसा कि आपने दावा किया था, सभी अनुक्रमों को दिखाते हुए और यह दर्शाते हुए कि 0 के बीच एक है और length-1वह नहीं है। मैं भी सिर्फ मुद्रित कर सकता था 2 in a, जो वास्तव में है false, इस तथ्य के बावजूद कि आपने कहा कि असंभव था।

— मार्क रीड

@ बृजेशचौहान - सही उदाहरण के लिए, IE 8 संस्करण के माध्यम से इसका समर्थन नहीं करता है। इस प्रश्न को देखें ।

— मार्क रीड

Answer 3

आप उपयोग कर सकते हैं 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;});

और अब x है [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।

Comments

नहीं, लेकिन यह अधिक शक्तिशाली हो सकता है। : इस की जाँच joelonsoftware.com/items/2006/08/01.html

— hasen

इस विशेष उदाहरण का उपयोग करके बेहतर तरीके से लागू किया गया है Array.forEach। mapएक नई सरणी बनाने के लिए है।

— harto

@ पता, Array.prototype.mapविधि ECMAScript 5 वें संस्करण के मानक का हिस्सा है, अभी तक सभी कार्यान्वयनों पर उपलब्ध नहीं है (उदाहरण के लिए IE की कमी), यह भी एक सरणी पर पुनरावृत्ति के लिए मुझे लगता है कि Array.prototype.forEachविधि अधिक शब्दार्थ सही है ... यह भी डॉन डॉन टी फॉर-इन स्टेटमेंट का सुझाव दें, अधिक विवरण के लिए मेरा उत्तर देखें :)

— CMS

के बीच का अंतर forEachऔर mapहै कि पूर्व यात्रा के परिणाम वापस नहीं करता है। map(कभी-कभी उर्फ collect, लेकिन इससे बहुत अलग apply) एक सरणी के प्रत्येक तत्व को संबंधित परिणाम में बदलने के लिए स्पष्ट रूप से है; यह 1-टू -1 मैपिंग है , इसलिए नाम। यह संचालन के पूरे परिवार का हिस्सा है reduceजिसमें शामिल हैं (जो पूरे सरणी से एकल परिणाम उत्पन्न करता है) और filter(जो मूल सरणी का सबसेट पैदा करता है) और इसी तरह। जबकि forEachबस प्रत्येक तत्व के साथ कुछ करता है, शब्दार्थ अनिर्दिष्ट है।

— मार्क रीड

डाउनवोट क्योंकि यदि आप वास्तव में कुछ मैप नहीं कर रहे हैं, तो [] .map का उपयोग करना भ्रामक है। [] .forEach अर्थ संबंधी समझ में आता है और यह भी फ़ंक्शन के लिए तीन तर्क देता है।

— गेंगकेव

Answer 4

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

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

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

Comments

myArray.forEach (फ़ंक्शन (obj) {}); अभी भी सबसे अच्छा है

— जान सेवरे

एक छोटा सुधार: आप ++ii++

— 12ber12

++iएक पुराना स्कूल ऑप्टिमाइज़ेशन है जो आधुनिक संकलक आपके लिए लूप के लिए बहुत समय पहले से करते हैं :) stackoverflow.com/a/1547433/1033348

— ngryman

आपको इस लूप का उपयोग करके सावधान रहना होगा। मैंने इसका उपयोग करना शुरू कर दिया और एक गलती की वजह से बग को ट्रैक करना मुश्किल था। यदि आप इस तरह से दो छोरों को घोंसला देते हैं: jsfiddle.net/KQwmL/1 । आपको दो छोरों में भिन्न रूप से var len का नाम रखने के लिए सावधान रहना होगा, अन्यथा दूसरा लूप पहली लेन को अधिलेखित कर देगा।

— रुई मार्केज

रुई मार्केज़ - आप अपने चर का नाम i_stopया i_endइसके बजाय नाम रख सकते हैं len। यह सिर्फ पठनीय है (यदि ऐसा नहीं है तो!), और आप स्वाभाविक रूप से इस तरह की समस्या से बचेंगे (क्योंकि आपके अन्य लूप मिलेंगे, जैसे, j_stop)।

— चिप होग

Answer 5

के लिए (myStringArray के चलो) {

(सीधे अपने सवाल का जवाब: अब आप कर सकते हैं!)

अधिकांश अन्य उत्तर सही हैं, लेकिन वे उल्लेख नहीं करते हैं (इस लेखन के रूप में) कि ECMA स्क्रिप्ट  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); 
}

वस्तुओं की एक सरणी को बदलना

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 लूप

कल्पना: http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}

Comments

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

— दूंगा

बड़े सरणियों पर मेरे परीक्षणों में, उपयोग var s of arrकरना लगभग दोगुना है (1.9x) एक साधारण काउंटर के लिए लूप का उपयोग करने की तुलना में निष्पादन समय और नोड्ज में सूचकांक द्वारा तत्वों को पुनः प्राप्त करने की तुलना में

— theferrit32

पहली और आखिरी पंक्ति में वह अजीब सामान क्यों?

— पीटर मोर्टेंसन

Answer 6

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

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

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

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

यदि हर सरणी सदस्य परीक्षण पास करता है तो हर रिटर्न सही है।

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

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

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

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

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

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

Comments

परिवर्धन: IE संस्करण 9 से forEach का समर्थन करता है, forEach विधि

— rwitzel

Answer 7

पहचान

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

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

---

एक पारंपरिक- forलूप

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

यह भी ध्यान दें कि हर लूप को लूप के रूप में फिर से लिखा जा सकता है for। उदाहरण के लिए, whileलूप हर्बोव इस -लूप के समान ही व्यवहार करता है 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:

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(), अंडरस्कोर.जे में :

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

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

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

Answer 8

लूप का उपयोग करें ...

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/

Comments

सरणी तत्वों में से कोई भी गलत होने पर "जबकि" वाक्यविन्यास का पहला उदाहरण काम नहीं करेगा।

— क्रिस कूपर

... और यह लूप के बराबर है: के लिए (var i = 0, आइटम; आइटम = आइटम [i]; i ++), जो पहले से सूचकांक और आइटम चर घोषित करने की आवश्यकता को दूर करता है ...

— Stijn de Witt

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

— जहीर अहमद

Answer 9

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

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)) को कैशिंग करने का लाभ है ।

यहां तक ​​कि कई बार जब आप रिवर्स में iterate करने के लिए चाहिए, जैसे कि जब एक लाइव NodeList पर पुनरावृत्ति करते हैं जहां आप चलना के दौरान DOM से आइटम हटाने पर योजना बनाते हैं।

Comments

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

— स्टिजन डे विट

falsish? आपका मतलब है कि गलत है। चलो सभी भ्रम से बचने के लिए उचित शब्दावली को छड़ी करते हैं;)

— danwellman

मैंने देखा है कि जिन लोगों को मैं गुरु मानता हूं, उनके द्वारा गलत शब्द का इस्तेमाल किया जा रहा है। अगर यह उनके लिए काफी अच्छा है तो यह मेरे लिए काफी अच्छा है। इसके अलावा, यह देखकर कि मेरी टिप्पणी वास्तव में ontopic है और स्पष्टीकरण / अंतर्दृष्टि जोड़ता है 0 अपवोट हो जाता है, लेकिन यह देखकर निराश हूं, लेकिन मेरी टिप्पणी में एक शब्द पर नाइटपिक्स हो जाता है 4. मुझे लगता है कि प्राथमिकताओं का एक मामला है।

— स्टिजेन डे विट

"लंबाई कैशिंग"? लंबाई को सरणी में पूर्णांक के रूप में संग्रहीत किया जाता है, यह हर बार जब आप इसे एक्सेस करते हैं तो इसे मापा नहीं जाता है। लंबाई का मान दूसरे चर में कॉपी करने में यहाँ कोई लाभ नहीं है।

— मौसमी

@ मौसमी इन दिनों वहाँ निश्चित रूप से नहीं है; पिछले वर्षों में जावास्क्रिप्ट सरणियों को जावास्क्रिप्ट पक्ष पर कैशिंग की लंबाई (बजाय कार्यान्वयन तक पहुँचने के बजाय) एक स्पष्ट पूर्ण लाभ (जब microoptimizing) था। उदाहरण के लिए, for (var i=0,len=array.length;i<len;++i)लिखने के लिए एक सामान्य, समझदार लूप था।

— मेंढक

Answer 10

जावास्क्रिप्ट में कार्यात्मक प्रोग्रामिंग तरीके से एक सरणी के माध्यम से लूपिंग के कुछ मामलों का उपयोग करें :

1. बस एक सरणी के माध्यम से लूप

const myArray = [{x:100}, {x:200}, {x:300}];

myArray.forEach((element, index, array) => {
    console.log(element.x); // 100, 200, 300
    console.log(index); // 0, 1, 2
    console.log(array); // same myArray object 3 times
});

नोट: Array.prototyp.forEach () कड़ाई से बोलने का एक कार्यात्मक तरीका नहीं है, क्योंकि इनपुट पैरामीटर के रूप में इसे लेने वाले फ़ंक्शन को मान वापस करने के लिए नहीं माना जाता है, जिसे इस प्रकार शुद्ध फ़ंक्शन के रूप में नहीं माना जा सकता है।

2. जांचें कि क्या सरणी में कोई भी तत्व एक परीक्षा पास करता है

const people = [
    {name: 'John', age: 23}, 
    {name: 'Andrew', age: 3}, 
    {name: 'Peter', age: 8}, 
    {name: 'Hanna', age: 14}, 
    {name: 'Adam', age: 37}];

const anyAdult = people.some(person => person.age >= 18);
console.log(anyAdult); // true

3. एक नई सरणी में बदलना

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => element.x);
console.log(newArray); // [100, 200, 300]

नोट: मानचित्र () विधि कॉलिंग एरे में प्रत्येक तत्व पर दिए गए फ़ंक्शन को कॉल करने के परिणामों के साथ एक नया सरणी बनाता है।

4. एक विशेष संपत्ति को जोड़ो, और इसकी औसत गणना करें

const myArray = [{x:100}, {x:200}, {x:300}];

const sum = myArray.map(element => element.x).reduce((a, b) => a + b, 0);
console.log(sum); // 600 = 0 + 100 + 200 + 300

const average = sum / myArray.length;
console.log(average); // 200

5. मूल के आधार पर एक नया सरणी बनाएं लेकिन इसे संशोधित किए बिना

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => {
    return {
        ...element,
        x: element.x * 2
    };
});

console.log(myArray); // [100, 200, 300]
console.log(newArray); // [200, 400, 600]

6. प्रत्येक श्रेणी की संख्या गिनें

const people = [
    {name: 'John', group: 'A'}, 
    {name: 'Andrew', group: 'C'}, 
    {name: 'Peter', group: 'A'}, 
    {name: 'James', group: 'B'}, 
    {name: 'Hanna', group: 'A'}, 
    {name: 'Adam', group: 'B'}];

const groupInfo = people.reduce((groups, person) => {
    const {A = 0, B = 0, C = 0} = groups;
    if (person.group === 'A') {
        return {...groups, A: A + 1};
    } else if (person.group === 'B') {
        return {...groups, B: B + 1};
    } else {
        return {...groups, C: C + 1};
    }
}, {});

console.log(groupInfo); // {A: 3, C: 1, B: 2}

7. विशेष मापदंड के आधार पर एक सरणी के सबसेट को पुनः प्राप्त करें

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray = myArray.filter(element => element.x > 250);
console.log(newArray); // [{x:300}] 

नोट: फ़िल्टर () विधि सभी तत्वों के साथ एक नया सरणी बनाता है जो प्रदान किए गए फ़ंक्शन द्वारा कार्यान्वित परीक्षण को पास करता है।

8. एक क्रमबद्ध करें

const people = [
  { name: "John", age: 21 },
  { name: "Peter", age: 31 },
  { name: "Andrew", age: 29 },
  { name: "Thomas", age: 25 }
];

let sortByAge = people.sort(function (p1, p2) {
  return p1.age - p2.age;
});

console.log(sortByAge);

9. एक सरणी में एक तत्व का पता लगाएं

const people = [ {name: "john", age:23},
                {name: "john", age:43},
                {name: "jim", age:101},
                {name: "bob", age:67} ];

const john = people.find(person => person.name === 'john');
console.log(john);

Array.prototyp.find () विधि सरणी में पहले तत्व का मान लौटाता है जो प्रदान किए गए परीक्षण फ़ंक्शन को संतुष्ट करता है।

संदर्भ

• Array.prototype.some ()
• Array.prototype.forEach ()
• Array.prototype.map ()
• Array.prototype.filter ()
• Array.prototype.sort ()
• फैला हुआ वाक्यविन्यास
• Array.prototype.find ()

Answer 11

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

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और पर अन्य तरीकों के एक मेजबान सरणी प्रोटोटाइप ।

Comments

ध्यान दें कि कुछ दुभाषियों (जैसे V8) को स्वचालित रूप से सरणी की लंबाई कैश होगी यदि कोड को पर्याप्त बार कहा जाता है और यह पता लगाता है कि लंबाई लूप द्वारा संशोधित नहीं है।

— फ्रॉग्ज

@Phrogz की जानकारी के लिए धन्यवाद, यह सच है कि बहुत सारी अनुकूलन है जो VM कर सकता है, लेकिन चूंकि पुराने ब्राउज़रों के पास यह नहीं है, इसलिए यह सस्ता होने के बाद भी इसके लिए अनुकूलन करने का सबसे अच्छा अभ्यास होगा।

— गेब्रियल

@ गैब्रिएल: क्यों? कृपया वास्तविक दुनिया के उदाहरण दें, जो यह बताती है कि लंबाई को कैशिंग नहीं करना वास्तव में एक प्रदर्शन अड़चन है। मैं 'समयपूर्व अनुकूलन सभी बुराई की जड़ है' दृष्टिकोण का पालन करता हूं। मैं उस एक लूप को ठीक करूंगा जो वास्तव में एक समस्या है जो एक बार मेरे सामने आती है ...

— Stijn de Witt

@StijndeWitt imo यह सिर्फ एक शैलीगत मुद्दा है। ईमानदारी से, मैं अब इन चीजों को करने के लिए _.each, _.map आदि चीजों के लिए अंडरस्कोर पर निर्भर होने के बजाय छोरों के लिए भी उपयोग नहीं करता हूं। जब मैंने इस तरह लूप लिखा था तो मैंने लंबाई को मुख्य रूप से कैश किया ताकि मेरे सभी चर घोषणा एक जगह पर हो, मेरे फ़ंक्शन के शीर्ष पर। इस संबंध में मेरी सलाह के बाद किसी भी वास्तविक दुनिया के आवेदन के लिए अनुपयुक्त है। समयपूर्व अनुकूलन सुपर खराब है, लेकिन अगर अनुकूलन शैलीगत निर्णयों के परिणामस्वरूप होता है तो मुझे नहीं लगता कि यह वास्तव में मायने रखता है।

— गेब्रियल

@ गैब्रिएल मेरा मानना ​​है कि जावास्क्रिप्ट पहले से ही सरणियों पर मानचित्र फ़ंक्शन का समर्थन करता है, इसके लिए अतिरिक्त परिवाद पेश करने की आवश्यकता नहीं है।

— Noz

Answer 12

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

सामान्य लूप:

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

ES5 का अग्र भाग:

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 का उपयोग कर सकते हैं ।

Answer 13

मैं पूरी तरह से अंडरस्कोर । जेएस लाइब्रेरी के उपयोग की सिफारिश करूंगा । यह आपको विभिन्न कार्य प्रदान करता है जिनका उपयोग आप सरणियों / संग्रहों पर पुनरावृति करने के लिए कर सकते हैं।

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

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

Comments

इस प्रश्न के नए खोजकर्ताओं के लिए, मैं सिर्फ अंडर- कॉन के आध्यात्मिक उत्तराधिकारी लो-डैश को इंगित करना चाहूंगा, जो इस पर कई तरह से सुधार करता है।

— मार्क रीड

underscoreयदि ECMA-262 को forEachमेथोर में जोड़ा गया है तो क्यों उपयोग करें । देशी कोड हमेशा बेहतर होता है।

— वाल्टर चापिलिकेन - wZVanG

Answer 14

ऐरे लूप:

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

Answer 15

हां , आप एक लूप का उपयोग करके जावास्क्रिप्ट में ही कर सकते हैं, लेकिन यह सीमित नहीं है, जावास्क्रिप्ट में ऐरे पर लूप करने के कई तरीके हैं। कल्पना करें कि आपके पास यह सरणी नीचे है, और आप इस पर एक लूप करना चाहते हैं:

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

ये हैं उपाय:

1) लूप के लिए

एक forलूप जावास्क्रिप्ट में सरणियों के माध्यम से एक आम तरीका है, लेकिन बड़े सरणियों के लिए सबसे तेज़ समाधान के रूप में नहीं माना जाता है:

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

2) जबकि लूप

एक समय में लूप को लंबी सरणियों के माध्यम से लूप का सबसे तेज़ तरीका माना जाता है, लेकिन आमतौर पर इसका उपयोग जावास्क्रिप्ट कोड में कम किया जाता है:

let i=0;

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

3)
एक do whileही काम कर रहा है जबकिwhile नीचे के रूप में कुछ वाक्यविन्यास अंतर के साथ है:

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

जावास्क्रिप्ट लूप करने के ये मुख्य तरीके हैं, लेकिन ऐसा करने के कुछ और तरीके हैं।

इसके अलावा, हम for inजावास्क्रिप्ट में वस्तुओं पर लूपिंग के लिए एक लूप का उपयोग करते हैं ।

इसके अलावा देखो map(), filter(), reduce()जावास्क्रिप्ट में एक सरणी पर, आदि कार्य करता है। वे चीजों को उपयोग करने की तुलना में बहुत तेज और बेहतर कर सकते हैं whileऔरfor ।

यह एक अच्छा लेख है यदि आप जावास्क्रिप्ट में सरणियों पर अतुल्यकालिक कार्यों के बारे में अधिक जानना चाहते हैं।

फंक्शनल प्रोग्रामिंग इन दिनों विकास की दुनिया में काफी धूम मचा रही है। और अच्छे कारण के लिए: कार्यात्मक तकनीकें आपको अधिक घोषणात्मक कोड लिखने में मदद कर सकती हैं जो एक नज़र में समझने में आसान है, रिफ्लेक्टर, और परीक्षण।

कार्यात्मक प्रोग्रामिंग के कोनेस्टोन में से एक इसका उपयोग सूचियों और सूची संचालन का विशेष उपयोग है। और वे चीजें ठीक वैसी ही हैं जैसी ध्वनि वे हैं: चीजों की सरणियाँ, और सामान जो आप उन्हें करते हैं। लेकिन कार्यात्मक मानसिकता उन्हें थोड़ा अलग तरीके से व्यवहार करती है जितना आप उम्मीद कर सकते हैं।

यह आलेख "बड़े तीन" सूची संचालन को कॉल करने के लिए मुझे पसंद करता है: मानचित्र, फ़िल्टर और कम करें। इन तीन कार्यों के चारों ओर अपना सिर लपेटना स्वच्छ कार्यात्मक कोड लिखने में सक्षम होने की दिशा में एक महत्वपूर्ण कदम है, और कार्यात्मक और प्रतिक्रियाशील प्रोग्रामिंग की विशाल शक्तिशाली तकनीकों के लिए दरवाजे खोलता है।

इसका मतलब यह भी है कि आपको फिर से लूप के लिए लिखना नहीं पड़ेगा।

और पढ़ें >> यहाँ :

Comments

क्या लूप के लिए वास्तव में एक प्रदर्शन अंतर है और एक सरणी के माध्यम से पुनरावृत्ति करते समय लूप के लिए एक अंतर है? मैं इस धारणा के तहत था कि मतभेद मुख्य रूप से वाक्यात्मक थे

— शी

Answer 16

यदि कोई ऐरे पुनरावृत्तियों के लिए उपलब्ध कई तंत्रों के प्रदर्शन पक्ष में रुचि रखता है, तो मैंने निम्नलिखित JSPerf परीक्षण तैयार किए हैं:

https://jsperf.com/fastest-array-iterator

परिणाम:

पारंपरिक for()पुनरावृत्ति, अब तक की सबसे तेज़ विधि है, विशेष रूप से तब इस्तेमाल की जाती है, जब सरणी लंबाई को कैश किया जाता है ।

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

for(let i=0, size=arr.length; i<size; i++){
    // Do something
}

द Array.prototype.forEach()और दArray.prototype.map() तरीकों धीमी अनुमानों, शायद का एक परिणाम के रूप में कर रहे हैं समारोह कॉल उपरि ।

Comments

के i = i +1बजाय बेहतर उपयोग हैi++

— DarckBlezzer

सुधार किया जा सकता है: कृपया उपयोग करें: i ++ के बजाय ++ मैं, यह एक अस्थायी वस्तु से बचना होगा। तो यह मेमोरी उपयोग और सीपीयू समय (कोई आवंटन की आवश्यकता नहीं) को कम करता है!

— पावरस्टैट

@PowerStat आप उस बारे में एक लिंक या संदर्भ प्रदान कर सकते हैं? मैंने इसके बारे में कभी नहीं सोचा है, दिलचस्प लगता है ...

— कोलोक्सी

@colxi ऐसी रोचक बातों के लिए आपको हर्ब सटर और स्कॉट मेयर्स के हार्डकोर सी ++ सामान को पढ़ना चाहिए। ++ i vs i ++ चीज़ किताब से है: असाधारण C ++: 47 इंजीनियरिंग पहेलियाँ, प्रोग्रामिंग समस्याएं, और समाधान - मुझे लगता है कि आप इसे gotw.ca पर भी पा सकते हैं, लेकिन हर प्रोग्रामिंग भाषा के लिए साबित हो सकता है।

— पावरस्टैट

Answer 17

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

प्रलेखन से:

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

वापसी: वस्तु

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

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

Comments

सब कुछ के लिए jQuery?

— अपवाद

अपवाद से सहमत। अतिरिक्त निर्भरता के प्रभाव को कम मत समझो। मैं इसके खिलाफ ऐसे कोड के बारे में सलाह दूंगा जो पहले से ही jQuery का उपयोग कर रहा है।

— स्टिजेन डे विट

अद्यतन: इन दिनों, आप Array.forEach का उपयोग देशी सरणियों के साथ समान प्रभाव प्राप्त करने के लिए कर सकते हैं ।

— स्टिजन डे विट

Answer 18

मैंने अभी तक इस भिन्नता को नहीं देखा है, जो मुझे व्यक्तिगत रूप से सबसे अच्छा लगता है:

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

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

इस JsFiddle को प्रदर्शित करते हुए देखें कि: http://jsfiddle.net/prvzk/

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

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

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

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

इसका कारण यह है कि सरणी विनिर्देशन यह बताता है कि जब आप किसी आइटम को इंडेक्स = = सरणी की लंबाई से पढ़ते हैं, तो यह अपरिभाषित वापस आ जाएगा। जब आप ऐसे स्थान पर लिखते हैं तो यह वास्तव में लंबाई को अपडेट करेगा।

मेरे लिए, यह सबसे ज्यादा बारीकी से जावा 5 सिंटैक्स का अनुकरण करता है जो मुझे पसंद है:

for (String item : someArray) {
}

... लूप के अंदर मौजूदा सूचकांक के बारे में जानने के अतिरिक्त लाभ के साथ

Comments

ध्यान दें कि इस दृष्टिकोण के साथ लूप बंद हो जाएगा जैसे ही यह एक गलत मूल्य पाता है , जैसे कि एक खाली स्ट्रिंग 0,false , NaN, nullया undefined, पहले भी iपहुँच लंबाई, जैसे: jsfiddle.net/prvzk/1

— सीएमएस

पाश की स्थिति हो सकती है (item=someArray[i]) !== undefined।

— daniel1426

Answer 19

केवल स्वयं के ऑब्जेक्ट गुणों पर पुनरावृति करने का एक तरीका है, जिसमें प्रोटोटाइप शामिल नहीं हैं:

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

लेकिन यह अभी भी कस्टम-परिभाषित गुणों पर आधारित होगा।

जावास्क्रिप्ट में किसी भी कस्टम संपत्ति को किसी भी ऑब्जेक्ट को सौंपा जा सकता है, जिसमें एक सरणी भी शामिल है।

एक पुनरावृति से अधिक sparsed सरणी के लिए चाहता है, for (var i = 0; i < array.length; i++) if (i in array)या array.forEachके साथ es5shimकिया जाना चाहिए।

Comments

और कैसे उपयोग के बारे में for (var i in array) if (++i)?

— डैनियल सोकोलोस्की

Answer 20

इसे जावास्क्रिप्ट में करने के कुछ तरीके हैं। पहले दो उदाहरण जावास्क्रिप्ट नमूने हैं। तीसरा एक जावास्क्रिप्ट लाइब्रेरी का उपयोग करता है, अर्थात्, jQuery .each()फ़ंक्शन का उपयोग करता है।

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

var myStringArray = ["hello", "World"];
for (var i=0; i < myStringArray.length; i++) {
  alert(myStringArray[i]);
}

var myStringArray = ["hello", "World"];
$.each(myStringArray, function(index, value){
  alert(value);
})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

Comments

for...inऐरे जैसी वस्तुओं के लिए बचा जाना चाहिए

— brk

Answer 21

सबसे सुंदर और तेज़ तरीका

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

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

---

संपादित (क्योंकि मैं गलत था)

---

100000 मदों की एक सरणी के माध्यम से पाशन के लिए तरीकों की तुलना करना और हर बार नए मूल्य के साथ एक न्यूनतम संचालन करना।

• http://jsben.ch/#/BQhED

तैयारी:

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

टेस्ट:

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

Comments

यह लूप सरणी में आइटम के आदेश का पालन नहीं करता है।

— डेनिज़ ओज़गर

मेरी परीक्षा गलत थी। यह सही है, अब सभी LOOPS दिखा रहा है। jsperf.com/native-loop-performance/16

— मोलोकोलोको

@bergi सही है। यह लूप सरणी मिटा देता है क्योंकि यह इसके माध्यम से छोरों। अधिकांश मामलों में नहीं जो आप चाहते हैं।

— स्टिजन डे विट

फालसी वस्तुओं पर टूट जाता है।

— njzk2

Answer 22

अनुकूलित दृष्टिकोण सरणी की लंबाई को कैश करना है और सिंगल वेरिएबल के साथ सभी वेरिएबल्स को इनिशियलाइज़ करते हुए सिंगल वेरिएंट पैटर्न का उपयोग करना है।

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

यदि पुनरावृत्ति के आदेश से कोई फर्क नहीं पड़ता है, तो आपको उल्टे लूप की कोशिश करनी चाहिए, यह सबसे तेज़ है क्योंकि यह ओवरहेड स्थिति परीक्षण को कम करता है और एक बयान में गिरावट होती है:

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

या बेहतर और क्लीनर लूप का उपयोग करने के लिए:

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

Answer 23

जावास्क्रिप्ट में, ऐरे को लूप करने के लिए बहुत सारे समाधान हैं।

नीचे दिए गए कोड लोकप्रिय हैं

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

Answer 24

यदि आप jQuery का उपयोग करना चाहते हैं, तो इसके प्रलेखन में एक अच्छा उदाहरण है:

 $.each([ 52, 97 ], function( index, value ) {
      alert( index + ": " + value );
 });

Answer 25

मेरी राय में सबसे अच्छा तरीका Array.forEach फ़ंक्शन का उपयोग करना है। यदि आप इसका उपयोग नहीं कर सकते हैं तो मैं एमडीएन से पॉलीफिल प्राप्त करने का सुझाव दूंगा। इसे उपलब्ध करने के लिए, यह निश्चित रूप से जावास्क्रिप्ट में एक सरणी पर पुनरावृति करने का सबसे सुरक्षित तरीका है।

Array.prototype.forEach ()

इसलिए जैसा कि दूसरों ने सुझाव दिया है, यह लगभग हमेशा वही होता है जो आप चाहते हैं:

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

यह सुनिश्चित करता है कि जिस चीज की आपको प्रोसेसिंग की जरूरत है, वह उस दायरे में रहती है, और यह कि आप केवल सरणी के मूल्यों को प्रोसेस कर रहे हैं, न कि ऑब्जेक्ट प्रॉपर्टीज और अन्य सदस्यों को, जो कि है for .. करता है।

एक नियमित सी-शैली का उपयोग करना forज्यादातर मामलों में लूप काम करता है। यह याद रखना महत्वपूर्ण है कि लूप के भीतर सब कुछ अपने कार्यक्रम के बाकी हिस्सों के साथ अपना दायरा साझा करता है, {} एक नया दायरा नहीं बनाता है।

इसलिये:

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

आउटपुट "11" - जो आप चाहते हैं या नहीं हो सकता है।

एक कार्यशील jsFiddle उदाहरण: https://jsfiddle.net/workingClassHacker/pxpv2dh5/7/

Answer 26

यह 100% समान नहीं है, लेकिन समान है:

   var myStringArray = ['Hello', 'World']; // array uses [] not {}
    for (var i in myStringArray) {
        console.log(i + ' -> ' + myStringArray[i]); // i is the index/key, not the item
    }

Comments

ऐसा लगता है कि यह एक सरणी वस्तु के साथ उपयोग के लिए अन्य समस्याओं के समान है, जिसमें प्रोटोटाइप सदस्य चर भी साथ ही साथ पकड़ा जाएगा।

— कजकाई

Answer 27

उदाहरण के लिए, मैंने फ़ायरफ़ॉक्स कंसोल में इस्तेमाल किया:

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

Answer 28

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

बहुत सारा क्लीनर ...

Comments

की तुलना में यह बहुत साफ नहीं है z.forEach(j => console.log(j));।

— नीलमणि

Answer 29

संक्षिप्त उत्तर: हाँ। आप इसके साथ कर सकते हैं:

var myArray = ["element1", "element2", "element3", "element4"];

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

एक ब्राउज़र कंसोल में, आप "एलिमेंट 1", "एलिमेंट 2", आदि जैसे कुछ देख सकते हैं, मुद्रित।

Answer 30

आप या तो उपयोग कर सकते हैं Array.prototype.forEach(...):

var arr = ["apple", "banana", "cherry", "mango"];
arr.forEach((item, index)=>{
   //Some code...
});

या Array.prototype.map(...):

var arr = ["apple", "banana", "cherry", "mango"];
arr.map((item, index)=>{
   //Some code...
});

या पहले से उल्लिखित जॉकरी या लूप के तरीकों के लिए।