क्यों एक बुरा विचार सरणी सरणी के साथ "के लिए" का उपयोग कर रहा है?

Question

मुझे for...inजावास्क्रिप्ट में सरणियों के साथ उपयोग नहीं करने के लिए कहा गया है । क्यों नहीं?

Comments

मैंने हाल का प्रश्न देखा, जहां किसी ने आपसे कहा था, लेकिन वे केवल एरे के लिए थे। यह सरणियों के माध्यम से पुनरावृत्ति करने के लिए बुरा व्यवहार माना जाता है, लेकिन जरूरी नहीं कि किसी वस्तु के सदस्यों के माध्यम से पुनरावृत्ति हो।

— एमचर्च

"के लिए" के साथ उत्तर के बहुत सारे 'जैसे' के लिए '(var i = 0; मैं <hColl.length; i ++) {}' 'var i = hColl.length की तुलना में; जबकि (i--) {} 'जो, बाद के रूप का उपयोग करना संभव होने पर यह काफी तेजी से होता है। मुझे पता है कि यह मूर्त है लेकिन मुझे लगता है कि मैं इसे थोड़ा जोड़ूंगा।

— मार्क शुल्त्स

@MarkSchultheiss लेकिन यह उल्टा चलना है। क्या आगे चलने का एक और संस्करण है जो तेज है?

— ma11hew28

@Wynand var i = hCol1.length; for (i;i;i--;) {}मैं कैश का उपयोग करें क्योंकि यह एक फर्क पड़ेगा, और परीक्षण को सरल करेगा। - पुराने ब्राउज़र, और अधिक के बीच अंतर forऔर whileहमेशा "मैं" काउंटर कैश - और निश्चित रूप से नकारात्मक स्थिति में फिट नहीं है, और obfuscate कुछ लोगों के लिए कोड थोड़ा जबकि नकारात्मक । और ध्यान दें var i = 1000; for (i; i; i--) {}और var b =1000 for (b; b--;) {}जहां मैं 1000 से 1 जाता है और बी 999 से 0. तक चला जाता है - पुराने ब्राउज़र जितना अधिक होता है, उतना ही प्रदर्शन के पक्ष में जाता है।

— मार्क शुल्त्स

आप चतुर भी हो सकते हैं। for(var i = 0, l = myArray.length; i < l; ++i) ...सबसे तेज़ और सबसे अच्छा आप आगे की यात्रा के साथ प्राप्त कर सकते हैं।

— मैथ्यू एमियोट

Answer 1

कारण यह है कि एक निर्माण:

var a = []; // Create a new empty array.
a[5] = 5;   // Perfectly legal JavaScript that resizes the array.

for (var i = 0; i < a.length; i++) {
    // Iterate over numeric indexes from 0 to 5, as everyone expects.
    console.log(a[i]);
}

/* Will display:
   undefined
   undefined
   undefined
   undefined
   undefined
   5
*/

कभी-कभी दूसरे से बिलकुल अलग हो सकते हैं:

var a = [];
a[5] = 5;
for (var x in a) {
    // Shows only the explicitly set index of "5", and ignores 0-4
    console.log(x);
}

/* Will display:
   5
*/

यह भी विचार करें कि जावास्क्रिप्ट लाइब्रेरी इस तरह की चीजें कर सकती हैं, जो आपके द्वारा बनाई गई किसी भी सरणी को प्रभावित करेगी:

// Somewhere deep in your JavaScript library...
Array.prototype.foo = 1;

// Now you have no idea what the below code will do.
var a = [1, 2, 3, 4, 5];
for (var x in a){
    // Now foo is a part of EVERY array and 
    // will show up here as a value of 'x'.
    console.log(x);
}

/* Will display:
   0
   1
   2
   3
   4
   foo
*/

Comments

ऐतिहासिक रूप से, कुछ ब्राउज़रों ने 'लंबाई','स्ट्रिंग 'आदि पर भी ध्यान दिया!

— बोबिन्स

(var x in a)इसके बजाय उपयोग करने के लिए याद रखें (x in a)- एक वैश्विक बनाना नहीं चाहते हैं।

— क्रिस मॉर्गन

पहला मुद्दा यह एक कारण नहीं है कि यह बुरा है, केवल शब्दार्थ में अंतर है। दूसरा मुद्दा मुझे एक कारण लगता है (ऐसा करने वाले पुस्तकालयों के बीच झड़पों के शीर्ष पर) जो कि एक निर्मित डेटाटाइप के प्रोटोटाइप को बदलना बुरा है, बजाय इसके कि.in. बुरा है।

— स्टीवर्ट

@Stewart: JS में सभी ऑब्जेक्ट एसोसिएटिव हैं। एक जेएस सरणी एक वस्तु है, इसलिए हां, यह साहचर्य भी है, लेकिन यह ऐसा नहीं है। यदि आप किसी ऑब्जेक्ट की कुंजियों पर चलना चाहते हैं , तो उपयोग करें for (var key in object)। यदि आप किसी सरणी के तत्वों पर पुनरावृति करना चाहते हैं , तो उपयोग करें for(var i = 0; i < array.length; i += 1)।

— मार्टिज़न

आपने पहले उदाहरण के लिए कहा, कि यह 0 से 4 तक संख्यात्मक सूचकांक पर Iterates है, जैसा कि सभी को उम्मीद है , मैं इसे 0 से 5 तक पुनरावृति करने की उम्मीद करता हूं ! चूंकि यदि आप स्थिति 5 में एक तत्व जोड़ते हैं, तो सरणी में 6 तत्व (उनमें से 5 अपरिभाषित) होंगे।

— स्टिव्लो

Answer 2

for-inबयान अपने आप में लेकिन यह हो सकता है, एक "बुरा व्यवहार" नहीं है का उपयोग गलत है , उदाहरण के लिए, करने के लिए पुनरावृति सरणियों या वस्तुओं सरणी की तरह खत्म हो गया।

के प्रयोजन के for-inबयान करने के लिए है की गणना वस्तु गुण अधिक। यह कथन प्रोटोटाइप श्रृंखला में ऊपर जाएगा, विरासत में मिली संपत्तियों की गणना भी , एक ऐसी चीज जो कभी-कभी वांछित नहीं होती है।

इसके अलावा, पुनरावृत्ति के क्रम की गारंटी युक्ति द्वारा नहीं दी गई है। इसका अर्थ है कि यदि आप एक सरणी ऑब्जेक्ट को "पुनरावृति" करना चाहते हैं, तो इस कथन के साथ आप यह सुनिश्चित नहीं कर सकते हैं कि गुण (सरणी अनुक्रमित) संख्यात्मक क्रम में जाएंगे।

उदाहरण के लिए, JScript (IE <= 8) में, एरे वस्तुओं पर भी गणना का क्रम परिभाषित किया गया है क्योंकि गुण बनाए गए थे:

var array = [];
array[2] = 'c';
array[1] = 'b';
array[0] = 'a';

for (var p in array) {
  //... p will be "2", "1" and "0" on IE
}

इसके अलावा, विरासत में मिली संपत्तियों के बारे में बोलते हुए, यदि आप, उदाहरण के लिए, Array.prototypeवस्तु का विस्तार करें (जैसे कुछ लाइब्रेरी MooTools करते हैं), तो उन गुणों की गणना भी की जाएगी:

Array.prototype.last = function () { return this[this.length-1]; };

for (var p in []) { // an empty array
  // last will be enumerated
}

जैसा कि मैंने सरणियों या सरणी जैसी वस्तुओं पर पुनरावृति करने से पहले कहा था , सबसे अच्छी बात एक क्रमिक लूप का उपयोग करना है , जैसे कि एक सादे-पुराने for/ whileलूप।

जब आप किसी वस्तु के केवल स्वयं के गुणों की गणना करना चाहते हैं (जो कि विरासत में नहीं हैं), तो आप hasOwnPropertyविधि का उपयोग कर सकते हैं :

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) {
    // prop is not inherited
  }
}

और कुछ लोग Object.prototypeसमस्या को टालने के लिए सीधे तरीके से कॉल करने की सलाह देते हैं यदि कोई व्यक्ति hasOwnPropertyहमारी वस्तु में कोई संपत्ति जोड़ता है :

for (var prop in obj) {
  if (Object.prototype.hasOwnProperty.call(obj, prop)) {
    // prop is not inherited
  }
}

Comments

जावास्क्रिप्ट में ऑब्जेक्ट्स पर डेविड हम्फ्रे की पोस्ट को जल्दी से देखें - सरणी के लिए for..in"सामान्य" छोरों की तुलना में बहुत धीमी है।

— क्रिस मॉर्गन

"HasOwnProperty" के बारे में अंतिम बिंदु के बारे में प्रश्न: यदि कोई ऑब्जेक्ट पर "hasOwnProperty" ओवरराइड करता है, तो आपको समस्या होगी। लेकिन अगर आपको किसी को "Object.prototype.hasOwnProperty" ओवरराइड करने में कोई समस्या नहीं होगी? किसी भी तरह से वे आप पर शिकंजा कस रहे हैं और यह आपकी जिम्मेदारी नहीं है?

— स्कॉट रिपी

आप कहते हैं for..inकि यह बुरा अभ्यास नहीं है, लेकिन इसका दुरुपयोग किया जा सकता है। क्या आपको अच्छे अभ्यास का वास्तविक दुनिया उदाहरण मिला है, जहां आप वास्तव में विरासत में मिली संपत्ति सहित सभी वस्तुओं के गुणों से गुजरना चाहते हैं?

— rjmunro

@ScottRippey: अगर आप इसे वहां ले जाना चाहते हैं: youtube.com/watch?v=FrFUI591WhI

— Nathan Wall

इस जवाब के साथ मैंने पाया कि साथ मूल्य तक पहुँच सकते हैंfor (var p in array) { array[p]; }

— equiman

Answer 3

for..inसरणी तत्वों पर पुनरावृति के लिए उपयोग नहीं करने के तीन कारण हैं:

• for..inसरणी वस्तु के सभी और विरासत में मिले गुणों पर लूप करेंगे जो कि नहीं हैं DontEnum; इसका मतलब है कि अगर कोई व्यक्ति विशिष्ट सरणी ऑब्जेक्ट में गुण जोड़ता है (इसके लिए वैध कारण हैं - मैंने खुद ऐसा किया है) या बदल दिया गया है Array.prototype(जिसे कोड में बुरा अभ्यास माना जाता है जिसे अन्य लिपियों के साथ अच्छी तरह से काम करना चाहिए), ये गुण होंगे के रूप में अच्छी तरह से iterated; विरासत में मिली संपत्तियों को जाँच के द्वारा बाहर रखा जा सकता है hasOwnProperty(), लेकिन यह आपको सरणी ऑब्जेक्ट में सेट गुणों के साथ मदद नहीं करेगा

• for..in तत्व आदेश को संरक्षित करने की गारंटी नहीं है

• यह धीमा है क्योंकि आपको सरणी ऑब्जेक्ट और इसकी संपूर्ण प्रोटोटाइप श्रृंखला के सभी गुणों को चलना होगा और अभी भी केवल संपत्ति का नाम प्राप्त करना होगा, अर्थात मूल्य प्राप्त करने के लिए, एक अतिरिक्त लुकअप की आवश्यकता होगी

Answer 4

क्योंकि ... उस ऑब्जेक्ट के माध्यम से एन्यूमरेट करता है जो एरे को पकड़ता है, न कि एरे को। यदि मैं सरणियों प्रोटोटाइप श्रृंखला में एक फ़ंक्शन जोड़ता हूं, तो वह भी शामिल होगा। अर्थात

Array.prototype.myOwnFunction = function() { alert(this); }
a = new Array();
a[0] = 'foo';
a[1] = 'bar';
for(x in a){
 document.write(x + ' = ' + a[x]);
}

यह लिखेगा:

0 = फू
1 = बार
myOwnFunction = function () {अलर्ट (यह); }

और चूँकि आप कभी भी यह सुनिश्चित नहीं कर सकते हैं कि कुछ भी नहीं होगा प्रोटोटाइप श्रृंखला में सिर्फ सरणी को एन्यूमरेट करने के लिए लूप के लिए उपयोग करें:

for(i=0,x=a.length;i<x;i++){
 document.write(i + ' = ' + a[i]);
}

यह लिखेगा:

0 = फू
1 = बार

Comments

सरणी हैं वस्तुओं, वहाँ कोई "उद्देश्य यह है कि सरणी रखती है।"

— रॉबिन

Answer 5

अलगाव में, सरणियों पर फॉर-इन का उपयोग करने में कुछ भी गलत नहीं है। किसी ऑब्जेक्ट के गुण नामों पर पुनरावृत्तियों के लिए, और "आउट-ऑफ-द-बॉक्स" सरणी के मामले में, गुण सरणी अनुक्रमित से मेल खाते हैं। (अंतर्निर्मित समरूपताएं length, toStringऔर इसी तरह पुनरावृत्ति में शामिल नहीं हैं।)

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

कुछ JS चौखटे, जैसे प्रोटोटाइप Array प्रोटोटाइप को संशोधित करता है। JQuery जैसे अन्य फ्रेमवर्क नहीं हैं, इसलिए JQuery के साथ आप सुरक्षित रूप से फॉर-इन का उपयोग कर सकते हैं।

यदि आप संदेह में हैं, तो आपको संभवतः फॉर-इन का उपयोग नहीं करना चाहिए।

एक सरणी के माध्यम से पुनरावृत्ति का एक वैकल्पिक तरीका फॉर-लूप का उपयोग कर रहा है:

for (var ix=0;ix<arr.length;ix++) alert(ix);

हालाँकि, यह एक अलग मुद्दा है। मुद्दा यह है कि एक जावास्क्रिप्ट सरणी में "छेद" हो सकते हैं। यदि आप इस arrरूप में परिभाषित करते हैं:

var arr = ["hello"];
arr[100] = "goodbye";

फिर सरणी में दो आइटम हैं, लेकिन 101 की लंबाई है। फॉर-इन का उपयोग करने से दो अनुक्रमित होंगे, जबकि फॉर-लूप में 101 इंडेक्स होंगे, जहां 99 का मान है undefined।

Answer 6

2016 के रूप में (ईएस 6) हम for…ofसरणी पुनरावृत्ति के लिए उपयोग कर सकते हैं , जैसा कि जॉन सेलर्स ने पहले ही देखा था।

मैं इस सरल प्रदर्शन कोड को जोड़ना चाहूंगा, ताकि चीजें स्पष्ट हो सकें:

Array.prototype.foo = 1;
var arr = [];
arr[5] = "xyz";

console.log("for...of:");
var count = 0;
for (var item of arr) {
    console.log(count + ":", item);
    count++;
    }

console.log("for...in:");
count = 0;
for (var item in arr) {
    console.log(count + ":", item);
    count++;
    }

कंसोल दिखाता है:

for...of:

0: undefined
1: undefined
2: undefined
3: undefined
4: undefined
5: xyz

for...in:

0: 5
1: foo

दूसरे शब्दों में:

• for...of0 से 5 तक गिना जाता है, और यह भी अनदेखा करता है Array.prototype.foo। यह सरणी मान दिखाता है ।

• for...inकेवल 5अपरिभाषित सरणी सूचियों को अनदेखा करते हुए सूचीबद्ध करता है, लेकिन जोड़ रहा है foo। यह एरे प्रॉपर्टी के नाम दिखाता है ।

Answer 7

संक्षिप्त उत्तर: यह सिर्फ इसके लायक नहीं है।

---

लंबे समय तक जवाब: यह सिर्फ इसके लायक नहीं है, भले ही अनुक्रमिक तत्व आदेश और इष्टतम प्रदर्शन की आवश्यकता न हो।

---

लंबे उत्तर: यह सिर्फ इसके लायक नहीं है ...

• उपयोग करने से एक वस्तु के रूप में पुनरावृत्त होने का for (var property in array)कारण होगा , वस्तु प्रोटोटाइप श्रृंखला को पार करना और अंत में सूचकांक आधारित लूप की तुलना में धीमी गति से प्रदर्शन करना ।arrayfor
• for (... in ...) अनुक्रमिक क्रम में वस्तु गुणों को वापस करने की गारंटी नहीं है, जैसा कि कोई उम्मीद कर सकता है।
• ऑब्जेक्ट गुणों को फ़िल्टर करने के लिए उपयोग करना hasOwnProperty()और !isNaN()जांचना एक अतिरिक्त ओवरहेड है, जिससे यह और भी धीमा हो जाता है और इसे पहले संक्षिप्त रूप में उपयोग करने के लिए महत्वपूर्ण कारण को नकारता है, अर्थात अधिक संक्षिप्त प्रारूप के कारण।

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

Answer 8

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

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

for (var i=0; i<a.length; i++) {
    document.write(i + ', ' + typeof i + ', ' + i+1);
}

लिखेंगे

0, number, 1
1, number, 2
...

जहाँ तक,

for (var ii in a) {
    document.write(i + ', ' + typeof i + ', ' + i+1);
}

लिखेंगे

0, string, 01
1, string, 11
...

बेशक, इसे आसानी से शामिल करके दूर किया जा सकता है

ii = parseInt(ii);

लूप में, लेकिन पहली संरचना अधिक प्रत्यक्ष है।

Comments

आप उपसर्ग उपयोग कर सकते हैं +के बजाय parseIntजब तक आप वास्तव में पूर्णांक की जरूरत है या उपेक्षा अमान्य वर्ण।

— कोनराड बोरोस्की

इसके अलावा, उपयोग करने parseInt()की अनुशंसा नहीं की जाती है। कोशिश करो parseInt("025");और यह विफल हो जाएगा ।

— डेरेक 會 會

@ डेरेक 會 朕 you - आप निश्चित रूप से उपयोग कर सकते हैं parseInt। समस्या यह है कि यदि आप मूलांक को शामिल नहीं करते हैं, तो पुराने ब्राउज़र संख्या की व्याख्या करने का प्रयास कर सकते हैं (इस प्रकार 025 अष्टक हो जाता है)। यह ईसीएमएस्क्रिप्ट 5 में तय किया गया था लेकिन यह अभी भी "0x" से शुरू होने वाली संख्याओं के लिए होता है (यह संख्या को हेक्स के रूप में व्याख्या करता है)। सुरक्षित पक्ष पर होने के लिए, संख्या निर्दिष्ट करने के लिए मूलांक का उपयोग करें parseInt("025", 10)- जैसे कि आधार 10. निर्दिष्ट करता है

— IAmTimCorey

Answer 9

इस तथ्य के अलावा कि for... inसभी असंख्य गुणों (जो "सभी सरणी तत्वों" के समान नहीं है!) पर दिखाई देता है, http://www.ecma-international.org/publications/files/ECMA-ST/Ecma देखें -262.pdf , खंड 12.6.4 (5 वां संस्करण) या 13.7.5.15 (7 वां संस्करण):

यांत्रिकी और गुणों की गणना के आदेश ... निर्दिष्ट नहीं है ...

(जोर मेरा)

इसका मतलब है कि यदि कोई ब्राउज़र चाहता था, तो यह उस गुण के माध्यम से जा सकता है जिस क्रम में उन्हें डाला गया था। या संख्यात्मक क्रम में। या लेक्सिकल ऑर्डर में (जहां "4" से पहले "30" आता है! सभी ऑब्जेक्ट कुंजियों को ध्यान में रखें - और इस प्रकार, सभी ऐरे इंडेक्स - वास्तव में तार हैं, ताकि कुल समझ में आता है)। यह उनके द्वारा बाल्टी के माध्यम से जा सकता है, अगर यह वस्तुओं को हैश टेबल के रूप में लागू करता है। या उस में से कोई भी ले लो और "पीछे की ओर" जोड़ें। एक ब्राउज़र भी बेतरतीब ढंग से पुनरावृति कर सकता है और ईसीएमए -262 के अनुरूप हो सकता है, जब तक कि यह प्रत्येक संपत्ति का एक बार दौरा किया हो।

व्यवहार में, अधिकांश ब्राउज़र वर्तमान में लगभग उसी क्रम में पुनरावृति करना पसंद करते हैं। लेकिन वहाँ कुछ भी नहीं कह रहा है कि वे करने के लिए है। यह विशिष्ट कार्यान्वयन है, और यदि किसी अन्य तरीके से कहीं अधिक कुशल पाया गया तो किसी भी समय बदल सकता है।

किसी भी तरह से, for... inइसके साथ आदेश का कोई अर्थ नहीं है। यदि आप ऑर्डर के बारे में परवाह करते हैं, तो इसके बारे में स्पष्ट रहें और forसूचकांक के साथ एक नियमित लूप का उपयोग करें ।

Answer 10

मुख्य रूप से दो कारण:

एक

जैसे अन्य लोगों ने कहा है, आपको कुंजी मिल सकती है जो आपके सरणी में नहीं हैं या जो कि प्रोटोटाइप से विरासत में मिली हैं। तो अगर, हम कहते हैं, एक पुस्तकालय ऐरे या ऑब्जेक्ट प्रोटोटाइप में एक संपत्ति जोड़ता है:

Array.prototype.someProperty = true

आप इसे हर ऐरे के हिस्से के रूप में प्राप्त करेंगे:

for(var item in [1,2,3]){
  console.log(item) // will log 1,2,3 but also "someProperty"
}

आप इसे hasOwnProperty विधि से हल कर सकते हैं:

var ary = [1,2,3];
for(var item in ary){
   if(ary.hasOwnProperty(item)){
      console.log(item) // will log only 1,2,3
   }
}

लेकिन यह फॉर-इन लूप के साथ किसी भी ऑब्जेक्ट पर पुनरावृत्ति करने के लिए सही है।

दो

आमतौर पर किसी सरणी में वस्तुओं का क्रम महत्वपूर्ण होता है, लेकिन फॉर-लूप सही क्रम में जरूरी नहीं होगा, ऐसा इसलिए है क्योंकि यह सरणी को एक वस्तु के रूप में मानता है, जिस तरह से इसे जेएस में लागू किया जाता है, और नहीं एक सरणी के रूप में। यह एक छोटी सी बात की तरह लगता है, लेकिन यह वास्तव में अनुप्रयोगों को खराब कर सकता है और डीबग करना कठिन है।

Comments

Object.keys(a).forEach( function(item) { console.log(item) } )स्वयं की संपत्ति कुंजियों की एक सरणी पर पुनरावृति, न कि प्रोटोटाइप से विरासत में मिली।

— क्वर्टी

सच है, लेकिन फॉर-लूप की तरह, यह जरूरी नहीं कि सही सूचकांक क्रम में हो। इसके अलावा, यह पुराने ब्राउज़रों पर काम नहीं करेगा जो ईएस 5 का समर्थन नहीं करते हैं।

— लाइर

आप array.forEachअपनी स्क्रिप्ट में कुछ कोड डालकर उन ब्राउज़रों को सिखा सकते हैं। Polyfill developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— Qwerty

बेशक, लेकिन फिर आप प्रोटोटाइप में हेरफेर कर रहे हैं, और यह हमेशा एक अच्छा विचार नहीं है ... और फिर भी, आपके पास ऑर्डर का मुद्दा है ...

— लाइर

और, ज़ाहिर है, कारण संख्या तीन: विरल सरणियाँ।

— एक बेहतर ऑलिव जूल

Answer 11

क्योंकि यह वस्तु क्षेत्रों के माध्यम से गणना करता है, सूचकांक नहीं। आप सूचकांक "लंबाई" के साथ मूल्य प्राप्त कर सकते हैं और मुझे संदेह है कि आप यह चाहते हैं।

Comments

तो ऐसा करने का सबसे अच्छा तरीका क्या है?

— lYriCAlsSH

के लिए (var i = 0; i <arr.length; i ++) {}

— vava

Firefox 3 में आप या तो arr.forEach या (var (i, v) Iterator (arr)) {} के लिए उपयोग कर सकते हैं, लेकिन IE में उन दोनों में से कोई भी काम नहीं करता है, हालाँकि आप खुद forEach विधि लिख सकते हैं।

— vava

और वस्तुतः प्रत्येक पुस्तकालय के पास इसके लिए स्वयं की विधि भी है।

— vava

यह उत्तर गलत है। "लीनथ" को फॉर-इट इटरेशन में शामिल नहीं किया जाएगा। यह केवल गुण है जो आप खुद को जोड़ते हैं जो शामिल है।

— जैक्सबी 10

Answer 12

मुझे नहीं लगता कि मेरे पास उदाहरण के लिए बहुत कुछ है। कुछ मामलों में उपयोग करने से क्यों बचना चाहिए, इस पर ट्रिप्टाइक का जवाब या सीएमएस का जवाबfor...in ।

हालांकि, मैं यह जोड़ना चाहूंगा कि आधुनिक ब्राउज़रों में इसका एक विकल्प है for...inकि उन मामलों में इसका उपयोग किया जा सकता है जहां for...inइसका उपयोग नहीं किया जा सकता है। वह विकल्प है for...of:

for (var item of items) {
    console.log(item);
}

---

ध्यान दें :

दुर्भाग्य से, इंटरनेट एक्सप्लोरर का कोई संस्करण समर्थन नहीं करता है for...of( एज 12+ करता है), इसलिए आपको थोड़ी देर इंतजार करना होगा जब तक कि आप इसे अपने क्लाइंट साइड प्रोडक्शन कोड में उपयोग नहीं कर सकते। हालाँकि, आपके सर्वर साइड JS कोड में उपयोग करना सुरक्षित होना चाहिए (यदि आप Node.js का उपयोग करते हैं )।

Comments

@georgeawg आपका मतलब था for-of, नहीं for-in?

— 2: ᆼ '

Answer 13

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

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

Comments

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

— NiCk Newman

@NiCkNewman अच्छी तरह से वस्तु आप के बाद का संदर्भ inएक में for ... inपाश सिर्फ होगा

— नुकीले

समझा। बस उत्सुक हूं क्योंकि मेरे मुख्य गेम ऑब्जेक्ट के अंदर ऑब्जेक्ट्स और सरणियां हैं और सोच रहा था कि अगर इनिंग के लिए और अधिक दर्दनाक होगा तो बस इंडेक्स पर लूप के लिए एक नियमित।

— NiCk न्यूमैन

@NiCkNewman अच्छी तरह से इस पूरे प्रश्न का विषय है कि आपको केवल for ... inसरणियों पर उपयोग नहीं करना चाहिए ; नहीं करने के लिए कई अच्छे कारण हैं। यह "प्रदर्शन सुनिश्चित नहीं करता है कि यह टूटता नहीं है" समस्या के रूप में इतना प्रदर्शन मुद्दा नहीं है।

— प्वाईंट

ठीक है, मेरी वस्तुओं को तकनीकी रूप से एक सरणी में संग्रहीत किया जाता है, इसीलिए मैं चिंतित था, जैसे कुछ: [{a:'hey',b:'hi'},{a:'hey',b:'hi'}]लेकिन, हाँ, मैं समझता हूँ।

— नीके न्यूमैन

Answer 14

साथ ही, शब्दार्थ के कारण, for, inसरणियों का व्यवहार करता है (अर्थात किसी अन्य जावास्क्रिप्ट वस्तु के समान) अन्य लोकप्रिय भाषाओं के साथ गठबंधन नहीं किया जाता है।

// C#
char[] a = new char[] {'A', 'B', 'C'};
foreach (char x in a) System.Console.Write(x); //Output: "ABC"

// Java
char[] a = {'A', 'B', 'C'};
for (char x : a) System.out.print(x);          //Output: "ABC"

// PHP
$a = array('A', 'B', 'C');
foreach ($a as $x) echo $x;                    //Output: "ABC"

// JavaScript
var a = ['A', 'B', 'C'];
for (var x in a) document.write(x);            //Output: "012"

Answer 15

TL और DR:for in सरणियों में लूप का उपयोग करना बुराई नहीं है, वास्तव में काफी विपरीत है।

मुझे लगता है कि for inलूप जेएस का एक मणि है यदि सही तरीके से सरणियों में उपयोग किया जाता है । आपसे अपेक्षा की जाती है कि आप अपने सॉफ़्टवेयर पर पूर्ण नियंत्रण रखें और जानें कि आप क्या कर रहे हैं। आइए, उल्लेखित कमियां देखें और एक-एक करके उनका निर्वहन करें।

1. यह विरासत में मिली संपत्तियों से भी गुजरता है: सबसे पहले किसी भी एक्सटेंशन का Array.prototypeउपयोग करके किया जाना चाहिए Object.defineProperty()और उनके enumerableविवरणकर्ता को सेट किया जाना चाहिए false। ऐसा नहीं करने वाले किसी भी पुस्तकालय का उपयोग बिल्कुल नहीं किया जाना चाहिए।
2. गुण जिन्हें आप वंशानुक्रम श्रृंखला में जोड़ते हैं, बाद में गिने जाते हैं: जब Object.setPrototypeOfवर्ग या वर्ग द्वारा उप-श्रेणीकरण करते हैं extend। आपको फिर से उपयोग करना चाहिए Object.defineProperty()जो डिफ़ॉल्ट रूप से सेट करता है writable, enumerableऔर configurableसंपत्ति के विवरणकर्ता को false। यहाँ एक सरणी उप-वर्गीय उदाहरण देखें ...

function Stack(...a){
  var stack = new Array(...a);
  Object.setPrototypeOf(stack, Stack.prototype);
  return stack;
}
Stack.prototype = Object.create(Array.prototype);                                 // now stack has full access to array methods.
Object.defineProperty(Stack.prototype,"constructor",{value:Stack});               // now Stack is a proper constructor
Object.defineProperty(Stack.prototype,"peak",{value: function(){                  // add Stack "only" methods to the Stack.prototype.
                                                       return this[this.length-1];
                                                     }
                                             });
var s = new Stack(1,2,3,4,1);
console.log(s.peak());
s[s.length] = 7;
console.log("length:",s.length);
s.push(42);
console.log(JSON.stringify(s));
console.log("length:",s.length);

for(var i in s) console.log(s[i]);

इसलिए आप देखते हैं कि for inलूप अब सुरक्षित है क्योंकि आपने अपने कोड की परवाह की है।

3. for in: पाश धीमी है कोई नरक। यदि आप समय-समय पर विरल सरणियों पर लूपिंग कर रहे हैं, तो यह अब तक का सबसे तेज़ तरीका है। यह सबसे महत्वपूर्ण प्रदर्शन ट्रिक्स में से एक है जिसे किसी को पता होना चाहिए। एक उदाहरण देखते हैं। हम एक विरल सरणी पर लूप करेंगे।

var a = [];
a[0] = "zero";
a[10000000] = "ten million";
console.time("for loop on array a:");
for(var i=0; i < a.length; i++) a[i] && console.log(a[i]);
console.timeEnd("for loop on array a:");
console.time("for in loop on array a:");
for(var i in a) a[i] && console.log(a[i]);
console.timeEnd("for in loop on array a:");

Comments

@ रवि शंकर रेड्डी ने अच्छा बेंचमार्किंग सेट किया। जैसा कि मैंने अपने उत्तर में उल्लेख किया है कि for inलूप दूसरों को "यदि" सरणी विरल है और अधिक है अगर यह आकार में बड़ा हो जाता है। इसलिए मैंने एक विरल सरणी के लिए बेंच टेस्ट को फिर से व्यवस्थित किया है arr, आकार ~ 10000 के साथ केवल 50 आइटम [42,"test",{t:1},null, void 0]यादृच्छिक रूप से यादृच्छिक रूप से चुने गए । आप तुरंत अंतर को नोटिस करेंगे। - >> इसे यहां देखें << - ।

— रेडू

Answer 16

अन्य समस्याओं के अलावा, "for..in" सिंटैक्स शायद धीमा है, क्योंकि सूचकांक एक स्ट्रिंग है, एक पूर्णांक नहीं।

var a = ["a"]
for (var i in a)
    alert(typeof i)  // 'string'
for (var i = 0; i < a.length; i++)
    alert(typeof i)  // 'number'

Comments

शायद एक बहुत कुछ मायने नहीं रखता। एरे तत्व एरे-आधारित या एरे-जैसे ऑब्जेक्ट के गुण हैं, और सभी ऑब्जेक्ट गुणों में स्ट्रिंग कुंजियाँ हैं। जब तक आपका JS इंजन किसी तरह से इसका अनुकूलन नहीं करता है, भले ही आपने नंबर का उपयोग किया हो, यह अंत में लुकअप के लिए स्ट्रिंग में बदल जाएगा।

— cHao

किसी भी प्रदर्शन के मुद्दों के बावजूद, यदि आप जावास्क्रिप्ट में नए हैं, तो var i in aइंडेक्स का पूर्णांक होने का उपयोग करें और अपेक्षा करें, तो ऐसा कुछ करना a[i+offset] = <value>पूरी तरह से गलत स्थानों में मान डाल देगा। ("1" + 1 == "11")।

— szmoore

Answer 17

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

एक गुण गुण के गुण की जांच कर सकता है:

myobject.propertyIsEnumerable('myproperty')

या सभी चार गुण प्राप्त करने के लिए:

Object.getOwnPropertyDescriptor(myobject,'myproperty')

यह ईसीएमएस्क्रिप्ट 5 में उपलब्ध एक विशेषता है - पहले के संस्करणों में यह संभव नहीं था कि यह नाममात्र संपत्ति विशेषता के मूल्य में परिवर्तन करे (यह हमेशा सच था)।

Answer 18

for/ inHashtables (साहचर्य सरणियों) और सरणी (गैर साहचर्य): चर के दो प्रकार के साथ काम करता है।

जावास्क्रिप्ट स्वचालित रूप से आइटम के माध्यम से इसके गुजरने के तरीके को निर्धारित करेगा। इसलिए यदि आप जानते हैं कि आपका सरणी वास्तव में गैर-सहयोगी है जिसका आप उपयोग कर सकते हैं for (var i=0; i<=arrayLen; i++), और ऑटो-डिटेक्शन पुनरावृत्ति को छोड़ सकते हैं ।

लेकिन मेरी राय में, इसका उपयोग करना बेहतर है for/ in, उस ऑटो-डिटेक्शन के लिए आवश्यक प्रक्रिया बहुत छोटी है।

इसके लिए एक वास्तविक उत्तर यह निर्भर करेगा कि ब्राउज़र पार्सर्स जावास्क्रिप्ट कोड की व्याख्या / व्याख्या कैसे करता है। यह ब्राउज़रों के बीच बदल सकता है।

मैं for/ का उपयोग नहीं करने के अन्य उद्देश्यों के बारे में नहीं सोच सकता in;

//Non-associative
var arr = ['a', 'b', 'c'];
for (var i in arr)
   alert(arr[i]);

//Associative
var arr = {
   item1 : 'a',
   item2 : 'b',
   item3 : 'c'
};

for (var i in arr)
   alert(arr[i]);

Comments

सच है, जब तक आप प्रोटोटाइप ऑब्जेक्ट्स का उपयोग नहीं कर रहे हैं। ;) नीचे

— रिकार्डो

क्योंकि Arrayयह Objectभी है

— नि: शुल्क परामर्श

for ... inवस्तुओं के साथ काम करता है। ऑटो-डिटेक्शन जैसी कोई चीज नहीं है।

— एक बेहतर ऑलिव जूल

Answer 19

क्योंकि यह प्रोटोटाइप श्रृंखला की वस्तुओं से संबंधित गुणों पर पुनरावृति करेगा यदि आप सावधान नहीं हैं।

आप उपयोग कर सकते हैं for.. in, बस प्रत्येक संपत्ति को hasOwnProperty के साथ जांचना सुनिश्चित करें ।

Comments

पर्याप्त नहीं है - सरणी उदाहरणों में मनमाने ढंग से नामित गुणों को जोड़ना पूरी तरह से ठीक है, और वे चेक trueसे परीक्षण करेंगे hasOwnProperty()।

— नुकीले

अच्छी बात है, धन्यवाद। मैं मूर्खतापूर्ण रूप से ऐसा करने के लिए पर्याप्त नहीं था, इसलिए मैंने ऐसा नहीं माना!

— JAL

@ मैं यह परीक्षण नहीं किया है, लेकिन शायद यह isNaNप्रत्येक संपत्ति के नाम पर एक चेक का उपयोग करके दूर किया जा सकता है ।

— WynandB

@Wynand दिलचस्प विचार; हालाँकि, मैं वास्तव में यह नहीं देखता कि एक साधारण संख्यात्मक सूचकांक के साथ पुनरावृत्ति करना कितना मुश्किल है क्योंकि यह इतना आसान है।

— पॉइन्टी

@WynandB टक्कर के लिए खेद है, लेकिन मुझे लगता है कि एक सुधार क्रम में है: isNaNयह जाँचने के लिए है कि एक चर विशेष मान NaN है या नहीं, इसका उपयोग 'संख्याओं के अलावा अन्य चीजों' के लिए जाँच करने के लिए नहीं किया जा सकता है (आप एक नियमित रूप से जा सकते हैं इसके लिए टाइपोफ़)।

— doldt

Answer 20

यह आवश्यक रूप से बुरा नहीं है (जो आप कर रहे हैं उसके आधार पर), लेकिन सरणियों के मामले में, अगर कुछ जोड़ा गया है Array.prototype, तो आप अजीब परिणाम प्राप्त करने जा रहे हैं। जहाँ आप इस लूप को तीन बार चलाने की उम्मीद करेंगे:

var arr = ['a','b','c'];
for (var key in arr) { ... }

एक समारोह में कहा जाता है, तो helpfulUtilityMethodमें जोड़ दिया गया Arrayहै prototype, तो अपने पाश में चार बार चल खत्म होगा: keyहोगा 0, 1, 2, और helpfulUtilityMethod। यदि आप केवल पूर्णांकों की अपेक्षा कर रहे थे, उफ़।

Answer 21

आपको for(var x in y)केवल संपत्ति सूचियों का उपयोग करना चाहिए , वस्तुओं पर नहीं (जैसा कि ऊपर बताया गया है)।

Comments

एसओ के बारे में बस एक नोट - कोई 'ऊपर' नहीं है क्योंकि टिप्पणियां हर समय पृष्ठ पर आदेश बदलती हैं। इसलिए, हम वास्तव में नहीं जानते हैं कि आप किस टिप्पणी का मतलब है। इस कारण से "x व्यक्ति की टिप्पणी" कहना अच्छा है।

— JAL

@ जाल ... या उत्तर के लिए पर्मलिंक जोड़ें।

— WynandB

Answer 22

for...inकिसी सरणी के लिए लूप का उपयोग करना गलत नहीं है, हालांकि मैं अनुमान लगा सकता हूं कि किसी ने आपको क्यों बताया:

1.) पहले से ही एक उच्च क्रम फ़ंक्शन, या विधि है, जिसमें एक सरणी के लिए वह उद्देश्य है, लेकिन अधिक कार्यक्षमता और झुकाव सिंटैक्स है, जिसे 'forEach' कहा जाता है: Array.prototype.forEach(function(element, index, array) {} );

2.) सरणी हमेशा लंबाई है, लेकिन for...inऔर forEachवह यह है कि किसी भी मूल्य के लिए एक समारोह निष्पादित नहीं 'undefined', केवल अनुक्रमणिका परिभाषित एक मूल्य है कि के लिए। इसलिए यदि आप केवल एक मान प्रदान करते हैं, तो ये लूप केवल एक बार किसी फ़ंक्शन को निष्पादित करेंगे, लेकिन चूंकि एक सरणी को एन्यूमरेट किया गया है, यह हमेशा उच्चतम सूचकांक तक एक लंबाई होगी जिसमें एक परिभाषित मूल्य होता है, लेकिन इन का उपयोग करते समय उस लंबाई को किसी का ध्यान नहीं जा सकता है छोरों।

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

संक्षेप में, आप किसी भी लूप का उपयोग कर सकते हैं, लेकिन आपको यह याद रखना चाहिए कि वे कैसे काम करते हैं। उन स्थितियों को समझें जिन पर अलग-अलग छोरों को दोहराया जाता है, उनकी अलग-अलग कार्यक्षमताएं होती हैं, और महसूस होता है कि वे अलग-अलग परिदृश्यों के लिए कम या ज्यादा उपयुक्त होंगे।

इसके अलावा, सामान्य रूप forEachसे for...inलूप की तुलना में विधि का उपयोग करने के लिए यह एक बेहतर अभ्यास माना जा सकता है , क्योंकि यह लिखना आसान है और अधिक कार्यक्षमता है, इसलिए आप केवल इस विधि और मानक का उपयोग करने की आदत में पड़ सकते हैं, लेकिन आपके कहते हैं।

नीचे देखें कि पहले दो लूप केवल कंसोल.लॉग स्टेटमेंट को एक बार निष्पादित करते हैं, जबकि लूप के लिए मानक इस मामले में फ़ंक्शन को कई बार निष्पादित करता है, इस मामले में, array.length = 6।

var arr = [];
arr[5] = 'F';

for (var index in arr) {
console.log(index);
console.log(arr[index]);
console.log(arr)
}
// 5
// 'F'
// => (6) [undefined x 5, 6]

arr.forEach(function(element, index, arr) {
console.log(index);
console.log(element);
console.log(arr);
});
// 5
// 'F'
// => Array (6) [undefined x 5, 6]

for (var index = 0; index < arr.length; index++) {
console.log(index);
console.log(arr[index]);
console.log(arr);
};
// 0
// undefined
// => Array (6) [undefined x 5, 6]

// 1
// undefined
// => Array (6) [undefined x 5, 6]

// 2
// undefined
// => Array (6) [undefined x 5, 6]

// 3
// undefined
// => Array (6) [undefined x 5, 6]

// 4
// undefined
// => Array (6) [undefined x 5, 6]

// 5
// 'F'
// => Array (6) [undefined x 5, 6]

Answer 23

यहाँ कारण हैं कि यह (आमतौर पर) एक बुरा अभ्यास क्यों है:

1. for...inसभी अपने स्वयं के असंख्य गुणों और उनके प्रोटोटाइप (एस) के असंख्य गुणों पर पुनरावृति करता है । आमतौर पर एक सरणी पुनरावृत्ति में हम केवल सरणी पर पुनरावृति करना चाहते हैं। और भले ही आप अपने आप को सरणी में कुछ भी नहीं जोड़ सकते हैं, आपके पुस्तकालयों या ढांचे में कुछ जोड़ सकते हैं।

उदाहरण :

Array.prototype.hithere = 'hithere';

var array = [1, 2, 3];
for (let el in array){
    // the hithere property will also be iterated over
    console.log(el);
}

2. for...inलूप विशिष्ट पुनरावृत्ति क्रम की गारंटी नहीं देते हैं । हालांकि ऑर्डर इन दिनों आमतौर पर अधिकांश आधुनिक ब्राउज़रों में देखा जाता है, फिर भी 100% गारंटी नहीं है।
3. for...inलूप undefinedसरणी तत्वों को अनदेखा करते हैं, अर्थात सरणी तत्व जो अभी तक असाइन नहीं किए गए हैं।

उदाहरण :

const arr = []; 
arr[3] = 'foo';   // resize the array to 4
arr[4] = undefined; // add another element with value undefined to it

// iterate over the array, a for loop does show the undefined elements
for (let i = 0; i < arr.length; i++) {
    console.log(arr[i]);
}

console.log('\n');

// for in does ignore the undefined elements
for (let el in arr) {
    console.log(arr[el]);
}

Answer 24

के लिए ... जावास्क्रिप्ट में किसी ऑब्जेक्ट पर काम करते समय उपयोगी है, लेकिन एक ऐरे के लिए नहीं, लेकिन फिर भी हम यह नहीं कह सकते कि यह एक गलत तरीका है, लेकिन यह अनुशंसित नहीं है, लूप में उपयोग करने के लिए नीचे दिए गए इस उदाहरण को देखें :

let txt = "";
const person = {fname:"Alireza", lname:"Dezfoolian", age:35}; 
for (const x in person) {
    txt += person[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 

ठीक है, चलो अब एरे के साथ करते हैं:

let txt = "";
const person = ["Alireza", "Dezfoolian", 35]; 
for (const x in person) {
   txt += person[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 

जैसा कि आप परिणाम को देखते हैं ...

लेकिन चलो कुछ करने की कोशिश करते हैं, चलो कुछ ऐरे के लिए प्रोटोटाइप ...

Array.prototype.someoneelse = "someoneelse";

अब हम एक नया ऐरे () बनाते हैं;

let txt = "";
const arr = new Array();
arr[0] = 'Alireza';
arr[1] = 'Dezfoolian';
arr[2] = 35;
for(x in arr) {
 txt += arr[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 someoneelse

तुम देखो someoneelse !!! ... हम वास्तव में इस मामले में नई सरणी वस्तु के माध्यम से पाशन!

तो इसका एक कारण है कि हमें सावधानीपूर्वक ..in का उपयोग करने की आवश्यकता है , लेकिन यह हमेशा ऐसा नहीं होता है ...

Answer 25

एक के लिए ... पाश में हमेशा चाबियाँ enumerates। ऑब्जेक्ट गुण कुंजियाँ हमेशा स्ट्रिंग होती हैं, यहां तक ​​कि किसी सरणी के अनुक्रमित गुण:

var myArray = ['a', 'b', 'c', 'd'];
var total = 0
for (elem in myArray) {
  total += elem
}
console.log(total); // 00123

Answer 26

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

से https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections

Answer 27

हालाँकि इस प्रश्न को विशेष रूप से संबोधित नहीं किया गया है, लेकिन मैं यह जोड़ना चाहूँगा कि कभी भी उपयोग न करने का एक बहुत अच्छा कारण है ... एक के NodeListरूप में (एक querySelectorAllकॉल से प्राप्त होगा , क्योंकि यह बदले हुए तत्वों को बिल्कुल नहीं देखता है, बजाय केवल NodeList संपत्तियों पर पुनरावृत्ति।

एक परिणाम के मामले में, मुझे मिला:

var nodes = document.querySelectorAll(selector);
nodes
▶ NodeList [a._19eb]
for (node in nodes) {console.log(node)};
VM505:1 0
VM505:1 length
VM505:1 item
VM505:1 entries
VM505:1 forEach
VM505:1 keys
VM505:1 values

जो समझाया कि क्यों मेरी for (node in nodes) node.href = newLink;असफलता थी।