सरणी। पुश जावास्क्रिप्ट उदाहरण

ऐरे कंस्ट्रक्टर द्वारा प्रदान किए गए विभिन्न तरीकों का उपयोग करके एरे को हेरफेर किया जा सकता है।

पॉप / पुश और शिफ्ट / अनशिफ्ट मेथड

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

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

वार फू \u003d; // foo: foo.push (1,2); // foo: रिटर्न 2 foo.pop (); // foo: रिटर्न 2 foo.push (3); // foo: रिटर्न 2 foo.pop (); // foo: रिटर्न 3 foo.push (); // foo:] रिटर्न 2 foo.pop () // foo: रिटर्न foo.pop (); // foo: 1 var फल देता है \u003d ["नाशपाती", "केले", "सेब"]; var उठाया \u003d फल.पॉप (); document.write ("आपने मुझे चुना" + उठाया); प्रयत्न "

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

वर च \u003d; // f: f.unshift (1); // f: रिटर्न: 1 f.unshift (22); // f: रिटर्न: 2 f.shift (); // f: रिटर्न: 22 f.unshift (3,); // f :, 1] रिटर्न: 3 f.shift (); // f: [, 1] रिटर्न: 3 f.shift (); // f: रिटर्न: f.shift (); // f: रिटर्न: 1

विधि से जुड़ें

Array.join () विधि का उपयोग किसी सरणी के तत्वों को एक स्ट्रिंग में संयोजित करने के लिए किया जाता है। आप विधि के लिए एक वैकल्पिक स्ट्रिंग तर्क पारित कर सकते हैं, जिसका उपयोग स्ट्रिंग में तत्वों को अलग करने के लिए किया जाएगा। यदि कोई सीमांकक निर्दिष्ट नहीं है, तो विधि कहा जाता है जब डिफ़ॉल्ट सीमांकक वर्ण अल्पविराम होता है।

वार ए \u003d ["विंड", "रेन", "फायर"]; var myVar1 \u003d a.join (); // "विंड, रेन, फायर" var myVar2 \u003d a.join (","); // "विंड, रेन, फायर" var myVar3 \u003d a.join ("+"); // "विंड + रेन + फायर" डॉक्यूमेंट.राइट (myVar1 + "
"+ myVar2 +"
"+ myVar3); कोशिश करें"

Array.join () विधि String.split () विधि के विपरीत है, जो एक स्ट्रिंग को विखंडू में विभाजित करके एक सरणी बनाती है।

रिवर्स विधि

Array.reverse () विधि सरणी में तत्वों के क्रम को उलट देती है और पुनर्व्यवस्थित तत्वों के साथ सरणी लौटाती है। यह विधि पुन: व्यवस्थित तत्वों के साथ एक नया सरणी नहीं बनाता है, लेकिन पहले से मौजूद सरणी में उन्हें फिर से व्यवस्थित करता है।

वार myArr \u003d ["एक", "दो", "तीन"]; document.write (myArr.reverse ()); प्रयत्न "

संक्षिप्त विधि

Array.concat () विधि एक नई सरणी बनाता है और मूल सरणी के तत्वों से युक्त एक नया सरणी देता है, जिस पर concat () विधि को कहा जाता था, क्रमिक रूप से गद्य को सभी तर्कों के मानों (जिसे) विधि से पारित किया गया था। यदि इनमें से कोई भी तर्क स्वयं एक सरणी है, तो इसके सभी तत्व जोड़े जाएंगे। एरे नामों का उपयोग तर्कों के रूप में किया जाता है और उस क्रम में निर्दिष्ट किया जाता है जिसमें आप उनके तत्वों को संक्षिप्त करना चाहते हैं।

वार a \u003d; a.concat (4, 5) // रिटर्न a.concat (); // एक ही बात - रिटर्न a.concat (,) // रिटर्न

क्रमबद्ध विधि

Array.sort () विधि सरणी के तत्वों को जगह में सॉर्ट करती है और सॉर्ट किए गए सरणी को वापस करती है। यदि सॉर्ट () विधि को बिना किसी तर्क के कहा जाता है, तो यह सरणी के तत्वों को वर्णानुक्रम में (अस्थायी रूप से उन्हें तुलना के लिए तार में परिवर्तित करता है)। सॉर्ट () विधि एक तर्क के रूप में तुलनात्मक फ़ंक्शन ले सकती है, जो वस्तुओं के क्रम क्रम को निर्धारित करती है।

वार ए \u003d ["कीवी", "संतरे", "नाशपाती"]; एक प्रकार (); var s \u003d a.join (","); // संतरे, नाशपाती, कीवी डॉक्यूमेंट.राइट (एस); // संख्या के साथ उदाहरण var myArr \u003d; myArr.sort (); document.write (myArr); // 1,10,2 कोशिश "

आपको शायद संख्याओं को क्रमबद्ध करने से थोड़ा अलग परिणाम देखने की उम्मीद है। यह सॉर्ट प्रकार होता है क्योंकि सॉर्ट () विधि तत्वों को स्ट्रिंग्स में कनवर्ट करके सॉर्ट करती है। इसलिए, उन्हें जो आदेश मिलता है वह कठोर है - आखिरकार, "10"

किसी अन्य गैर-वर्णानुक्रम क्रम में सॉर्ट करने के लिए, आप सॉर्ट करने के लिए एक तर्क के रूप में एक तुलना फ़ंक्शन पास कर सकते हैं ()। हालाँकि, ध्यान दें कि आपको तुलनात्मक कार्य स्वयं लिखना होगा। इस फ़ंक्शन के दो पैरामीटर होने चाहिए, क्योंकि यह सेट करता है कि इसके दो तर्क किस क्रमबद्ध सूची में पहले प्रदर्शित होने चाहिए। ऐसे फ़ंक्शन को समझना और लिखना आसान बनाने के लिए, कई नियम हैं जिनके द्वारा तत्वों का क्रम निर्धारित किया जाएगा:

• यदि पहले तर्क को दूसरे से पहले होना चाहिए, तो तुलनात्मक फ़ंक्शन एक ऋणात्मक संख्या देता है (यदि ए
• यदि पहले तर्क को दूसरे का पालन करना चाहिए, तो तुलना फ़ंक्शन एक सकारात्मक संख्या देता है (यदि a\u003e b)
• यदि दो मान समतुल्य हैं (यानी, उनका क्रम महत्वपूर्ण नहीं है), तो तुलनात्मक फ़ंक्शन 0 (यदि a \u003d b) है तो

तुलना के लिए, फ़ंक्शन अपने तर्क के रूप में सरणी तत्वों का उपयोग करता है:

फ़ंक्शन फू (ए, बी) (// एक परीक्षण फ़ंक्शन को परिभाषित करता है अगर (बी) वापसी 1; वापसी 0; // अगर \u003d\u003d बी) var a \u003d; a.sort (foo); // केवल फ़ंक्शन नाम को एक तर्क दस्तावेज़ के रूप में पारित किया जाता है। राइट (a.join (",")); // एक ही चीज़ को कम लिखें var a \u003d; a.sort (फ़ंक्शन (a, b) (// अनाम फ़ंक्शन रिटर्न a - b; // फ़ंक्शन रिटर्न 0) का उपयोग करें); document.write (a); // 1,2,5,10 यह कोशिश करो "

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

नोट: यदि सरणी में अपरिभाषित तत्व हैं, तो वे सरणी के अंत तक लपेटते हैं।

स्लाइस विधि

सरणी से निर्दिष्ट क्षेत्र की प्रतिलिपि बनाने के लिए Array.slice () विधि का उपयोग किया जाता है और कॉपी किए गए तत्वों से युक्त एक नया सरणी देता है। यह मूल सरणी को नहीं बदलता है।

विधि सिंटैक्स:

ArrayName.slice (शुरू, अंत);

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

वर गिरफ्त \u003d; arr.slice (0.3); // रिटर्न गिरफ्तारी। स्लाइस (3); // रिटर्न अरेस्ट।स्लीस (1, -1); // रिटर्न गिरफ्तारी ।lice (-3, -2); // लौटता है

ब्याह विधि

Array.splice () विधि सरणियों के साथ काम करने के लिए एक सामान्य विधि है। यह स्लाइस () और कॉनकट () विधियों की तरह एक नया संशोधित सरणी वापस करने के बजाय, जगह में सरणी को संशोधित करता है। ब्याह विधि एक सरणी से तत्वों को निकाल सकती है, नए तत्वों को सम्मिलित कर सकती है, तत्वों को बदल सकती है - एक बार में और एक साथ। यह हटाए गए तत्वों की एक सरणी देता है, यदि कोई भी तत्व हटाया नहीं गया था, तो यह एक खाली सरणी लौटाएगा।

विधि सिंटैक्स:

ArrayName.splice (इंडेक्स, मात्रा, एलएम 1, ..., एलएमएन);

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

वर फल \u003d ["संतरे", "सेब", "नाशपाती", "अंगूर"]; var हटाए गए \u003d fruit.splice (2,2); // रिटर्न ["नाशपाती", "अंगूर"] document.write (हटाए गए); var गिरफ्तारी \u003d; arr.splice (4); // लौटता है; सरणी अब है: arr.splice (1,2); // लौटता है; सरणी बन गया: arr.splice (1,1); // लौटता है; सरणी बन गई है: आज़माएं "

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

वर फल \u003d ["संतरे", "सेब"]; fruit.splice (2,0, "तरबूज"); // रिटर्न डॉक्यूमेंट.राइट (फल); // अब ["संतरे", "सेब", "तरबूज"] var arr \u003d; arr.splice (2,0, "ए", "बी"); // लौटता है; arr.splice (2,2,) बन गया; // रिटर्न ["ए", "बी"]; बन गया, 3,4,5] कोशिश करो "

ध्यान दें कि कॉनैट () के विपरीत, ब्याह () विधि अलग-अलग तत्वों में तर्क के रूप में पारित सरणियों को विभाजित नहीं करती है। यही है, अगर किसी सरणी को सम्मिलन के लिए एक विधि को पारित किया जाता है, तो यह सरणी को सम्मिलित करता है, न कि उस सरणी के तत्वों को।

तना विधि

TheString () विधि एक सरणी के तत्वों को विभाजक वर्ण के रूप में अल्पविराम का उपयोग करके स्ट्रिंग में परिवर्तित करती है।

वार गिरफ्तार \u003d ["दूध", "रोटी", "कुकीज़"]; var खाना \u003d arr.toString (); document.write (भोजन); // दूध, ब्रेड, कुकीज़ इसे आज़माएं "

ध्यान दें कि विधि एक ही स्ट्रिंग को रिटर्न में शामिल करती है () जब कोई तर्क नहीं कहा जाता है।

indexOf और lastIndexOf

इंडेक्सऑफ विधि एक तत्व के सूचकांक को लौटाती है जिसका मान तर्क के रूप में विधि के लिए पारित मूल्य के बराबर है।

IndexOf () और lastIndexOf () विधियों के लिए सिंटैक्स है:

Array_name.indexOf (looking_item, index) array_name.lastIndexOf (लुकअप_इटेम, इंडेक्स)

विधि का पहला तर्क उस तत्व के मूल्य को निर्दिष्ट करता है जिसका सूचकांक ढूंढना है, दूसरा तर्क (वैकल्पिक) उस सूचकांक को निर्दिष्ट करता है जिससे खोज शुरू करनी है। यदि कई समान घटनाएं होती हैं, तो सबसे छोटा (पहला) सूचकांक चुना जाता है। यदि वांछित मान वाला कोई तत्व नहीं मिला है, तो विधि -1 वापस आ जाएगी। विधि के अंदर, खोज के लिए सख्त तुलना (\u003d\u003d\u003d) का उपयोग किया जाता है।

वार a \u003d; a.indexOf (3); // 2 वापसी करेगा a .indexOf (3,4); // 6 a.indexOf (35) लौटाएगा; // रिटर्न -1: इस मान के साथ कोई तत्व नहीं है। aindexOf (2); // 1

LastIndexOf () विधि एक तत्व के सूचकांक को भी लौटाती है, जिसका मूल्य तर्क के रूप में विधि के लिए पारित मूल्य के बराबर है। अंतर केवल इतना है कि lastIndexOf () विधि उच्चतम (अंतिम) इंडेक्स का चयन करती है।

वार a \u003d; a.lastIndexOf (3); // 7. a.lastIndexOf (35) लौटाएगा; // रिटर्न -1: इस मान के साथ कोई तत्व नहीं है। alastIndexOf (2); // 6

Iterator विधियाँ

नीचे वर्णित तरीके पुनरावृत्तियों हैं। सरणियों के साथ काम करने के लिए सभी आधुनिक ब्राउज़रों में ऐसे तरीके हैं जो तत्वों पर पुनरावृति करने और उन पर विभिन्न कार्य करने के लिए डिज़ाइन किए गए हैं। ये फॉरएच (), मैप (), फिल्टर (), हर (), कुछ, कम () और कम करना () तरीके हैं।

वे 0 से लंबाई - 1 तक सरणी तत्वों पर पुनरावृति करते हैं और यदि तत्व मौजूद है, तो इसे कॉलबैक हैंडलर फ़ंक्शन में पास करें।

प्रत्येक के लिए

विधि सिंटैक्स:

ArrayName.forEach (कॉलबैक, thisArg)

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

वर गिरफ्त \u003d; फ़ंक्शन फू (मान) (var sum \u003d value * this; return document.write (योग +)
");) arr.forEach (foo, 5); // दूसरे तर्क को इस मान के रूप में पारित किया जाएगा। उदाहरण के लिए तीन पैरामीटर var a \u003d; a.forEach (फ़ंक्शन (el, idx), a (document.write () "ए [" + आईडीएक्स + "] \u003d" + एल + "में [" + ए + "]
");)); प्रयत्न"

फिल्टर

विधि सिंटैक्स:

Arrayname.filter (कॉलबैक, यह ऑबजेक्ट)

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

फंक्शनबिग (तत्व, इंडेक्स, एरे) (// रिटर्न नंबर्स जो कि 10 रिटर्न (एलिमेंट \u003d \u003d 10) से अधिक या उसके बराबर हैं; अगर एलिमेंट वैल्यू 10 से अधिक या उसके बराबर है, तो एक्सप्रेशन वापस आ जाएगा) var फिल्टर्ड \u003d .figter (isBig) ; // छाना हुआ

नक्शा

नक्शा () विधि एक नई सरणी बनाता है और वापस करता है, जिसमें सरणी में प्रत्येक तत्व के लिए कॉलबैक (आइटम, आईडीएक्स, एआर) फ़ंक्शन को कॉल करने के परिणाम शामिल होंगे।

वार a \u003d; var b \u003d a.map (फ़ंक्शन (आइटम, आईडीएक्स, अरेस्ट) (वापसी आइटम * आइटम;)); // बी \u003d

हर और कुछ

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

निर्दिष्ट फ़ंक्शन में सत्यापन के दौरान कुछ () विधि सही हो जाती है, एक या अधिक तत्व सही होते हैं।

वार a \u003d; a.every (फ़ंक्शन (x) (रिटर्न x 10;)) // true: एक संख्या\u003e 10

कम करें और कम करें

विधि सिंटैक्स:

ArrayName.reduce (कॉलबैक, initialValue) ArrayName.reduceRight (कॉलबैक, initialVue)

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

कॉलबैक फ़ंक्शन के तर्क: (पिछलेवैल्यू, करेंटइम, इंडेक्स, एरे)

• पिछलाValue - कॉलबैक फ़ंक्शन का रिटर्न परिणाम (उर्फ मध्यवर्ती परिणाम)
• currentItem - सरणी में वर्तमान आइटम (आइटम बदले में बाएं से दाएं से पुनरावृत्त होते हैं)
• सूचकांक - वर्तमान तत्व का सूचकांक
• सरणी - संसाधित की जा रही सरणी

initialValue कॉलबैक फ़ंक्शन के पहले कॉल के पहले तर्क के रूप में उपयोग की जाने वाली वस्तु। सरल शब्दों में, पिछलेवैल्यू का मूल्य प्रारंभिकवैल्यू के बराबर है जिसे पहली बार कहा जाता है। यदि आरंभिक अनुपस्थित है, तो यह सरणी के पहले तत्व के बराबर है, और पुनरावृति दूसरे से शुरू होती है:

वार a \u003d; function foo (prevNum, curNum) (sum \u003d prevNum + curNum; अलर्ट (sum); वापसी राशि;) var result \u003d a.reduce (foo, 0); document.write (परिणाम); प्रयत्न "

आइए देखें कि यह उदाहरण कैसे काम करता है। फू करने के लिए पहले तर्क हैं:

• prevNum \u003d 0 (चूंकि आरंभिक संस्करण 0 है)
• curNum \u003d 1 (वर्तमान तत्व सरणी का पहला तत्व है)

संख्या 0 को 1. में जोड़ा गया है। यह परिणाम (योग: 1) अगली बार फ़ंक्शन के चलने के रूप में पारित किया जाएगा। और इसलिए जब तक यह अंतिम तत्व की बात नहीं आती। लौटा परिणाम - अंतिम रन से योग, 15 (1 + 2 + 3 + 4 + 5) होगा।

कम करने की विधि कम करने की विधि के समान काम करती है, लेकिन दाईं ओर से बाईं ओर सरणी के माध्यम से जाती है:

वार ए \u003d ["एच", "ओ", "एम", "ई"]; function bar (prevStr, curItem) (वापसी prevStr + curItem;) document.write (a.reduceRight (बार)); // इमो

Arrays

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

जावास्क्रिप्ट में ऐरे इंडेक्स शून्य-आधारित हैं और 32-बिट पूर्णांक का उपयोग करते हैं - किसी सरणी के पहले तत्व में सूचकांक 0. है। जावास्क्रिप्ट सरणियां गतिशील हैं: वे आवश्यकतानुसार बढ़ सकते हैं और सिकुड़ सकते हैं; जब वे बनाए जाते हैं या स्मृति का पुन: आबंटन किया जाता है, तो उन्हें निश्चित आकार के सरणियों की घोषणा करने की आवश्यकता नहीं होती है।

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

सरणियाँ बनाना

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

वार खाली \u003d; // खाली सरणी var संख्या \u003d; // पांच संख्यात्मक तत्वों के साथ सरणी misc \u003d [1.1, सच, "a"]; // विभिन्न प्रकार के 3 तत्व + अनुगामी अल्पविराम var बेस \u003d 1024; var तालिका \u003d; // चर के साथ सरणी var arrbbj \u003d [,]; // 2 सरणियों जिसमें ऑब्जेक्ट शामिल हैं

सरणी शाब्दिक वाक्यविन्यास आपको एक वैकल्पिक अनुगामी अल्पविराम सम्मिलित करने की अनुमति देता है, अर्थात। शाब्दिक [,] दो तत्वों के साथ एक सरणी से मेल खाता है, तीन नहीं।

एक सरणी बनाने का एक और तरीका है, निर्माता को कॉल करना ऐरे ()... कंस्ट्रक्टर को तीन अलग-अलग तरीकों से बुलाया जा सकता है:

निर्माता को बिना किसी तर्क के बुलाएँ:

वर गिरफ्तारी \u003d नया ऐरे ();

इस मामले में, शाब्दिक के बराबर एक खाली सरणी बनाई जाएगी।

व्यूह की लंबाई निर्दिष्ट करने वाले एकल संख्यात्मक तर्क के साथ निर्माता को कॉल करें:

वार गिरफ्तार \u003d नया ऐरे (10);

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

स्पष्ट रूप से पहले दो या दो से अधिक सरणी तत्वों या एक गैर-संख्यात्मक तत्व को एक निर्माता कॉल में निर्दिष्ट करें:

वार गिरफ्तार \u003d नया ऐरे (5, 4, 3, 2, 1, "परीक्षण");

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

सरणी तत्वों को पढ़ना और लिखना

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

// एक तत्व के साथ एक सरणी बनाएं var arr \u003d ["दुनिया"]; // पढ़ें आइटम 0 संस्करण मान \u003d गिरफ्तारी; // तत्व 1 अरेस्ट \u003d 3.14 के लिए मान लिखें; // तत्व 2 i \u003d 2 के लिए एक मूल्य लिखें; arr [i] \u003d 3; // तत्व 3 अरेस्ट \u003d "हैलो" का मान लिखें; // आइटम 0 और 2 पढ़ें, आइटम 3 अरेस्ट का मूल्य लिखें] \u003d arrest;

मुझे आपको याद दिलाना है कि सरणियाँ एक विशेष प्रकार की वस्तु हैं। सरणी तत्वों तक पहुँचने के लिए उपयोग किए जाने वाले वर्ग कोष्ठक उसी तरह कार्य करते हैं जैसे कि वर्ग कोष्ठक ऑब्जेक्ट गुणों तक पहुँचने के लिए उपयोग किए जाते हैं। जावास्क्रिप्ट दुभाषिया कोष्ठक के संख्यात्मक सूचकांक को स्ट्रिंग्स में परिवर्तित करता है - इंडेक्स 1 स्ट्रिंग "1" बन जाता है - और फिर प्रॉपर्टी के नाम के रूप में स्ट्रिंग्स का उपयोग करता है।

संख्यात्मक सूचकांकों को तार में बदलने के बारे में कुछ खास नहीं है: नियमित वस्तुओं के साथ भी ऐसा ही किया जा सकता है:

वार obj \u003d (); // एक साधारण वस्तु बनाएं obj \u003d "एक"; // इसे पूर्णांक के साथ अनुक्रमित करें

सरणियों की ख़ासियत यह है कि गैर-नकारात्मक पूर्णांक वाले गुण नामों का उपयोग करते समय, सरणियाँ स्वचालित रूप से संपत्ति का मूल्य निर्धारित करती हैं लंबाई... उदाहरण के लिए, गिरफ्तारी सरणी ऊपर एक एकल तत्व के साथ बनाई गई थी। फिर, मान 1, 2, और 3 के साथ इसके तत्वों को सौंपा गया था। इन कार्यों के परिणामस्वरूप, सरणी की लंबाई संपत्ति का मान बदल गया और 4 के बराबर हो गया।

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

ध्यान दें कि ऋणात्मक और गैर-पूर्णांक को सरणी सूचक के रूप में अनुमति दी गई है। इस स्थिति में, संख्याएं स्ट्रिंग्स में परिवर्तित हो जाती हैं जो कि संपत्ति के नाम के रूप में उपयोग की जाती हैं।

ऐरे तत्वों को जोड़ना और हटाना

हमने पहले ही देखा है कि किसी सरणी में तत्वों को जोड़ने का सबसे आसान तरीका नए सूचकांकों को मान असाइन करना है। आप किसी सरणी के अंत में एक या अधिक तत्वों को जोड़ने के लिए विधि का उपयोग कर सकते हैं धक्का दें ():

वर गिरफ्त \u003d; // एक खाली ऐरे अरेस्ट बनाएं। पश ("शून्य"); // अंत arr.push के लिए एक मान जोड़ें ("एक", 2); // दो और मान जोड़ें

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

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

वर गिरफ्त \u003d; गिरफ्तारी हटाना; 2 में गिरफ्तारी; // गलत, सरणी में सूचकांक 2 अपरिभाषित गिरफ्तारी है। // 3: हटाए गए ऑपरेटर सरणी की लंबाई संपत्ति को नहीं बदलता है

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

केवल लंबाई के गुण के लिए एक नया मान प्रदान करके किसी सरणी के अंत में तत्वों को निकालना भी संभव है। Arrays में एक विधि है पॉप () (पुश के विपरीत ()), जो सरणी की लंबाई 1 से कम कर देता है और हटाए गए तत्व का मान लौटाता है। एक विधि भी है खिसक जाना () (unshift () के विपरीत), जो एरे की शुरुआत में तत्व को हटा देता है। डिलीट ऑपरेटर के विपरीत, शिफ्ट () विधि सभी तत्वों को उनके वर्तमान सूचकांकों के नीचे एक स्थान से नीचे ले जाती है।

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

बहुआयामी सरणियाँ

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

उदाहरण के लिए, मान लीजिए कि चर मैट्रिक्स संख्याओं के सारणी का एक सरणी है। मैट्रिक्स का प्रत्येक तत्व [x] संख्याओं की एक सरणी है। आप किसी सरणी में किसी विशिष्ट संख्या तक पहुँचने के लिए एक्सप्रेशन मैट्रिक्स [x] [y] का उपयोग कर सकते हैं। नीचे एक विशिष्ट उदाहरण दिया गया है जहां एक दो-आयामी सरणी का उपयोग गुणन तालिका के रूप में किया जाता है:

// एक बहुआयामी सरणी बनाएं var तालिका \u003d नया ऐरे (10); // तालिका में 10 पंक्तियाँ हैं (var i \u003d 0; i)

एरे क्लास के तरीके

ECMAScript 3 मानक Array.prototype के भाग के रूप में सरणियों के साथ काम करने के लिए कई सुविधाजनक कार्यों को परिभाषित करता है, जो किसी भी सरणी के तरीकों के रूप में उपलब्ध हैं। इन विधियों को निम्नलिखित उप-वर्गों में प्रस्तुत किया जाएगा।

सम्मिलित हों () विधि

Array.join () विधि सरणी के सभी तत्वों को स्ट्रिंग्स में परिवर्तित करती है, उन्हें समेटती है, और परिणामस्वरूप स्ट्रिंग लौटाती है। एक वैकल्पिक तर्क को एक स्ट्रिंग के साथ विधि में पारित किया जा सकता है जिसका उपयोग परिणाम स्ट्रिंग में अलग-अलग मदों के लिए किया जाएगा। यदि कोई सीमांकक स्ट्रिंग निर्दिष्ट नहीं है, तो अल्पविराम का उपयोग किया जाता है। उदाहरण के लिए, निम्नलिखित स्निपेट का परिणाम "1,2,3" स्ट्रिंग में है:

वर गिरफ्त \u003d; arr.join (); // "1,2,3" arr.join ("-"); // "1-2-3"

रिवर्स () विधि

Array.reverse () विधि एक सरणी में तत्वों के क्रम को उलट देती है और एक पुन: क्रमबद्ध सरणी देता है। क्रमांकन मूल सरणी पर सीधे किया जाता है, अर्थात यह विधि पुन: व्यवस्थित तत्वों के साथ एक नई सरणी नहीं बनाता है, लेकिन पहले से मौजूद सरणी में उन्हें फिर से व्यवस्थित करता है। उदाहरण के लिए, निम्नलिखित स्निपेट, जो रिवर्स () और जॉइन () विधियों का उपयोग करता है, परिणाम स्ट्रिंग में "3,2,1":

वर गिरफ्त \u003d; arr.reverse ()। join (); // "3,2,1"

क्रमबद्ध () विधि

Array.sort () विधि मूल सरणी में तत्वों को क्रमबद्ध करती है और क्रमबद्ध सरणी को वापस करती है। यदि सॉर्ट () को बिना किसी तर्क के कहा जाता है, तो सॉर्टिंग वर्णानुक्रम से की जाती है (तुलना के लिए, आइटम अस्थायी रूप से आवश्यक रूप से स्ट्रिंग्स में परिवर्तित हो जाते हैं)। अपरिभाषित तत्व सरणी के अंत तक लिपटे हुए हैं।

आप किसी अन्य गैर-वर्णानुक्रम क्रम में सॉर्ट करने के लिए एक तर्क के रूप में एक तुलना फ़ंक्शन पास कर सकते हैं। यह फ़ंक्शन सेट करता है कि इसके दो तर्क किस क्रमबद्ध सूची में पहले आने चाहिए। यदि पहले तर्क को दूसरे से पहले होना चाहिए, तो तुलनात्मक फ़ंक्शन को एक ऋणात्मक संख्या वापस करना होगा। यदि पहले तर्क को सॉर्ट किए गए सरणी में दूसरे का पालन करना है, तो फ़ंक्शन को शून्य से अधिक संख्या में वापस करना होगा। और यदि दो मान समतुल्य हैं (यानी, आदेश महत्वपूर्ण नहीं है), तो तुलनात्मक फ़ंक्शन 0 पर लौटना चाहिए:

वर गिरफ्त \u003d; arr.sort (); // वर्णानुक्रम क्रम: 1111, 222, 33, 4 गिरफ्तारी (कार्य (ए, बी) (// संख्यात्मक क्रम: 4, 33, 222, 1111 वापसी अब; // रिटर्न मान 0 // सॉर्ट क्रम पर निर्भर करता है; ए और बी)); // पीछे से क्रमबद्ध करें, उच्चतम से सबसे कम गिरफ्तारी से। सॉर्ट (फ़ंक्शन (ए, बी) (रिटर्न बी-ए));

ध्यान दें कि इस स्निपेट में एक अनाम फ़ंक्शन का उपयोग करना कितना सुविधाजनक है। तुलनात्मक फ़ंक्शन केवल यहां उपयोग किया जाता है, इसलिए इसे कोई नाम देने की आवश्यकता नहीं है।

समतल () विधि

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

वर गिरफ्त \u003d; arr.concat (4, 5); // रिटर्न गिरफ्तारी। कॉनकट (); // रिटर्न गिरफ्तारी ।concat (,) // रिटर्न गिरफ्तार ।concat (4,]) // रिटर्न]

स्लाइस () विधि

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

यदि केवल एक तर्क निर्दिष्ट किया गया है, तो लौटे हुए सरणी में आरंभ स्थिति से अंत तक के सभी तत्व समाहित हैं। यदि कोई भी तर्क नकारात्मक है, तो यह सरणी के अंत के सापेक्ष तत्व संख्या को निर्दिष्ट करता है। इस प्रकार, तर्क -1 सरणी के अंतिम तत्व से मेल खाती है, और तर्क -3 अंत से सरणी के तीसरे तत्व से मेल खाती है। यहाँ कुछ उदाहरण हैं:

वर गिरफ्त \u003d; arr.slice (0.3); // रिटर्न गिरफ्तारी। स्लाइस (3); // रिटर्न अरेस्ट।स्लीस (1, -1); // रिटर्न गिरफ्तारी ।lice (-3, -2); // वापस होगा

ब्याह () विधि

Array.splice () विधि एक सामान्य विधि है जो किसी सरणी से तत्वों को सम्मिलित या हटाती है। स्लाइस () और कॉनैट () विधियों के विपरीत, ब्याह () विधि मूल सरणी को संशोधित करती है जिस पर इसे बुलाया गया था। ध्यान दें कि स्प्लिस () और स्लाइस () विधियों में बहुत समान नाम हैं, लेकिन पूरी तरह से अलग संचालन करते हैं।

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

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

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

वर गिरफ्त \u003d; arr.splice (4); // रिटर्न गिरफ्तार \u003d arr.splice (1,2); // रिटर्न गिरफ्तार \u003d arr.splice (1,1); // वापस होगा; arr \u003d arrest \u003d; arr.splice (2,0, "ए", "बी"); // वापस होगा; गिरफ्तारी \u003d

पुश () और पॉप () विधियाँ

पुश () और पॉप () तरीके आपको स्टैक जैसे सरणियों के साथ काम करने देते हैं। पुश () विधि सरणी के अंत में एक या एक से अधिक नए तत्व जोड़ता है और इसकी नई लंबाई लौटाता है। पॉप () विधि विपरीत ऑपरेशन करती है - यह सरणी के अंतिम तत्व को हटा देती है, सरणी की लंबाई कम कर देती है, और इसे हटाए गए मान को वापस कर देती है। ध्यान दें कि ये दोनों विधियाँ इसकी एक संशोधित प्रति बनाने के बजाय मूल सरणी को संशोधित करती हैं।

अनशिफ्ट () और शिफ्ट () तरीके

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

धक्का दें () विधि किसी सरणी के अंत में एक या अधिक तत्व जोड़ता है और सरणी की नई लंबाई देता है।

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

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

गिरफ्तारी .push (element1 [, ... [, elementN]])

पैरामीटर

तत्त्व एन सरणी के अंत में जोड़ने के लिए तत्व (एस)।

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

उदाहरण

एक सरणी में तत्वों को जोड़ना

निम्नलिखित कोड दो तत्वों वाले खेल सरणी बनाता है, फिर इसमें दो तत्वों को जोड़ता है। कुल चर में सरणी की नई लंबाई है।

चलो खेल \u003d ["फुटबॉल", "बेसबॉल"] कुल \u003d sports.push ("फुटबॉल", "तैराकी") कंसोल.लॉग (खेल) // ["फुटबॉल", "बेसबॉल", "फुटबॉल", "तैराकी" दें "" कंसोल.लॉग (कुल) // 4

दो सरणियों विलय

यह उदाहरण एक दूसरे सरणी से सभी तत्वों को धकेलने के लिए लागू () का उपयोग करता है।

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

सब्जियों को दें Array.prototype.push.apply (सब्जियां, moreVegs) कंसोल.लॉग (सब्जियां) // ["पारसिप", "आलू", "अजवाइन", "चुकंदर"]

किसी सरणी-जैसी फ़ैशन में किसी ऑब्जेक्ट का उपयोग करना

जैसा कि ऊपर उल्लेख किया गया है, पुश जानबूझकर सामान्य है, और हम इसका उपयोग अपने लाभ के लिए कर सकते हैं। Array.prototype.push किसी ऑब्जेक्ट पर ठीक काम कर सकता है, जैसा कि यह उदाहरण दिखाता है।

ध्यान दें कि हम वस्तुओं के संग्रह को संग्रहीत करने के लिए एक सरणी नहीं बनाते हैं। इसके बजाय, हम संग्रह को ऑब्जेक्ट पर स्वयं संग्रहित करते हैं और Array.prototype.push पर कॉल का उपयोग करते हुए उस पद्धति को सोचने के लिए ट्रिक करते हैं जिसे हम एक सरणी के साथ काम कर रहे हैं-और बस काम करता है, जिस तरह से जावास्क्रिप्ट हमें निष्पादन संदर्भ स्थापित करने की अनुमति देता है, हालांकि हम कृपया।

आज्ञा दें \u003d (लंबाई: 0, addElem: फ़ंक्शन addElem (elem) (// obj.length स्वचालित रूप से बढ़ा दी जाती है // हर बार जब कोई तत्व जोड़ा जाता है ।Push.call (यह, elem)) // दें। कुछ खाली वस्तुओं को केवल उदाहरण के लिए .obj.addElem (()) obj.addElem (()) कंसोल.लॉग (obj.length) // → 2

ध्यान दें कि हालांकि ओब्ज एक सरणी नहीं है, लेकिन अगर हम एक वास्तविक एरे के साथ काम कर रहे हैं, तो विधि सफलतापूर्वक बढ़ी हुई obj की लंबाई संपत्ति को धक्का देती है।

विशेष विवरण

विशिष्टता	स्थिति	टिप्पणी
ECMAScript 3 संस्करण (ECMA-262)	मानक	प्रारंभिक परिभाषा। जावास्क्रिप्ट 1.2 में लागू किया गया।
ECMAScript 5.1 (ECMA-262)	मानक
ईसीएमएस्क्रिप्ट 2015 (6 वां संस्करण, ईसीएमए -262) उस विनिर्देश में "Array.prototyp.push" की परिभाषा।	मानक
ECMAScript नवीनतम ड्राफ्ट (ECMA-262) उस विनिर्देश में "Array.prototyp.push" की परिभाषा।	प्रारूप

ब्राउज़र संगतता

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

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

	डेस्कटॉप						मोबाइल						सर्वर
	क्रोम	धार	फ़ायरफ़ॉक्स	इंटरनेट एक्स्प्लोरर	ओपेरा	सफारी	Android वेबव्यू	Android के लिए क्रोम	Android के लिए फ़ायरफ़ॉक्स	Android के लिए ओपेरा	IOS पर सफारी	सैमसंग इंटरनेट	Node.js
धक्का दें	Chrome पूर्ण समर्थन 1	एज फुल सपोर्ट 12	फ़ायरफ़ॉक्स पूर्ण समर्थन 1	IE पूर्ण समर्थन 5.5	ओपेरा पूर्ण समर्थन हाँ	सफारी पूर्ण समर्थन 1	WebView Android पूर्ण समर्थन हां	क्रोम Android पूर्ण समर्थन 18	फ़ायरफ़ॉक्स Android पूर्ण समर्थन 4	ओपेरा Android पूर्ण समर्थन हाँ	सफारी iOS पूर्ण समर्थन 1	सैमसंग इंटरनेट Android पूर्ण समर्थन हाँ	नोडज पूरा समर्थन हाँ

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

डेटा सरणी और इसके गठन का तर्क

बस चर का वर्णन करें। चर की एक सरणी बनाना मुश्किल नहीं है। डेटा का उपयोग कर एक एल्गोरिथ्म एक समस्या का स्थिर और सरल समाधान है। क्लासिक डेटा हेरफेर:

• वर्णन करना (बनाना) एक चर;
• एक मूल्य निर्दिष्ट करें;
• मूल्य बदलें;
• चर निकालें।

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

मान ") फ़ंक्शन सरणी के अंत में कुछ जोड़ने के लिए है। फ़ंक्शन सरणी के अंतिम तत्व को पुनः प्राप्त करना है। पुश / पॉप संदर्भ में सूचक, जब जोड़ा जाता है, जोड़ा तत्व तक पहुंच जाता है, जब पुन: प्राप्त तत्व के लिए, और अंतिम तत्व ऑपरेशन का परिणाम होता है।

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

मूल्यों द्वारा आंदोलन

ढेर का सार - आखिरी में आया, पहले छोड़ दिया। आप इस आदेश से कोई मान नहीं निकाल सकते। इस नियम का सख्ती से अवलोकन करते हुए, संपूर्ण सरणी के मानों को एक चर के रूप में देखते हुए, आप समय के साथ इस चर के मूल्यों में परिवर्तन की गतिशीलता प्राप्त कर सकते हैं।

इस उदाहरण में, JS array.push (...) मान जोड़ना क्रियाओं का एक अनुक्रम है, JS array pop () मानों को पुनः प्राप्त करना एक और अनुक्रम है। दोनों विकल्प परस्पर जुड़े हुए हैं। इसका मतलब है कि सक्रिय तत्व न केवल समय में, बल्कि इसके परिवर्तन के तर्क में भी अपना मूल्य बदलता है।

पुनरावर्तन और मूल्य की गतिशीलता

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

शास्त्रीय प्रोग्रामिंग शैली में जो कहा गया है, उसे लागू करना लगभग असंभव है, लेकिन पुनरावर्ती शैली में यह प्राथमिक है। यदि तालिका के साथ काम करने के लिए एल्गोरिथ्म की कार्यक्षमता खुद को किसी भी सेल के अंदर लागू करने की अनुमति देती है, तो यह जेएस सरणी पुश है। इस ट्रिक का जावास्क्रिप्ट में एक विशेष अर्थ है। तालिकाएँ कस्टम उपयोग हैं। पेज ट्री (DOM) पेज पर काम है।

हैंडलर डोम एलिमेंट्स (पेज टैग्स) पर हैंग करते हैं। एक विकल्प, जब इस तरह के हैंडलर को एक बार ट्रिगर किया जाता है, तो एक पूरी तरह से अलग विकल्प होता है, जब यह कई बार खुद को कॉल कर सकता है। सभी पृष्ठ तत्वों के सभी हैंडलर के संदर्भ में, समय में पृष्ठ की गतिशीलता प्राप्त की जाती है।

पुश / पॉप और पुनरावृत्ति पृष्ठ के तर्क का थोड़ा अलग विचार है: वर्तमान स्थिति में आवश्यकतानुसार सब कुछ बदलता है, और आगंतुक के कार्यों के अनुक्रमिक प्रसंस्करण के रूप में अग्रिम में क्रमादेशित नहीं होता है।

जावास्क्रिप्ट में। यहाँ हम Arrays के साथ अपने परिचित को जारी रखेंगे। चलो लंबाई की संपत्ति के बारे में बात करते हैं - यह कैसे पता करें: एक ऐरे में कितने तत्व हैं?

चलो सीखें सामगंरियां जोड़ें ऐरे की शुरुआत और अंत क्रमशः अनशिफ्ट और पुश विधियां हैं।

और शिफ्ट और पॉप तरीकों का उपयोग करके भी हम कर सकते हैं आइटम हटाएँ ऐरे की शुरुआत और अंत से भी!

अनिवार्य रूप से, एक सरणी एक वस्तु है जो विभिन्न तत्वों की एक निश्चित संख्या से बना है।

लंबाई की संपत्ति आपको ऐरे में तत्वों की संख्या बताएगी।

उदाहरण के लिए, आइए पिछले विषय से हमें परिचित सप्ताह के सात दिनों का ऐरे लें।

आइए सरणी में तत्वों की संख्या का पता लगाएं और प्रदर्शित करें। ऐसा करने के लिए, जैसा कि आप नीचे दिए गए उदाहरण में देख सकते हैं, एक चर बनाएं जिसका मूल्य हमारे लिए ब्याज की सरणी होगी, जिसके लिए, बदले में, लंबाई संपत्ति निर्दिष्ट की जाती है।

array.length - यह कोड हमें ऐरे के तत्वों की संख्या देता है (कहाँ पे सरणी - ऐरे नाम) .

इस प्रकार, हम एरे में तत्वों की संख्या के बराबर गिनती चर में एक संख्या डालते हैं।

इस तरह से लंबाई संपत्ति काम करती है।

पुश विधि - ऐरे के अंत में एक आइटम जोड़ता है।

तत्वों को जोड़ने के तरीकों के साथ काम करना शुरू करने के लिए, आपको एक ऐरे बनाने की आवश्यकता है।

नीचे मैंने एक "मित्र" - मित्र बनाया है।

अब हमें एक तत्व जोड़ने की आवश्यकता है, जो कि ऐरे के अंत में एक और नाम है।

इसके लिए एक धक्का विधि है - यह ऐरे के अंत में एक तत्व जोड़ता है। यह इस तरह दिख रहा है:

नास्त्य, ग्रिगोरी, व्याचेस्लाव, एलेक्सी, याकोव

याकूब

उपरोक्त उदाहरण में पुश विधि के काम का परीक्षण करने के लिए, हमने लंबाई के गुण का उपयोग करते हुए मित्रों के तत्वों की संख्या में कटौती की - उनमें से 5 हैं। फिर हमने पूरे दोस्तों को प्रदर्शित किया, साथ ही साथ। array का अंतिम तत्व .

अब आप अपने लिए देख सकते हैं कि तत्व को ऐरे के अंत में जोड़ा गया है!

अनशिफ्ट विधि - आइटम जोड़ें ऐरे की शुरुआत.

यहां हम मित्रों को फिर से Array का संदर्भ देते हैं।

अब हमें ऐरे की शुरुआत में एक तत्व जोड़ना होगा। इसके लिए एक अनशिफ्ट विधि है।

ऐरे में तत्वों की संख्या 5 है

बोरिस, नास्त्य, ग्रिगोरी, व्याचेस्लाव, एलेक्सी

बोरिस

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

अब, जैसा कि आप देख सकते हैं, तत्व को ऐरे की शुरुआत में जोड़ा जाता है!

पॉप विधि - निकालता है एरे से अंतिम तत्व.

और फिर से हम ऐरे "फ्रेंड्स" के साथ काम करते हैं

पॉप विधि का उपयोग - ऐरे से अंतिम तत्व निकालें:

नास्ति, ग्रिगोरी, व्याचेस्लाव

व्याचेस्लाव

पॉप विधि की स्पष्टता के लिए, हमने फिर से लंबाई की संपत्ति का उपयोग करके ऐरे तत्वों की संख्या में कटौती की, फिर हमने पूरे फ्रेंड्स एरे को घटाया - अंतिम तत्व को हटाए बिना।

और लाया भी अंतिम तत्व परिणामी ऐरे ... अंतिम तत्व प्रदर्शित करने के लिए, लंबाई की संपत्ति का उपयोग करते हुए, हमने Array (3) में शेष तत्वों की कुल संख्या को लिया और घटाया 1. इस प्रकार, हमने सरणी के अंतिम तत्व को नंबर 2 में प्रदर्शित किया। लेकिन यह तीसरा तत्व है, क्योंकि Array में नंबरिंग के साथ शुरू होता है। 0 !!!

शिफ्ट विधि - निकालता है एरे से पहला तत्व.

हमसे पहले, पहले की तरह, "मित्र"

शिफ्ट विधि के साथ - ऐरे से पहला तत्व निकालें:

ऐरे में तत्वों की संख्या 3 है

ग्रेगरी, व्याचेस्लाव, एलेक्सी

ग्रेगरी

और, अंत में, शिफ्ट विधि के संचालन का परीक्षण करने के लिए, हमने लंबाई संपत्ति का उपयोग करके नए प्राप्त एरे के तत्वों की संख्या को घटा दिया, फिर हमने पूरे ऐरे दोस्तों को काट दिया - पहले तत्व को हटाए बिना।

और लाया भी एरे का पहला तत्व... ऐरे में नंबर 0 से शुरू होता है !!!

मैं आपको और अपने लिए याद दिलाऊंगा दिलचस्प पल इस लेख के!

ऐरे के अंतिम तत्व की संख्या / सूचकांक का पता लगाने के लिए, आपको इसके तत्वों की संख्या की आवश्यकता है (यानी से) एक घटाएँ !!!

हमने पहले ही विषय पैराग्राफ में इसके साथ काम किया है.

इस बिंदु का एक अच्छा उदाहरण विषय पैराग्राफ से उदाहरण का एक निरंतरता होगा, जहां हमने सप्ताह के सात दिनों के एरे पर ध्यान दिया।

ऐरे दिनों में तत्वों की संख्या 7 है

ऐरे के अंतिम तत्व की संख्या 6 है

इसलिए, इस उदाहरण के साथ, हमने उसी समय एक बार फिर इस तथ्य को नोट किया ऐरे नंबरिंग 0 से शुरू होती है... और, जैसा कि आप इस उदाहरण से देख सकते हैं, सरणी के 7 वें तत्व की संख्या 6 है।

इस विषय के अंत में, हम अपना होमवर्क भी करेंगे। फिर, इसे स्वयं हल करने का प्रयास करें।

जावास्क्रिप्ट से हटाने और तत्वों को जोड़ने के लिए होमवर्क में निम्नलिखित सामग्री है:

1. फलों के साथ एक सरणी बनाएं: नारंगी, केला, नाशपाती।
2. स्क्रीन पर प्रिंट करें कि आपके पास वर्तमान में कितने फल हैं।
3. पिछले पाठ में सीखी गई विधियों का उपयोग करके, सरणी के अंत में दो फल जोड़ें - एक सेब और एक अनानास, और सरणी की शुरुआत में - एक अंगूर।
4. प्रदर्शित करें कि आपके पास वर्तमान में कितने फल हैं।
5. पिछले पाठ में आपके द्वारा सीखे गए तरीकों का उपयोग करके, अंतिम और पहले तत्व को सरणी से हटा दें।
6. प्रदर्शित करें कि आपके पास वर्तमान में कितने फल हैं।

नारंगी, केला, नाशपाती

अब मेरी टोकरी में 3 फल हैं

अंगूर, संतरा, केला, नाशपाती, सेब, अनानास

अब मेरी टोकरी में 6 फल हैं

ऑरेंज, केला, नाशपाती, सेब

अब मेरी टोकरी में 4 फल हैं