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




arrays loops (20)

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

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

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


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

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

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

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

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

यह नोड पर भी काम करता है (मैंने इसे संस्करण 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); 
}

वस्तुओं की एक सरणी Iterating

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 loops

स्पेक: http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}


सबसे सुरुचिपूर्ण और तेज़ तरीका

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

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

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

100000 वस्तुओं की सरणी के माध्यम से लूपिंग के तरीकों की तुलना करना और प्रत्येक बार नए मान के साथ न्यूनतम ऑपरेशन करें।

तैयारी:

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

टेस्ट:

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

आप map उपयोग कर सकते हैं, जो एक कार्यात्मक प्रोग्रामिंग तकनीक है जो Python और Haskell जैसी अन्य भाषाओं में भी उपलब्ध है।

[1,2,3,4].map( function(item) {
     alert(item);
})

सामान्य वाक्यविन्यास है:

array.map(func)

सामान्य func एक पैरामीटर लेगा, जो सरणी का एक आइटम है। लेकिन जावास्क्रिप्ट के मामले में, यह दूसरा पैरामीटर ले सकता है जो आइटम की अनुक्रमणिका है, और एक तीसरा पैरामीटर जो सरणी है।

array.map का वापसी मान एक और सरणी है, इसलिए आप इसे इस तरह उपयोग कर सकते हैं:

var x = [1,2,3,4].map( function(item) {return item * 10;});

और अब एक्स [10,20,30,40]

आपको फ़ंक्शन इनलाइन लिखना नहीं है। यह एक अलग समारोह हो सकता है।

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

जो कि इसके बराबर होगा:

 for (item in my_list) {item_processor(item);}

सिवाय आपको new_list नहीं मिलती है।


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

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


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

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.prototype.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.prototype.find () विधि सरणी में पहले तत्व का मान देता है जो प्रदान किए गए परीक्षण फ़ंक्शन को संतुष्ट करता है।

संदर्भ


जबकि लूप का प्रयोग करें ...

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/


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

सामान्य लूप:

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

ईएस 5 के लिए प्रत्येक:

substr.forEach(function(item) {
    // Do something with `item`
});

jQuery.each:

jQuery.each(substr, function(index, item) {
    // Do something with `item` (or `this` is also `item` if you like)
});

विस्तृत जानकारी के लिए this देखें या आप जावास्क्रिप्ट में किसी सरणी के माध्यम से लूपिंग के लिए एमडीएन और jQuery.each() jQuery चेक jQuery.each() का उपयोग करके भी देख सकते हैं।


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

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

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

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

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

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

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

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

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

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

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

for (var i in array) {
  alert(array[i]);
}

उपर्युक्त कोड सतर्क होगा, "ए", "बी", "सी" और "फू!"।

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

जैसा कि मैंने पहले कहा था, के लिए अंतर्निहित कथन वस्तु गुणों को गिनने के लिए है, उदाहरण के लिए:

var obj = {
  "a": 1,
  "b": 2,
  "c": 3
};

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) { 
  // or if (Object.prototype.hasOwnProperty.call(obj,prop)) for safety...
    alert("prop: " + prop + " value: " + obj[prop])
  }
}

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

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


हां, लेकिन केवल तभी जब आपके कार्यान्वयन में ईसीएमएस्क्रिप्ट 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 (const 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 के माध्यम से looping के लिए इस्तेमाल नहीं किया जाना चाहिए।


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

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

ऐरे लूप:

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

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

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

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


निश्चित रूप से यह अक्षम है और कई इसे तुच्छ मानते हैं, लेकिन यह उल्लिखित सबसे नज़दीकी में से एक है:

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

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

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

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

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

परिणाम:

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

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

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


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

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

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

1) लूप के लिए

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

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) जबकि
कुछ वाक्यविन्यास अंतर के साथ वही काम करते समय करते हैं:

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

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

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

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

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

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

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

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

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

और पढ़ें >> here :


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

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>
var arr = [1, 2, 3, 1023, 1024];
for (var value; value = arr.pop();) {
    value + 1
}


यदि आप jQuery लाइब्रेरी का उपयोग कर रहे हैं, तो http://api.jquery.com/jQuery.each/ का उपयोग करने पर विचार करें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स्ट्रिंग या संख्या मान के रूप में लपेटेगा।) विधि अपना पहला तर्क देता है, ऑब्जेक्ट जिसे पुनरावृत्त किया गया था।


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

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

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

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






for-loop