सरणियों और संग्रहों के लिए foreach js। जावास्क्रिप्ट में एसोसिएटिव ऐरे कैसे बनाएं। पुनरावर्तक का स्पष्ट उपयोग

परिभाषा और अनुप्रयोग

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

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

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

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

ब्राउज़र समर्थन

जावास्क्रिप्ट सिंटैक्स:

जावास्क्रिप्ट संस्करण

पैरामीटर मान

उपयोग उदाहरण

निम्नलिखित उदाहरण में, हम देखेंगे कि किसी सरणी के सभी तत्वों का योग कैसे प्राप्त किया जाए जावास्क्रिप्टतरीका प्रत्येक के लिए():

निम्नलिखित उदाहरण में हम उपयोग करने पर विचार करेंगे दूसराविधि तर्क प्रत्येक के लिए(), जो किसी ऑब्जेक्ट की ओर इशारा करता है जिसका उपयोग करके हम संदर्भ दे सकते हैं कीवर्डयह कॉलबैक फ़ंक्शन के अंदर है:

• I. वास्तविक सरणियों पर पुनरावृत्ति
  1. प्रत्येक विधि और संबंधित विधियों के लिए
  2. पाश के लिए
  3. for...in लूप का उचित उपयोग
  4. लूप के लिए (पुनरावर्तक का अंतर्निहित उपयोग)
  5. पुनरावर्तक का स्पष्ट उपयोग
• द्वितीय. सरणी-जैसी वस्तुओं पर पुनरावृत्ति
  1. वास्तविक सरणियों पर पुनरावृति करने के तरीकों का उपयोग करना
  2. वास्तविक सरणी में कनवर्ट करें
  3. रनटाइम ऑब्जेक्ट पर एक नोट

I. वास्तविक सरणियों पर पुनरावृत्ति

पर इस पलवास्तविक सरणी के तत्वों पर पुनरावृति करने के तीन तरीके हैं:

1. विधि Array.prototype.forEach ;
2. लूप के लिए क्लासिक
3. लूप में... के लिए एक "सही ढंग से" निर्मित।

इसके अलावा, जल्द ही, नए ईसीएमएस्क्रिप्ट 6 (ईएस 6) मानक के आगमन के साथ, दो और तरीके अपेक्षित हैं:

1. for...of लूप (इटरेटर का अंतर्निहित उपयोग);
2. पुनरावर्तक का स्पष्ट उपयोग.

1. प्रत्येक विधि और संबंधित विधियाँ

यदि आपका प्रोजेक्ट ECMAScript 5 (ES5) मानक की सुविधाओं का समर्थन करने के लिए डिज़ाइन किया गया है, तो आप इसके नवाचारों में से एक - forEach विधि का उपयोग कर सकते हैं।

उपयोग उदाहरण:

वर ए = ["ए", "बी", "सी"]; a.forEach(function(entry) ( console.log(entry); ));

सामान्य तौर पर, forEach का उपयोग करने के लिए उन ब्राउज़रों के लिए es5-शिम इम्यूलेशन लाइब्रेरी को कनेक्ट करने की आवश्यकता होती है जो मूल रूप से इस पद्धति का समर्थन नहीं करते हैं। इनमें IE 8 और इसके बाद के संस्करण शामिल हैं प्रारंभिक संस्करणजो आज भी यत्र-तत्र प्रयोग में हैं।

forEach का लाभ यह है कि वर्तमान सरणी तत्व के सूचकांक और मूल्य को संग्रहीत करने के लिए स्थानीय चर घोषित करने की कोई आवश्यकता नहीं है, क्योंकि वे स्वचालित रूप से कॉलबैक फ़ंक्शन को तर्क के रूप में पारित कर दिए जाते हैं।

यदि आप प्रत्येक तत्व पर कॉलबैक करने की संभावित लागत के बारे में चिंतित हैं, तो चिंता न करें और इसे पढ़ें।

forEach को किसी सरणी के सभी तत्वों के माध्यम से पुनरावृत्त करने के लिए डिज़ाइन किया गया है, लेकिन इसके अलावा, ES5 सभी या कुछ तत्वों के माध्यम से पुनरावृत्त करने के साथ-साथ उन पर कुछ क्रियाएं करने के लिए कई और उपयोगी तरीके प्रदान करता है:

• प्रत्येक - सत्य लौटाता है यदि सरणी के प्रत्येक तत्व के लिए कॉलबैक एक मान देता है जिसे सत्य में परिवर्तित किया जा सकता है।
• कुछ - सत्य लौटाता है यदि सरणी के कम से कम एक तत्व के लिए कॉलबैक एक मान लौटाता है जिसे सत्य में परिवर्तित किया जा सकता है।
• फ़िल्टर - एक नई सरणी बनाता है जिसमें मूल सरणी के वे तत्व शामिल होते हैं जिनके लिए कॉलबैक सत्य लौटाता है।
• मानचित्र - कॉलबैक द्वारा लौटाए गए मानों से युक्त एक नई सरणी बनाता है।
• कम करें - एक सरणी को एक मान में कम कर देता है, पहले से शुरू करके सरणी के प्रत्येक तत्व पर कॉलबैक लागू करता है (सरणी तत्वों और अन्य सारांश कार्यों के योग की गणना के लिए उपयोगी हो सकता है)।
• कम करें - कम करने के समान काम करता है, लेकिन तत्वों के माध्यम से उल्टे क्रम में पुनरावृत्त करता है।

2. लूप के लिए

नियमों के लिए अच्छा पुराना:

वर ए = ["ए", "बी", "सी"]; वर सूचकांक; के लिए (सूचकांक = 0; सूचकांक< a.length; ++index) { console.log(a); }

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

वर ए = ["ए", "बी", "सी"]; वर सूचकांक, लेन; के लिए (सूचकांक = 0, लेन = ए.लंबाई; सूचकांक< len; ++index) { console.log(a); }

सिद्धांत रूप में, यह कोड पिछले वाले की तुलना में थोड़ा तेज़ चलना चाहिए।

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

वर ए = ["ए", "बी", "सी"]; वर सूचकांक; (सूचकांक = ए.लंबाई - 1; सूचकांक >= 0; --सूचकांक) ( कंसोल.लॉग(ए); ) के लिए

हालाँकि, आधुनिक जावास्क्रिप्ट इंजनों में ऐसे अनुकूलन गेम का आमतौर पर कोई मतलब नहीं होता है।

3. for...in लूप का सही उपयोग

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

हालाँकि, कुछ मामलों में, जैसे कि विरल सरणियों पर पुनरावृत्ति, for...in उपयोगी हो सकता है, जब तक आप सावधानी बरतते हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

// ए - विरल सरणी var a = ; ए = "ए"; ए = "बी"; ए = "सी"; for (var key in a) ( if (a.hasOwnProperty(key) && /^0$|^d*$/.test(key) && key<= 4294967294) { console.log(a); } }

इस उदाहरण में, लूप के प्रत्येक पुनरावृत्ति पर दो जाँचें की जाती हैं:

1. कि सरणी की अपनी संपत्ति है जिसे कुंजी कहा जाता है (इसके प्रोटोटाइप से विरासत में नहीं मिली है)।
2. वह कुंजी एक स्ट्रिंग है जिसमें पूर्णांक का दशमलव प्रतिनिधित्व होता है जिसका मान 4294967294 से कम है। आखिरी नंबर कहां से आता है? ES5 में एक सरणी सूचकांक की परिभाषा से, जो दर्शाता है कि किसी सरणी में एक तत्व का उच्चतम सूचकांक हो सकता है: (2^32 - 2) = 4294967294।

बेशक, लूप निष्पादित करते समय ऐसी जांच में अनावश्यक समय लगेगा। लेकिन विरल सरणी के मामले में, यह विधि लूप की तुलना में अधिक कुशल है, क्योंकि इस मामले में केवल वे तत्व जो सरणी में स्पष्ट रूप से परिभाषित हैं, पुनरावृत्त होते हैं। इसलिए, ऊपर दिए गए उदाहरण में, केवल 3 पुनरावृत्तियाँ निष्पादित की जाएंगी (सूचकांक 0, 10 और 10000 के लिए) - बनाम लूप में 10001।

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

फ़ंक्शन arrayHasOwnIndex(array, key) ( return array.hasOwnProperty(key) && /^0$|^d*$/.test(key) && key<= 4294967294; }

तब उदाहरण से लूप का शरीर काफी कम हो जाएगा:

(a में key) के लिए ( if (arrayHasOwnIndex(a, key)) ( console.log(a); ) )

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

(a में key) के लिए ( if (a.hasOwnProperty(key) && String(parseInt(key, 10)) === key) ( console.log(a); ) )

4. लूप के लिए (पुनरावर्तक का अंतर्निहित उपयोग)

ईएस6, जो अभी भी ड्राफ्ट स्थिति में है, को पुनरावर्तकों को जावास्क्रिप्ट से परिचित कराना चाहिए।

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

1. किया (बूलियन) - यदि पुनरावर्तक पुनरावर्तनीय अनुक्रम के अंत तक पहुंच गया है तो सत्य है। अन्यथा मान गलत है.
2. मूल्य - पुनरावर्तक द्वारा लौटाए गए मान को परिभाषित करता है। यदि किया गया गुण सत्य है तो अपरिभाषित (गायब) हो सकता है।

कई अंतर्निर्मित वस्तुएं, जिनमें शामिल हैं। वास्तविक सरणियों में डिफ़ॉल्ट रूप से पुनरावर्तक होते हैं। वास्तविक सरणियों पर पुनरावर्तक का उपयोग करने का सबसे सरल तरीका नए for...of निर्माण का उपयोग करना है।

for...of का उपयोग करने का उदाहरण:

वर्वल; var a = ["a", "b", "c"]; (वैल ऑफ ए) के लिए ( कंसोल.लॉग(वैल); )

उपरोक्त उदाहरण में, for...of लूप, सरणी के प्रत्येक मान को प्राप्त करने के लिए स्पष्ट रूप से ऐरे ऑब्जेक्ट के इटरेटर को कॉल करता है।

5. इटरेटर का स्पष्ट उपयोग

इटरेटर का उपयोग स्पष्ट रूप से भी किया जा सकता है, हालांकि, इस मामले में कोड लूप के लिए की तुलना में बहुत अधिक जटिल हो जाता है। यह कुछ इस तरह दिखता है:

वर ए = ["ए", "बी", "सी"]; वर प्रविष्टि; जबकि (!(entry = a.next()).done) ( console.log(entry.value); )

द्वितीय. सरणी-जैसी वस्तुओं पर पुनरावृत्ति

वास्तविक सरणियों के अलावा, जावास्क्रिप्ट में भी हैं सरणी जैसी वस्तुएं . वास्तविक सरणियों के साथ उनमें जो समानता है वह यह है कि उनके पास लंबाई गुण और गुण हैं जिन्हें सरणी के तत्वों के अनुरूप संख्याओं के रूप में नामित किया गया है। उदाहरणों में नोडलिस्ट संग्रह का DOM और किसी भी फ़ंक्शन/विधि के अंदर उपलब्ध तर्क छद्म-सरणी शामिल हैं।

1. वास्तविक सरणियों पर पुनरावृति करने के तरीकों का उपयोग करना

कम से कम, अधिकांश, यदि सभी नहीं, तो वास्तविक सरणियों पर पुनरावृति की विधियों का उपयोग सरणी-जैसी वस्तुओं पर पुनरावृति करने के लिए किया जा सकता है।

फॉर और फॉर...इन निर्माणों को सरणी-जैसी वस्तुओं पर बिल्कुल उसी तरह लागू किया जा सकता है जैसे वे वास्तविक सरणियों पर लागू होते हैं।

forEach और अन्य Array.prototype विधियाँ सरणी जैसी वस्तुओं पर भी लागू होती हैं। ऐसा करने के लिए आपको Function.call या Function.apply का उपयोग करना होगा।

उदाहरण के लिए, यदि आप किसी नोड ऑब्जेक्ट की childNodes प्रॉपर्टी के लिए forEach लागू करना चाहते हैं, तो आप इसे इस प्रकार करेंगे:

Array.prototype.forEach.call(node.childNodes, function(child) ( // चाइल्ड ऑब्जेक्ट के साथ कुछ करें));

इस ट्रिक को पुन: उपयोग में आसान बनाने के लिए, आप एक अलग वेरिएबल में Array.prototype.forEach विधि का संदर्भ घोषित कर सकते हैं और इसे शॉर्टकट के रूप में उपयोग कर सकते हैं:

// (यह मानते हुए कि नीचे दिया गया सभी कोड एक ही दायरे में है) var forEach = Array.prototype.forEach; // ... forEach.call(node.childNodes, function(child) ( // चाइल्ड ऑब्जेक्ट के साथ कुछ करें));

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

2. वास्तविक सरणी में कनवर्ट करें

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

वर ट्रूअरे = Array.prototype.slice.call(arrayLikeObject, 0);

उदाहरण के लिए, यदि आप एक नोडलिस्ट संग्रह को वास्तविक सरणी में परिवर्तित करना चाहते हैं, तो आपको कुछ इस तरह कोड की आवश्यकता होगी:

वार divs = Array.prototype.slice.call(document.querySelectorAll("div"), 0);

3. रनटाइम ऑब्जेक्ट पर एक नोट

यदि आप रनटाइम ऑब्जेक्ट्स (जैसे DOM संग्रह) पर Array.prototype तरीकों को लागू करते हैं, तो आपको पता होना चाहिए कि इन तरीकों को सभी रनटाइम वातावरण (ब्राउज़र सहित) में सही ढंग से काम करने की गारंटी नहीं है। यह किसी विशेष निष्पादन वातावरण में किसी विशेष ऑब्जेक्ट के व्यवहार पर निर्भर करता है, या अधिक सटीक रूप से, इस ऑब्जेक्ट में अमूर्त ऑपरेशन हैसप्रॉपर्टी को कैसे कार्यान्वित किया जाता है। समस्या यह है कि ES5 मानक स्वयं इस ऑपरेशन के संबंध में किसी वस्तु के दुर्व्यवहार की संभावना की अनुमति देता है (§8.6.2 देखें)।

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

• I. वास्तविक सरणियों पर पुनरावृत्ति
  1. प्रत्येक विधि और संबंधित विधियों के लिए
  2. पाश के लिए
  3. for...in लूप का उचित उपयोग
  4. लूप के लिए (पुनरावर्तक का अंतर्निहित उपयोग)
  5. पुनरावर्तक का स्पष्ट उपयोग
• 1. वास्तविक सरणियों पर पुनरावृति करने के तरीकों का उपयोग करना
  2. वास्तविक सरणी में कनवर्ट करें
  3. रनटाइम ऑब्जेक्ट पर एक नोट

I. वास्तविक सरणियों पर पुनरावृत्ति

1. विधि Array.prototype.forEach ;
2. लूप के लिए क्लासिक
3. लूप में... के लिए एक "सही ढंग से" निर्मित।

1. for...of लूप (इटरेटर का अंतर्निहित उपयोग);
2. पुनरावर्तक का स्पष्ट उपयोग.

1. प्रत्येक विधि और संबंधित विधियाँ

उपयोग उदाहरण:
var a = ["a", "b", "c"]; a.forEach(function(entry) ( console.log(entry); ));
सामान्य तौर पर, forEach का उपयोग करने के लिए उन ब्राउज़रों के लिए es5-शिम इम्यूलेशन लाइब्रेरी को कनेक्ट करने की आवश्यकता होती है जो मूल रूप से इस पद्धति का समर्थन नहीं करते हैं। इनमें IE 8 और इससे पहले के संस्करण शामिल हैं, जो अभी भी कुछ स्थानों पर उपयोग में हैं।

forEach का लाभ यह है कि वर्तमान सरणी तत्व के सूचकांक और मूल्य को संग्रहीत करने के लिए स्थानीय चर घोषित करने की कोई आवश्यकता नहीं है, क्योंकि वे स्वचालित रूप से कॉलबैक फ़ंक्शन को तर्क के रूप में पारित कर दिए जाते हैं।

यदि आप प्रत्येक तत्व पर कॉलबैक करने की संभावित लागत के बारे में चिंतित हैं, तो चिंता न करें और इसे पढ़ें।

ForEach को किसी सरणी के सभी तत्वों को पुनरावृत्त करने के लिए डिज़ाइन किया गया है, लेकिन इसके अलावा, ES5 सभी या कुछ तत्वों के माध्यम से पुनरावृत्त करने के साथ-साथ उन पर कुछ क्रियाएं करने के लिए कई और उपयोगी तरीके प्रदान करता है:

• प्रत्येक - सत्य लौटाता है यदि सरणी के प्रत्येक तत्व के लिए कॉलबैक एक मान देता है जिसे सत्य में परिवर्तित किया जा सकता है।
• कुछ - सत्य लौटाता है यदि सरणी के कम से कम एक तत्व के लिए कॉलबैक एक मान लौटाता है जिसे सत्य में परिवर्तित किया जा सकता है।
• फ़िल्टर - एक नई सरणी बनाता है जिसमें मूल सरणी के वे तत्व शामिल होते हैं जिनके लिए कॉलबैक सत्य लौटाता है।
• मानचित्र - कॉलबैक द्वारा लौटाए गए मानों से युक्त एक नई सरणी बनाता है।
• कम करें - एक सरणी को एक मान में कम कर देता है, पहले से शुरू करके सरणी के प्रत्येक तत्व पर कॉलबैक लागू करता है (सरणी तत्वों और अन्य सारांश कार्यों के योग की गणना के लिए उपयोगी हो सकता है)।
• कम करें - कम करने के समान काम करता है, लेकिन तत्वों के माध्यम से उल्टे क्रम में पुनरावृत्त करता है।

2. लूप के लिए

वर ए = ["ए", "बी", "सी"]; वर सूचकांक; के लिए (सूचकांक = 0; सूचकांक< a.length; ++index) { console.log(a); }
यदि सरणी की लंबाई पूरे लूप में स्थिर है, और लूप स्वयं कोड के प्रदर्शन-महत्वपूर्ण अनुभाग से संबंधित है (जो कि संभावना नहीं है), तो आप सरणी की लंबाई को संग्रहीत करने के लिए "अधिक इष्टतम" संस्करण का उपयोग कर सकते हैं :

वर ए = ["ए", "बी", "सी"]; वर सूचकांक, लेन; के लिए (सूचकांक = 0, लेन = ए.लंबाई; सूचकांक< len; ++index) { console.log(a); }
सिद्धांत रूप में, यह कोड पिछले वाले की तुलना में थोड़ा तेज़ चलना चाहिए।

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

वर ए = ["ए", "बी", "सी"]; वर सूचकांक; (सूचकांक = ए.लंबाई - 1; सूचकांक >= 0; --सूचकांक) ( कंसोल.लॉग(ए); ) के लिए
हालाँकि, आधुनिक जावास्क्रिप्ट इंजनों में ऐसे अनुकूलन गेम का आमतौर पर कोई मतलब नहीं होता है।

3. for...in लूप का सही उपयोग

हालाँकि, कुछ मामलों में, जैसे कि विरल सरणियों पर पुनरावृत्ति, for...in उपयोगी हो सकता है, जब तक आप सावधानी बरतते हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

// ए - विरल सरणी var a = ; ए = "ए"; ए = "बी"; ए = "सी"; for (var key in a) ( if (a.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key<= 4294967294) { console.log(a); } }
इस उदाहरण में, लूप के प्रत्येक पुनरावृत्ति पर दो जाँचें की जाती हैं:

1. कि सरणी की अपनी संपत्ति है जिसे कुंजी कहा जाता है (इसके प्रोटोटाइप से विरासत में नहीं मिली है)।
2. वह कुंजी एक स्ट्रिंग है जिसमें पूर्णांक का दशमलव प्रतिनिधित्व होता है जिसका मान 4294967294 से कम है। आखिरी नंबर कहां से आता है? ES5 में एक सरणी सूचकांक की परिभाषा से, जो दर्शाता है कि किसी सरणी में एक तत्व का उच्चतम सूचकांक हो सकता है: (2^32 - 2) = 4294967294।

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

फ़ंक्शन arrayHasOwnIndex(array, key) ( return array.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key<= 4294967294; }
तब उदाहरण से लूप का शरीर काफी कम हो जाएगा:

(a में key) के लिए ( if (arrayHasOwnIndex(a, key)) ( console.log(a); ) )
ऊपर चर्चा किया गया चेक कोड सार्वभौमिक है, सभी मामलों के लिए उपयुक्त है। लेकिन इसके बजाय, आप एक छोटे संस्करण का उपयोग कर सकते हैं, हालांकि औपचारिक रूप से यह पूरी तरह से सही नहीं है, लेकिन फिर भी अधिकांश मामलों के लिए उपयुक्त है:

(a में key) के लिए ( if (a.hasOwnProperty(key) && String(parseInt(key, 10)) === key) ( console.log(a); ) )

4. लूप के लिए (पुनरावर्तक का अंतर्निहित उपयोग)

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

1. किया (बूलियन) - यदि पुनरावर्तक पुनरावर्तनीय अनुक्रम के अंत तक पहुंच गया है तो सत्य है। अन्यथा मान गलत है.
2. मूल्य - पुनरावर्तक द्वारा लौटाए गए मान को परिभाषित करता है। यदि किया गया गुण सत्य है तो अपरिभाषित (गायब) हो सकता है।

for...of का उपयोग करने का उदाहरण:

वर्वल; var a = ["a", "b", "c"]; (वैल ऑफ ए) के लिए ( कंसोल.लॉग(वैल); )
उपरोक्त उदाहरण में, for...of लूप, सरणी के प्रत्येक मान को प्राप्त करने के लिए स्पष्ट रूप से ऐरे ऑब्जेक्ट के इटरेटर को कॉल करता है।

5. इटरेटर का स्पष्ट उपयोग

वर ए = ["ए", "बी", "सी"]; var it = a.entries(); वर प्रविष्टि; जबकि (!(entry = it.next()).done) ( console.log(entry.value); )
इस उदाहरण में, Array.prototype.entries विधि एक पुनरावर्तक लौटाती है जिसका उपयोग सरणी के मान प्रदर्शित करने के लिए किया जाता है। प्रत्येक पुनरावृत्ति पर, Entry.value में फॉर्म की एक सरणी होती है [key, value] ।

द्वितीय. सरणी-जैसी वस्तुओं पर पुनरावृत्ति

1. वास्तविक सरणियों पर पुनरावृति करने के तरीकों का उपयोग करना

फॉर और फॉर...इन निर्माणों को सरणी-जैसी वस्तुओं पर बिल्कुल उसी तरह लागू किया जा सकता है जैसे वे वास्तविक सरणियों पर लागू होते हैं।

ForEach और अन्य Array.prototype विधियाँ सरणी जैसी वस्तुओं पर भी लागू होती हैं। ऐसा करने के लिए आपको Function.call या Function.apply का उपयोग करना होगा।

उदाहरण के लिए, यदि आप किसी नोड ऑब्जेक्ट की childNodes प्रॉपर्टी के लिए forEach लागू करना चाहते हैं, तो आप इसे इस प्रकार करेंगे:

Array.prototype.forEach.call(node.childNodes, function(child) ( // चाइल्ड ऑब्जेक्ट के साथ कुछ करें));
इस ट्रिक को पुन: उपयोग में आसान बनाने के लिए, आप एक अलग वेरिएबल में Array.prototype.forEach विधि का संदर्भ घोषित कर सकते हैं और इसे शॉर्टकट के रूप में उपयोग कर सकते हैं:

// (यह मानते हुए कि नीचे दिया गया सभी कोड एक ही दायरे में है) var forEach = Array.prototype.forEach; // ... forEach.call(node.childNodes, function(child) ( // चाइल्ड ऑब्जेक्ट के साथ कुछ करें));
यदि किसी सरणी जैसी वस्तु में एक पुनरावर्तक है, तो इसका उपयोग वास्तविक सरणियों की तरह ही वस्तु पर पुनरावृति करने के लिए स्पष्ट रूप से या अंतर्निहित रूप से किया जा सकता है।

2. वास्तविक सरणी में कनवर्ट करें

वर ट्रूअरे = Array.prototype.slice.call(arrayLikeObject, 0);
उदाहरण के लिए, यदि आप एक नोडलिस्ट संग्रह को वास्तविक सरणी में परिवर्तित करना चाहते हैं, तो आपको कुछ इस तरह कोड की आवश्यकता होगी:

वार divs = Array.prototype.slice.call(document.querySelectorAll("div"), 0);
अद्यतन: जैसा कि रॉक एंड टोरबासो की टिप्पणियों में बताया गया है, ES6 में आप Array.prototype.slice के बजाय अधिक विज़ुअल Array.from विधि का उपयोग कर सकते हैं।

3. रनटाइम ऑब्जेक्ट पर एक नोट

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

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

इस इंटरैक्टिव उदाहरण का स्रोत GitHub रिपॉजिटरी में संग्रहीत है। यदि आप इंटरैक्टिव उदाहरण प्रोजेक्ट में योगदान देना चाहते हैं, तो कृपया https://github.com/mdn/interactive-examples को क्लोन करें और हमें एक पुल अनुरोध भेजें।

वाक्य - विन्यास

पैरामीटर

प्रतिलाभ की मात्रा

विवरण

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

कॉलबैक तीन तर्कों के साथ लागू किया जाता है:

1. तत्व का मूल्य
2. तत्व का सूचकांक
3. ऐरे ऑब्जेक्ट का पता लगाया जा रहा है

यदि एक thisArg पैरामीटर forEach() को प्रदान किया जाता है, तो इसका उपयोग कॉलबैक के इस मान के रूप में किया जाएगा। thisArg मान अंततः कॉलबैक द्वारा देखने योग्य होता है, जो किसी फ़ंक्शन द्वारा देखे गए this को निर्धारित करने के सामान्य नियमों के अनुसार निर्धारित किया जाता है।

forEach() द्वारा संसाधित तत्वों की श्रेणी कॉलबैक के पहले आह्वान से पहले निर्धारित की जाती है। forEach() पर कॉल शुरू होने के बाद सरणी में जोड़े गए तत्वों को कॉलबैक द्वारा नहीं देखा जाएगा। यदि सरणी के मौजूदा तत्वों को बदल दिया जाता है या हटा दिया जाता है, तो कॉलबैक में पारित उनका मान उस समय का मान होगा जब forEach() उन पर जाता है; विज़िट किए जाने से पहले हटा दिए गए तत्व विज़िट नहीं किए जाते हैं। यदि पहले से देखे गए तत्वों को पुनरावृत्ति के दौरान हटा दिया जाता है (उदाहरण के लिए शिफ्ट() का उपयोग करके), तो बाद के तत्वों को छोड़ दिया जाएगा। (यह उदाहरण नीचे देखें।)

forEach() प्रत्येक सरणी तत्व के लिए कॉलबैक फ़ंक्शन को एक बार निष्पादित करता है; मानचित्र() या कम() के विपरीत यह हमेशा अपरिभाषित मान लौटाता है और श्रृंखलाबद्ध नहीं है। सामान्य उपयोग का मामला श्रृंखला के अंत में साइड इफेक्ट निष्पादित करना है।

forEach() उस सरणी को परिवर्तित नहीं करता जिस पर इसे कॉल किया गया है। (हालाँकि, कॉलबैक ऐसा कर सकता है)

अपवाद फेंकने के अलावा forEach() लूप को रोकने या तोड़ने का कोई तरीका नहीं है। यदि आपको ऐसे व्यवहार की आवश्यकता है, तो forEach() विधि गलत उपकरण है।

शीघ्र समापन निम्नलिखित के साथ पूरा किया जा सकता है:

सरणी विधियां: प्रत्येक(), कुछ(), ढूंढें(), और ढूंढेंइंडेक्स() सरणी तत्वों का परीक्षण एक विधेय के साथ एक सत्य मान लौटाते हुए यह निर्धारित करने के लिए करते हैं कि आगे पुनरावृत्ति की आवश्यकता है या नहीं।

उदाहरण

अप्रारंभीकृत मानों (विरल सरणियों) के लिए कोई ऑपरेशन नहीं

लूप के लिए forEach में कनवर्ट करना

किसी सरणी की सामग्री को प्रिंट करना

टिप्पणी:कंसोल में किसी सरणी की सामग्री को प्रदर्शित करने के लिए, आप console.table() का उपयोग कर सकते हैं, जो सरणी का एक स्वरूपित संस्करण प्रिंट करता है।

निम्नलिखित उदाहरण forEach() का उपयोग करके एक वैकल्पिक दृष्टिकोण दिखाता है।

निम्न कोड किसी सरणी में प्रत्येक तत्व के लिए एक पंक्ति लॉग करता है:

फ़ंक्शन logArrayElements (तत्व, सूचकांक, सरणी) ( कंसोल.लॉग ("ए [" + सूचकांक + "] = " + तत्व) ) // ध्यान दें कि सूचकांक 2 को छोड़ दिया गया है, क्योंकि // उस स्थिति में कोई आइटम नहीं है सरणी... .forEach(logArrayElements) // लॉग्स: // a = 2 // a = 5 // a = 9

इस Arg का उपयोग करना

निम्नलिखित (कल्पित) उदाहरण सरणी में प्रत्येक प्रविष्टि से ऑब्जेक्ट के गुणों को अपडेट करता है:

फ़ंक्शन काउंटर() (यह.योग = 0 यह.गिनती = 0) काउंटर.प्रोटोटाइप.जोड़ें = फ़ंक्शन(सरणी) ( array.forEach(फ़ंक्शन(एंट्री) (यह.योग += प्रविष्टि ++यह.गिनती), यह ) // ^---- नोट ) const obj = new काउंटर() obj.add() obj.count // 3 obj.sum // 16

चूँकि thisArg पैरामीटर (यह) forEach() को प्रदान किया जाता है, इसे हर बार कॉल करने पर कॉलबैक में भेज दिया जाता है। कॉलबैक इसे इस मान के रूप में उपयोग करता है।

एक ऑब्जेक्ट कॉपी फ़ंक्शन

निम्नलिखित कोड किसी दिए गए ऑब्जेक्ट की एक प्रति बनाता है।

किसी ऑब्जेक्ट की प्रतिलिपि बनाने के विभिन्न तरीके हैं। निम्नलिखित सिर्फ एक तरीका है और यह समझाने के लिए प्रस्तुत किया गया है कि ECMAScript 5 ऑब्जेक्ट.* मेटा प्रॉपर्टी फ़ंक्शन का उपयोग करके Array.prototype.forEach() कैसे काम करता है।

फ़ंक्शन कॉपी (ओबीजे) ( कॉन्स्ट कॉपी = ऑब्जेक्ट.क्रिएट(ऑब्जेक्ट.गेटप्रोटोटाइपऑफ(ओबीजे)) कॉन्स्ट प्रोपनेम्स = ऑब्जेक्ट.गेटओनप्रॉपर्टीनाम(ओबीजे) प्रोपनेम्स.फॉरईच(फंक्शन(नाम) ( कॉन्स्ट डेस = ऑब्जेक्ट.गेटओनप्रॉपर्टीडिस्क्रिप्टर(ओबीजे, नाम) ऑब्जेक्ट .defineProperty (कॉपी, नाम, desc) )) रिटर्न कॉपी) const obj1 = ( a: 1, b: 2 ) const obj2 = प्रतिलिपि (obj1) // obj2 अब obj1 जैसा दिखता है

यदि पुनरावृत्ति के दौरान सरणी को संशोधित किया जाता है, तो अन्य तत्वों को छोड़ दिया जा सकता है।

निम्न उदाहरण "एक", "दो", "चार" लॉग करता है।

जब प्रविष्टि में मान "two" is reached, the first entry of the whole array is shifted off-resulting in all remaining entries moving up one position. Because element "four" is now at an earlier position in the array, "three" will be skipped.!}

forEach() पुनरावृत्त करने से पहले सरणी की प्रतिलिपि नहीं बनाता है।

मान लीजिए शब्द = ["एक", "दो", "तीन", "चार"] शब्द.प्रत्येक के लिए(फ़ंक्शन(शब्द) ( कंसोल.लॉग(शब्द) यदि (शब्द === "दो") ( शब्द.शिफ्ट( ) ) )) // एक // दो // चार

एक सरणी को समतल करें

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

/** * पारित सरणी को एक आयामी सरणी में समतल करता है * * @params (सरणी) arr * @returns (सरणी) */ फ़ंक्शन फ़्लैटन(arr) ( const परिणाम = arr.forEach((i) => ( यदि (Array. isArray(i)) (परिणाम.पुश(...सपाट(i)) ) अन्यथा (परिणाम.पुश(i) )) वापसी परिणाम) // उपयोग स्थिरांक समस्या = , 8, 9]] चपटा(समस्या) //

प्रॉमिस या एसिंक फ़ंक्शंस का उपयोग करने पर ध्यान दें

विशेष विवरण

ब्राउज़र अनुकूलता

इस पृष्ठ में संगतता तालिका संरचित डेटा से तैयार की गई है। यदि आप डेटा में योगदान देना चाहते हैं, तो कृपया https://github.com/mdn/browser-compat-data देखें और हमें एक पुल अनुरोध भेजें।

GitHub पर संगतता डेटा अपडेट करें

अंतिम अद्यतन: 03/26/2018

ऐरे ऑब्जेक्ट एक ऐरे का प्रतिनिधित्व करता है और कई गुण और तरीके प्रदान करता है जिनके साथ हम ऐरे में हेरफेर कर सकते हैं।

एक सारणी आरंभ करना

आप वर्गाकार कोष्ठक या ऐरे कंस्ट्रक्टर का उपयोग करके एक खाली सरणी बना सकते हैं:

वार उपयोगकर्ता = नया ऐरे(); वर लोग = ; कंसोल.लॉग(उपयोगकर्ता); // ऐरे कंसोल.लॉग(लोग); // सारणी

आप निश्चित संख्या में तत्वों के साथ किसी सरणी को तुरंत प्रारंभ कर सकते हैं:

वार उपयोगकर्ता = नया ऐरे ("टॉम", "बिल", "ऐलिस"); वर लोग = ["सैम", "जॉन", "केट"]; कंसोल.लॉग(उपयोगकर्ता); // ["टॉम", "बिल", "ऐलिस"] कंसोल.लॉग(लोग); // ["सैम", "जॉन", "केट"]

आप किसी सरणी को परिभाषित कर सकते हैं और उसमें नए तत्व जोड़ सकते हैं:

वार उपयोगकर्ता = नया ऐरे(); उपयोगकर्ता = "टॉम"; उपयोगकर्ता = "केट"; कंसोल.लॉग(उपयोगकर्ता); // "टॉम" कंसोल.लॉग(उपयोगकर्ता); // अपरिभाषित

इससे कोई फर्क नहीं पड़ता कि डिफ़ॉल्ट रूप से सरणी शून्य लंबाई के साथ बनाई गई है। इंडेक्स का उपयोग करके, हम किसी सरणी में एक विशिष्ट इंडेक्स पर एक या दूसरे तत्व को प्रतिस्थापित कर सकते हैं।

लंबाई

किसी सरणी की लंबाई जानने के लिए, length प्रॉपर्टी का उपयोग करें:

वर फल = नया ऐरे(); फल = "सेब"; फल = "नाशपाती"; फल = "प्लम"; दस्तावेज़.लिखें ("सरणी में फल" + फल.लंबाई + "तत्व:
"); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

वास्तव में, सरणी की लंबाई अंतिम तत्व प्लस वन का सूचकांक होगी। उदाहरण के लिए:

वार उपयोगकर्ता = नया ऐरे(); // सरणी में 0 तत्व हैं उपयोगकर्ता = "टॉम"; उपयोगकर्ता = "केट"; उपयोगकर्ता = "सैम"; for(var i=0; i

ब्राउज़र आउटपुट:

टॉम केट अपरिभाषित अपरिभाषित सैम

इस तथ्य के बावजूद कि हमने सूचकांक 2 और 3 के लिए तत्व नहीं जोड़े हैं, इस मामले में सरणी की लंबाई संख्या 5 होगी। यह सिर्फ इतना है कि सूचकांक 2 और 3 वाले तत्वों का मान अपरिभाषित होगा।

किसी सरणी की प्रतिलिपि बनाना. टुकड़ा()

किसी सरणी की प्रतिलिपि बनाना उथली या उथली (उथली प्रतिलिपि) और गहरी (गहरी प्रतिलिपि) हो सकती है।

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

वर उपयोगकर्ता = ["टॉम", "सैम", "बिल"]; कंसोल.लॉग(उपयोगकर्ता); // ["टॉम", "सैम", "बिल"] var लोग = उपयोगकर्ता; // उथले नकल करने वाले लोग = "माइक"; // दूसरा तत्व कंसोल.लॉग(उपयोगकर्ता) बदलें; // ["टॉम", "माइक", "बिल"]

इस मामले में, लोग वेरिएबल, कॉपी करने के बाद, उपयोगकर्ताओं वेरिएबल के समान सरणी को इंगित करेंगे। इसलिए, जब लोगों में तत्व बदलते हैं, तो उपयोगकर्ताओं में तत्व भी बदल जाएंगे, क्योंकि वास्तव में यह एक ही सरणी है।

यह व्यवहार हमेशा वांछनीय नहीं होता. उदाहरण के लिए, हम चाहते हैं कि वेरिएबल कॉपी करने के बाद अलग-अलग सरणियों को इंगित करें। और इस मामले में, आप स्लाइस() विधि का उपयोग करके गहरी प्रतिलिपि का उपयोग कर सकते हैं:

वर उपयोगकर्ता = ["टॉम", "सैम", "बिल"]; कंसोल.लॉग(उपयोगकर्ता); // ["टॉम", "सैम", "बिल"] var लोग = उपयोगकर्ता.स्लाइस(); // डीप कॉपी लोग = "माइक"; // दूसरा तत्व कंसोल.लॉग(उपयोगकर्ता) बदलें; // ["टॉम", "सैम", "बिल"] कंसोल.लॉग(लोग); // ["टॉम", "माइक", "बिल"]

इस मामले में, कॉपी करने के बाद, वेरिएबल अलग-अलग सरणियों को इंगित करेंगे, और हम उन्हें एक-दूसरे से अलग से बदल सकते हैं।

स्लाइस() विधि आपको किसी सरणी के भाग की प्रतिलिपि बनाने की भी अनुमति देती है:

वर उपयोगकर्ता = ["टॉम", "सैम", "बिल", "ऐलिस", "केट"]; वर लोग = उपयोगकर्ता.स्लाइस(1, 4); कंसोल.लॉग(लोग); // ["सैम", "बिल", "ऐलिस"]

स्लाइस() विधि प्रारंभिक और अंतिम इंडेक्स को पारित करती है, जिसका उपयोग सरणी से मान पुनर्प्राप्त करने के लिए किया जाता है। अर्थात्, इस मामले में, नए एरे में चयन इंडेक्स 1 से इंडेक्स 4 तक जाता है, इसमें शामिल नहीं है। और चूंकि सरणी अनुक्रमण शून्य से शुरू होता है, नई सरणी में दूसरे, तीसरे और चौथे तत्व होंगे।

धकेलना()

पुश() विधि सरणी के अंत में एक तत्व जोड़ती है:

वर फल = ; फल.पुश('सेब'); फल.पुश('नाशपाती'); फल.पुश('प्लम'); फल.पुश("चेरी","खुबानी
"); document.write(फल); // सेब, नाशपाती, आलूबुखारा, चेरी, खुबानी

जल्दी से आना()

पॉप() विधि सरणी से अंतिम तत्व को हटा देती है:

वर फल = ["सेब", "नाशपाती", "प्लम"]; var अंतिमफल = फल.पॉप(); // सरणी से अंतिम तत्व निकालें document.write(lastFruit + "
"); document.write("सरणी में फल " + फल.लंबाई + " तत्व:
"); for(var i=0; i ");

ब्राउज़र आउटपुट:

प्लम फलों की श्रेणी में 2 तत्व होते हैं: सेब नाशपाती

बदलाव()

शिफ्ट() विधि सरणी से पहला तत्व पुनर्प्राप्त और हटा देती है:

वर फल = ["सेब", "नाशपाती", "प्लम"]; वर फर्स्टफ्रूट = फ्रूट.शिफ्ट(); दस्तावेज़.लिखें(फर्स्टफ्रूट + "
"); document.write("सरणी में फल " + फल.लंबाई + " तत्व:
"); for(var i=0; i ");

ब्राउज़र आउटपुट:

सेब फल श्रृंखला में 2 तत्व होते हैं: नाशपाती प्लम

अनशिफ्ट()

अनशिफ्ट() विधि सरणी की शुरुआत में एक नया तत्व जोड़ती है:

वर फल = ["सेब", "नाशपाती", "प्लम"]; फल.अनशिफ्ट('खुबानी'); दस्तावेज़.लिखें(फल);

ब्राउज़र आउटपुट:

खुबानी, सेब, नाशपाती, प्लम

अनुक्रमणिका द्वारा किसी तत्व को हटाना। ब्याह()

ब्याह () विधि एक विशिष्ट सूचकांक पर तत्वों को हटा देती है। उदाहरण के लिए, तीसरे सूचकांक से तत्वों को हटाना:

वर उपयोगकर्ता = ["टॉम", "सैम", "बिल", "ऐलिस", "केट"]; var हटा दिया गया = उपयोगकर्ता.स्प्लिस(3); कंसोल.लॉग(हटाया गया); // ["ऐलिस", "केट" ] कंसोल.लॉग(उपयोगकर्ता); // ["टॉम", "सैम", "बिल" ]

स्लाइस विधि हटाए गए तत्वों को लौटाती है।

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

वर उपयोगकर्ता = ["टॉम", "सैम", "बिल", "ऐलिस", "केट"]; var हटा दिया गया = उपयोगकर्ता.स्प्लिस(-1); कंसोल.लॉग(हटाया गया); // ["केट" ] कंसोल.लॉग(उपयोगकर्ता); // ["टॉम", "सैम", "बिल", "ऐलिस" ]

विधि का एक अतिरिक्त संस्करण आपको हटाने के लिए अंतिम सूचकांक निर्दिष्ट करने की अनुमति देता है। उदाहरण के लिए, आइए पहले से तीसरे इंडेक्स को हटा दें:

वर उपयोगकर्ता = ["टॉम", "सैम", "बिल", "ऐलिस", "केट"]; var हटा दिया गया = उपयोगकर्ता.स्प्लिस(1,3); कंसोल.लॉग(हटाया गया); // ["सैम", "बिल", "ऐलिस" ] कंसोल.लॉग(उपयोगकर्ता); // ["टॉम", "केट" ]

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

वर उपयोगकर्ता = ["टॉम", "सैम", "बिल", "ऐलिस", "केट"]; var हटा दिया गया = उपयोगकर्ता.स्प्लिस(1,3, "ऐन", "बॉब"); कंसोल.लॉग(हटाया गया); // ["सैम", "बिल", "ऐलिस" ] कंसोल.लॉग(उपयोगकर्ता); // ["टॉम", "ऐन", "बॉब", "केट" ]

इस मामले में, हम पहली से तीसरी सूचकांक तक तीन तत्वों को हटाते हैं और उनके स्थान पर दो तत्वों को सम्मिलित करते हैं।

कॉनकैट()

कॉनकैट () विधि का उपयोग सरणियों को संयोजित करने के लिए किया जाता है:

वर फल = ["सेब", "नाशपाती", "प्लम"]; वर सब्जियाँ = ["टमाटर", "खीरे", "आलू"]; var उत्पाद = फल.concat(सब्जियां); for(var i=0; i< products.length; i++) document.write(products[i] + "
");

इस मामले में, केवल एक ही प्रकार की सरणियों को संयोजित करना आवश्यक नहीं है। विभिन्न प्रकार संभव हैं:

वर फल = ["सेब", "नाशपाती", "प्लम"]; var कीमतें = ; var उत्पाद = फल.concat(कीमतें);

जोड़ना()

Join() विधि किसी सरणी के सभी तत्वों को एक स्ट्रिंग में जोड़ती है:

वर फल = ["सेब", "नाशपाती", "आलूबुखारा", "खुबानी", "आड़ू"]; वर फ्रूटस्ट्रिंग = फ्रूट.जॉइन ("", "); दस्तावेज़.लिखें(फलस्ट्रिंग);

ज्वाइन () विधि को सरणी तत्वों के बीच विभाजक से गुजारा जाता है। इस मामले में, अल्पविराम और रिक्त स्थान (",") का उपयोग विभाजक के रूप में किया जाएगा।

क्रम से लगाना()

सॉर्ट() विधि सरणी को आरोही क्रम में क्रमबद्ध करती है:

वर फल = ["सेब", "नाशपाती", "आलूबुखारा", "खुबानी", "आड़ू"]; फल.सॉर्ट(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

ब्राउज़र आउटपुट:

खुबानी नाशपाती आड़ू आलूबुखारा सेब

रिवर्स()

रिवर्स () विधि सरणी को पीछे की ओर उलट देती है:

वर फल = ["सेब", "नाशपाती", "आलूबुखारा", "खुबानी", "आड़ू"]; फल.रिवर्स(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

ब्राउज़र आउटपुट:

आड़ू खुबानी आलूबुखारा नाशपाती सेब

सॉर्ट() विधि के संयोजन में, आप सरणी को अवरोही क्रम में क्रमबद्ध कर सकते हैं:

वर फल = ["सेब", "नाशपाती", "आलूबुखारा", "खुबानी", "आड़ू"]; फल.सॉर्ट().रिवर्स(); for(var i=0; i< fruit.length; i++) document.write(fruit[i] + "
");

ब्राउज़र आउटपुट:

सेब आलूबुखारा आड़ू नाशपाती खुबानी

किसी तत्व का सूचकांक ढूँढना

IndexOf() और LastIndexOf() विधियाँ सरणी में किसी तत्व के पहले और अंतिम समावेशन का सूचकांक लौटाती हैं। उदाहरण के लिए:

वर फल = ["सेब", "नाशपाती", "आलूबुखारा", "सेब", "नाशपाती"]; var फर्स्टइंडेक्स = फल.इंडेक्सऑफ ("सेब"); var LastIndex = फल.lastIndexOf("सेब"); var अन्यसूचकांक = फल.सूचकांकऑफ('चेरी'); दस्तावेज़.लिखें(फर्स्टइंडेक्स); // 0 दस्तावेज़.लिखें(अंतिमसूचकांक); // 3 दस्तावेज़.लिखें(अन्य इंडेक्स); // -1

फर्स्टइंडेक्स का मान 0 है क्योंकि सरणी में "सेब" लाइन का पहला समावेश इंडेक्स 0 पर है, और अंतिम इंडेक्स 3 पर है।

यदि तत्व सरणी में नहीं है, तो इस स्थिति में IndexOf() और LastIndexOf() विधियाँ मान -1 लौटाती हैं।

प्रत्येक()

प्रत्येक() विधि जाँच करती है कि क्या सभी तत्व एक निश्चित स्थिति से मेल खाते हैं:

वार संख्याएँ = [1, -12, 8, -4, 25, 42 ]; फ़ंक्शन स्थिति (मान, सूचकांक, सरणी) (var परिणाम = गलत; यदि (मान> 0) (परिणाम = सत्य;) वापसी परिणाम;); var उत्तीर्ण = संख्याएँ.प्रत्येक(स्थिति); दस्तावेज़.लिखें(उत्तीर्ण); // असत्य

प्रत्येक() विधि को एक पैरामीटर के रूप में स्थिति का प्रतिनिधित्व करने वाला एक फ़ंक्शन पारित किया जाता है। यह फ़ंक्शन तीन पैरामीटर लेता है:

फ़ंक्शन स्थिति (मान, सूचकांक, सरणी) ( )

मान पैरामीटर वर्तमान सरणी तत्व को पुनरावृत्त होने का प्रतिनिधित्व करता है, सूचकांक पैरामीटर उस तत्व के सूचकांक का प्रतिनिधित्व करता है, और सरणी पैरामीटर सरणी के संदर्भ को पास करता है।

इस फ़ंक्शन में हम कुछ शर्तों के अनुपालन के लिए पारित तत्व मान की जांच कर सकते हैं। उदाहरण के लिए, इस उदाहरण में हम यह देखने के लिए सरणी के प्रत्येक तत्व की जाँच करते हैं कि क्या यह शून्य से अधिक है। यदि यह अधिक है, तो हम सत्य का मान लौटाते हैं, अर्थात तत्व शर्त को पूरा करता है। यदि कम है, तो गलत लौटाएँ - तत्व शर्त को पूरा नहीं करता है।

परिणामस्वरूप, जब number.every(condition) विधि को कॉल किया जाता है, तो यह संख्या सरणी के सभी तत्वों के माध्यम से पुनरावृत्त होता है और उन्हें एक-एक करके कंडीशन फ़ंक्शन में भेजता है। यदि यह फ़ंक्शन सभी तत्वों के लिए सत्य लौटाता है, तो प्रत्येक() विधि सत्य लौटाती है। यदि कम से कम एक तत्व शर्त से मेल नहीं खाता है, तो प्रत्येक() विधि गलत लौटाती है।

कुछ()

कुछ() विधि प्रत्येक() विधि के समान है, केवल यह जांचती है कि कम से कम एक तत्व किसी शर्त से मेल खाता है या नहीं। और इस मामले में, some() विधि true लौटाती है। यदि सरणी में स्थिति से मेल खाने वाले कोई तत्व नहीं हैं, तो गलत लौटाया जाता है:

वार संख्याएँ = [1, -12, 8, -4, 25, 42 ]; फ़ंक्शन स्थिति (मान, सूचकांक, सरणी) (var परिणाम = गलत; यदि (मूल्य === 8) (परिणाम = सत्य;) वापसी परिणाम;); var पारित = संख्याएँ.कुछ(स्थिति); // सत्य

फ़िल्टर()

फ़िल्टर() विधि, some() और Every() की तरह, एक शर्त फ़ंक्शन स्वीकार करती है। लेकिन साथ ही यह उन तत्वों की एक श्रृंखला लौटाता है जो इस शर्त को पूरा करते हैं:

वार संख्याएँ = [1, -12, 8, -4, 25, 42 ]; फ़ंक्शन स्थिति (मान, सूचकांक, सरणी) (var परिणाम = गलत; यदि (मान> 0) (परिणाम = सत्य;) वापसी परिणाम;); var फ़िल्टर किए गए नंबर = नंबर.फ़िल्टर (स्थिति); for(var i=0; i< filteredNumbers.length; i++) document.write(filteredNumbers[i] + "
");

ब्राउज़र आउटपुट:

1 8 25 42

प्रत्येक के लिए() और मानचित्र()

forEach() और मैप() विधियां तत्वों पर पुनरावृति करती हैं और उन पर कुछ ऑपरेशन करती हैं। उदाहरण के लिए, किसी सरणी में संख्याओं के वर्गों की गणना करने के लिए, आप निम्नलिखित कोड का उपयोग कर सकते हैं:

वर संख्याएँ = [1, 2, 3, 4, 5, 6]; for(var i = 0; i "); }

लेकिन forEach() विधि का उपयोग करके आप इस निर्माण को सरल बना सकते हैं:

वर संख्याएँ = [1, 2, 3, 4, 5, 6]; फ़ंक्शन वर्ग (मान, सूचकांक, सरणी) (var परिणाम = मान * मान; दस्तावेज़.लिखें ("संख्या का वर्ग" + मान + "है" + परिणाम + "
"); ); संख्याएं.प्रत्येक के लिए(वर्ग);

forEach() विधि एक पैरामीटर के रूप में उसी फ़ंक्शन को लेती है, जिसमें, तत्वों पर पुनरावृत्ति करते समय, वर्तमान तत्व को पुनरावृत्त किया जाता है और उस पर संचालन किया जाता है।

मैप() विधि forEach विधि के समान है; यह एक पैरामीटर के रूप में एक फ़ंक्शन भी लेता है जो सरणी के तत्वों पर संचालन करता है, लेकिन मैप() विधि सरणी तत्वों पर संचालन के परिणामों के साथ एक नई सरणी लौटाती है।

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

वर संख्याएँ = [1, 2, 3, 4, 5, 6]; फ़ंक्शन वर्ग (मान, सूचकांक, सरणी) (वापसी परिणाम = मान * मान; ); var वर्गअरे = संख्याएँ.मानचित्र(वर्ग); दस्तावेज़.लिखें(स्क्वायरएरे);

जो फ़ंक्शन मानचित्र() विधि को पास किया जाता है वह वर्तमान तत्व को पुनरावृत्त होने पर प्राप्त करता है, उस पर संचालन करता है और कुछ मान लौटाता है। यह मान फिर परिणामी वर्गअरे में चला जाता है