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


Answers

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

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

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

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

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

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

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

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

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

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

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

आप अक्सर लूप इनिशियलाइजेशन क्लॉज में किए गए लम्बाई कैशिंग को देखेंगे, जैसे:

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

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

Question

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

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

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




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

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

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




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

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

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

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

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

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

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

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

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

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

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



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

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

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




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

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

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



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

var i = 0,
     item;

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

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

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

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

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




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

दस्तावेज़ से:

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

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

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

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




तरीके जावास्क्रिप्ट में यह करने के लिए के एक जोड़े हैं। पहले दो उदाहरण जावास्क्रिप्ट नमूने हैं। तीसरा एक JavaScript लाइब्रेरी, कि है, 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>




वहाँ केवल खुद वस्तु गुण, प्रोटोटाइप सहित नहीं से अधिक पुनरावृति के लिए एक विधि है:

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किया जाना चाहिए।




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

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

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

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

यह कुछ भी आप सरणी प्रसंस्करण के दायरे में जरूरत है कि दायरे के भीतर रहता है कि यह सुनिश्चित करता है, और है कि आप केवल सरणी, नहीं वस्तु गुण और अन्य सदस्यों, जिसके लिए क्या है के मूल्यों कार्रवाई कर रहे हैं .. करता है।

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

अत:

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/




उदाहरण के लिए, मैं एक Firefox कंसोल में प्रयोग किया है:

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



हाँ, आप पाश का उपयोग कर जावास्क्रिप्ट में भी ऐसा ही कर सकते हैं, लेकिन उस तक सीमित नहीं, JavaScrip में सरणियों से अधिक पाश करने के लिए कई तरीके हैं, कल्पना आप नीचे दिए गए इस सरणी है और आप इस पर एक पाश करना चाहते:

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

ये समाधान कर रहे हैं:

1) पाश के लिए

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

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

2) जबकि पाश

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

var i=0;

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

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

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

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

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

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

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

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

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

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

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

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




ठीक है, कैसे इस बारे में:

for (var key in myStringArray) {
    console.log(myStringArray[key]);
}



यकीन है कि यह अक्षम है और कई इसे घृणा है, लेकिन यह उल्लेख के सबसे करीब से एक है:

var myStringArray = ["Hello","World"];
myStringArray.forEach(function(f){
    // Do something
})



यह एक अनुक्रमिक उपयोग करने के लिए बेहतर है forपाश:

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



Links