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


Answers

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Question

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

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

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




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




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

दस्तावेज़ीकरण से:

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

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

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

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




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

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

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




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

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

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

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

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

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

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

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

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

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

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

(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 myStringArray = ["hello", "World"];
myStringArray.forEach(function(val, index){
   console.log(val, index);
})



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://i.imgur.com/YTrO68E.png" title="Hosted by imgur.com" /></a>



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

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

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



पहचान

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

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

पारंपरिक के for एक पारंपरिक

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

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

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

for (;;) {
    // Do stuff
}

बेशक, आपको एक if(condition === true) { break; } if(condition === true) { break; } या एक if(condition === true) { return; } 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 लूप को सबसे पुराने ब्राउज़रों द्वारा भी समर्थित किया जाता है।

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

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 , के https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of भी अब के https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of । निम्न उदाहरण लूप के for...of अंतर 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
}

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

Array.prototype.forEach()

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

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

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

पुस्तकालय

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

jQuery.each() , jQuery :

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

_.each() , Underscore.js :

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

_.forEach() , Lodash.js :

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



Some use cases of looping through an array in the functional programming way in JavaScript:

1. Just loop through an array

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

Note: Array.prototype.forEach() is not a functional way strictly speaking, as the function it takes as the input parameter is not supposed to return a value, which thus cannot be regarded as a pure function.

2. Check if any of the elements in an array pass a test

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. Transform to a new array

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

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

Note: The map() method creates a new array with the results of calling a provided function on every element in the calling array.

4. Sum up a particular property, and calculate its average

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. Create a new array based on the original but without modifying it

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. Count the number of each category

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. Retrieve a subset of an array based on particular criteria

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

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

Note: The filter() method creates a new array with all elements that pass the test implemented by the provided function.

8. Sort an array

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

संदर्भ




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



If you want to use jQuery, it has a nice example in its documentation:

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



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

एक सरणी दिया गया:

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, संख्याएं हैं, तो लूप समय-समय पर टूट जाएगा। Again in practice this is hardly ever a problem for me, but it is something to keep in mind, which makes this a loop to think about before you use it... That may disqualify it for some people :)

What I like about this loop is:

  • It's short to write
  • No need to access (let alone cache) the length property
  • The item to access is automatically defined within the loop body under the name you pick.
  • Combines very naturally with array.push and array.splice to use arrays like lists/stacks

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



Links