जावास्क्रिप्ट उदाहरणों में आता है। जावास्क्रिप्ट में दो-आयामी सरणी। एक आयामी सरणी नंबर 1

पिछले लेख में, हमने बात की कि यह क्या है और इसके साथ कैसे काम करना है। इस लेख में हम बात करेंगे बहुआयामी सरणी.

यह एक ऐसा सरणी है जिसमें एक या अधिक तत्व होते हैं, जो कि सरणियाँ भी हैं। विज्ञापन की गहराई के आधार पर, विशेष रूप से, इसे कहा जा सकता है द्वि-आयामी सरणी(२ स्तर) या तो त्रि-आयामी सरणी(3 स्तर) या तो चार आयामी(4 स्तर) और इतने पर।

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

जैसा कि आप देख सकते हैं, दो-आयामी सरणी के तत्व एक-आयामी सरणियाँ हैं। यदि इन वन-आयामी सरणियों में अधिक सरणियाँ होती हैं, तो गिरफ्तारी सरणी पहले से ही तीन-आयामी होगी।

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

// तीन खाली सरणियों को समान रूप से घोषित करें \u003d नया ऐरे (); // परिवर्तनीय कश्मीर - समरूप सरणी सूचकांकों के लिए var k \u003d 0; var oddNumbers \u003d नया ऐरे (); // चर n - सरणी सूचकांकों के लिए विषमांक n n \u003d 0; var data \u003d new Array ("कार", "विमान", सच, 89, "m"); // सरणी समरूप भरें, इसके लिए भी संख्याओं के साथ (var i \u003d 1; i

यह देखने के लिए कि ऐरे के अंदर क्या है, आप इस तरह के टूल का उपयोग कर सकते हैं कंसोल.

उदाहरण के लिए, हम विषम संख्या विषम के साथ एक सरणी की सामग्री को देखना चाहते हैं। ऐसा करने के लिए, नीचे दिए गए कोड में निम्नलिखित पंक्ति लिखें:

Console.log (oddNumbers);

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

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

अब के क्रम में एक दो आयामी सरणी बनाएँ, आपको इसे घोषित करने की आवश्यकता है, और आपके द्वारा इसके ऊपर बनाई गई एक-आयामी सरणियों को जोड़ना होगा।

// एक दो-आयामी सरणी दोDimens की घोषणा करें, और इसे var दोDimens भरें \u003d नया सरणी (समरूप, विषमांक, डेटा); कंसोल.लॉग (दोडिमेंस);

आइए कंसोल में इस सरणी की सामग्री देखें।

द्वि-आयामी सरणी पर पुनरावृति

पहले, आइए जानें दो-आयामी सरणी के तत्वों का उपयोग कैसे करें.

एकल सरणियों के साथ, तत्वों को उनके सूचकांकों द्वारा पहुँचा जाता है।

उदाहरण के लिए, आइए विषम संख्या (विषमता) वाले सरणी से तत्व 3 में तत्व प्रदर्शित करें। द्वि-आयामी सरणी दो आयामों में एक आयामी सरणी विषमांक का सूचकांक एक (1) है।

डॉक्यूमेंट.राइट ("विषमांक सरणी से अनुक्रमणिका 3 वाला तत्व है:" + दोडिम्स); // तत्व: 7

TwoDimens सरणी में, हम इंडेक्स में तत्व 1 को संदर्भित करते हैं। इस इंडेक्स में एलिमेंट विषमांक सरणी है। और इस सरणी में, हम पहले से ही सूचकांक 3 के साथ तत्व तक पहुंच रहे हैं, जो कि संख्या 7 है।

चलिए अब खुद ही सवाल पर पहुँचते हैं कैसे दो आयामी सरणी पर लूप करें.

दो-आयामी सरणी पर लूप एक डबल लूप का उपयोग करके किया जाता है। उदाहरण के लिए, चलिए अपने दो दिनों के सरणी पर पुनरावृति करते हैं।

के लिए (var i \u003d 0; i;< twoDimens.length; i++){ for(var j = 0; j < twoDimens[i].length; j++){ document.write("

सूचकांक के साथ तत्व "+ i +" "+ j +" के बराबर है: "+ दोडिमेंस [i] [j] +"

"); } }

पहले लूप में, हम खुद को दो डीमेंस ऐरे से अधिक पुनरावृत्त करते हैं। दूसरे लूप में, हम पहले से ही तत्व (सरणी) के ऊपर पुनरावृति कर रहे हैं। सबसे पहले, चर I 0. के बराबर है। इसलिए, दूसरे लूप में, हम पहले सरणी इवन्टर पर सबसे पहले पुनरावृति करते हैं, जिसमें इंडेक्स 0. है और पहले से ही दूसरे लूप के अंदर, हम इस ऐरे के तत्वों को एक्सेस करते हैं। इस प्रकार: TwoDimens [j]। जहां j 0 से लेकर समरूप सरणी की लंबाई तक है।

पहले सरणी से तत्वों पर पुनरावृत्ति करने के बाद, हम पहले लूप पर लौटते हैं, चर I को बढ़ाते हैं, और दूसरे सरणी विषम पर पुनरावृति करने के लिए आगे बढ़ते हैं, जिसमें सूचकांक 1 है। और इसलिए, हम द्वि-आयामी सरणी के दो तत्वों के प्रत्येक तत्व पर पुनरावृति करते हैं।

अब इस खोज के परिणाम पर नजर डालते हैं:

यही सब मैं इस लेख में बात करना चाहता था। अब आप जानते हैं कि द्वि-आयामी सरणी कैसे बनाएं, दो-आयामी सरणी के तत्वों का उपयोग कैसे करें, और दो-आयामी सरणी पर पुनरावृति कैसे करें। मुझे उम्मीद है कि सब कुछ स्पष्ट था। मैं आपको बहुत सफलता की कामना करता हूं!

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

I. वास्तविक सरणियों के माध्यम से लूपिंग

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

1. array.prototype.forEach विधि;
2. लूप के लिए क्लासिक;
3. के लिए एक अच्छी तरह से गठित ... पाश में।

इसके अलावा, जल्द ही, नए ECMAScript 6 (ES 6) मानक के उद्भव के साथ, दो और तरीके अपेक्षित हैं:

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

1. forEach विधि और संबंधित तरीके

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

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

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

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

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

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

2. लूप के लिए

नियमों के लिए अच्छा है:

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

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

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

वार ए \u003d ["ए", "बी", "सी"]; var सूचकांक; for (index \u003d a.length - 1; index\u003e \u003d 0; --index) (कंसोल.लॉग (a))
हालाँकि, आधुनिक जावास्क्रिप्ट इंजनों में, इन अनुकूलित खेलों का मतलब आमतौर पर कुछ भी नहीं होता है।

3. पाश में ... के लिए सही उपयोग

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

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

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

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

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

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

समारोह arrayHasOwnIndex (सरणी, कुंजी) (वापसी array.hasOwnProperty (कुंजी) और && / ^00 बचाओ के बारे में जानकारी) //.test(key) और& कुंजी<= 4294967294; }
फिर उदाहरण से लूप का शरीर काफी कम हो जाएगा:

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

के लिए (a) (यदि (a.hasOwnProperty (कुंजी) && स्ट्रिंग) (parseInt (कुंजी, 10)) \u003d\u003d\u003d कुंजी) (कंसोल.लॉग (a););

4. के लिए ... पाश (एक itter के निहित उपयोग)

ES6, जबकि अभी भी मसौदे की स्थिति में, पुनरावृत्तियों को जावास्क्रिप्ट में पेश करना चाहिए।

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

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

कई बिल्ट-इन ऑब्जेक्ट्स, incl। वास्तविक सरणियों में डिफ़ॉल्ट पुनरावृत्तियों हैं। असली सरणियों पर एक पुनरावृत्ति का उपयोग करने का सबसे सरल तरीका निर्माण के लिए नए का उपयोग करना है।

... के लिए उपयोग करने का एक उदाहरण:

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

5. एक पुनरावृत्त का स्पष्ट उपयोग

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

वार ए \u003d ["ए", "बी", "सी"]; var it \u003d a.entries (); var प्रविष्टि; जबकि ((प्रविष्टि \u003d it.next ()) किया गया) (कंसोल.लॉग (एंट्री.वल्यू););
इस उदाहरण में, Array.prototyp.entries पद्धति एक इटेरेटर लौटाती है जिसका उपयोग सरणी के मानों को प्रदर्शित करने के लिए किया जाता है। प्रत्येक पुनरावृत्ति पर, प्रविष्टि.वायु में एक सरणी होती है जैसे [कुंजी, मान]।

द्वितीय। सरणी जैसी वस्तुओं पर इरेटिंग

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

इसलिए, इस लेख को पढ़ने के बाद, आप सीखेंगे कि वेब अनुप्रयोगों में बहुआयामी सरणियों का उपयोग क्यों किया जाता है, उन्हें कैसे बनाया जाता है, और उन्हें कैसे हेरफेर और सॉर्ट किया जा सकता है। चलो सीखने के लिए नीचे उतरो!

बहुआयामी सरणियाँ कैसे बनाई जाती हैं और वे किस लिए हैं?

सबसे पहले, यह याद रखने योग्य है कि एक नियमित एक आयामी सरणी कैसे बनाई जाती है।

var सरणी \u003d

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

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

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

यह सब इस तरह दिखेगा:

var परिणाम \u003d [["मार्कस", 333], ["नताशा", 211], ["एलेक्सी", 124%];

जैसा कि आप देख सकते हैं, जानकारी को विषम संग्रहित किया जा सकता है। यह तार, संख्या और यहां तक \u200b\u200bकि हो सकता है। यह संभव है क्योंकि सरणियाँ अप्रकाशित हैं।

इस मामले में, तत्वों की पहुंच एक दोहरे ऑपरेटर के माध्यम से होती है।

सामग्री को मजबूत करने के लिए, एक छोटे से कार्यक्रम का विश्लेषण करें।

परिणाम \u003d

उन्हें संसाधित करते समय ऑर्डर किए गए जटिल डेटा को संग्रहीत करने के लिए ऐरे एक काफी सुविधाजनक तरीका है। इसके अलावा, उनके साथ काम करना बहुत सुविधाजनक है और एक ही समय में उनके प्रसंस्करण की गति काफी अधिक है।

डेटा छँटाई के तरीके

जावास्क्रिप्ट में सरणियों के लिए, एक अंतर्निहित विधि है जिसे कहा जाता है क्रमबद्ध करें ()... यह उपकरण बहुत लचीला है। और अब मैं समझाता हूँ क्यों।

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

एलेक्सी, 124

मार्कस, 333

नताशा, 211

और यदि आप प्रत्येक नेस्टेड सरणी में तत्वों को स्वैप करते हैं, तो आप प्राप्त करते हैं:

124, एलेक्सी

211, नताशा

333, मार्कस

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

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

• एक सकारात्मक संख्या (आमतौर पर 1 का चयन) यदि पहला निर्दिष्ट आइटम तुलना में दूसरे का अनुसरण करता है;
• एक नकारात्मक संख्या (आमतौर पर -1) यदि दूसरा चयनित आइटम पहले का पालन करना चाहिए;
• शून्य यदि दो परीक्षण किए गए मान समान हैं।

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

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

रिकॉर्ड तालिका:

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

इसलिए, सॉर्ट () फ़ंक्शन इस तरह दिखाई देगा:

1 2 3 4 5

function Recordort (a, b) (यदि (a\u003e b) वापसी 1, और यदि (a)< b) return -1; else return 0; }

function Recordort (a, b) (यदि (a\u003e b) वापसी 1, और यदि (a)< b) return -1; else return 0; }

लेकिन इसके बाद, उपरोक्त विधि जोड़ें।

निष्कर्ष एक समान तरीके से बनाया गया है।

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

खैर, इसलिए मैंने बहुआयामी सरणियों और उनकी छंटाई के बारे में बात की। अगर आपको लेख पसंद आया है, तो ब्लॉग की सदस्यता लें और अन्य समान रूप से दिलचस्प प्रकाशनों को पढ़ें। मैं रेपोस्टों के लिए आभारी रहूंगा। अगली बार तक!

अलविदा!

सबसे अच्छा संबंध है, रोमन चुशोव

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 मान। सॉर्ट क्रम के आधार पर 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

पुश () और पॉप () तरीके

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

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

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

अंतिम अपडेट: 09.04.2018

Arrays डेटासेट के साथ काम करने के लिए अभिप्रेत है। एक सरणी बनाने के लिए अभिव्यक्ति नया ऐरे () का उपयोग किया जाता है:

वार मायएरे \u003d नया ऐरे ();

किसी सरणी को आरंभीकृत करने का एक छोटा तरीका भी है:

वर मायरा \u003d;

इस मामले में, हम एक खाली सरणी बना रहे हैं। लेकिन आप इसमें प्रारंभिक डेटा भी जोड़ सकते हैं:

वर लोग \u003d ["टॉम", "एलिस", "सैम"]; कंसोल.लॉग (लोग);

इस मामले में, myArray में तीन तत्व होंगे। आलेखीय रूप से, इसे निम्नानुसार दर्शाया जा सकता है:

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

वर लोग \u003d ["टॉम", "एलिस", "सैम"]; कंसोल.लॉग (लोग); // टॉम संस्करण person3 \u003d लोग; // सैम कंसोल.लॉग (person3); // सैम

यदि हम सरणी के आकार से अधिक किसी इंडेक्स पर किसी तत्व को एक्सेस करने का प्रयास करते हैं, तो हम अपरिभाषित हो जाते हैं:

वर लोग \u003d ["टॉम", "एलिस", "सैम"]; कंसोल.लॉग (लोग); // अपरिभाषित

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

वर लोग \u003d ["टॉम", "एलिस", "सैम"]; कंसोल.लॉग (लोग); // टॉम लोग \u003d "बॉब"; कंसोल.लॉग (लोग); // बॉब

इसके अलावा, सी # या जावा जैसी अन्य भाषाओं के विपरीत, आप एक ऐसा तत्व स्थापित कर सकते हैं जो शुरू में स्थापित नहीं था:

वर लोग \u003d ["टॉम", "एलिस", "सैम"]; कंसोल.लॉग (लोग); // अपरिभाषित - सरणी लोगों में केवल तीन तत्व हैं \u003d "बॉब"; कंसोल.लॉग (लोग); // बॉब

यह भी ध्यान देने योग्य है कि, जावास्क्रिप्ट में कई प्रोग्रामिंग भाषाओं के विपरीत, सरणियों को दृढ़ता से टाइप नहीं किया जाता है, एक सरणी विभिन्न प्रकारों के डेटा को स्टोर कर सकती है:

वर वस्तु \u003d ["टॉम", 12, सच, 3.14, असत्य]; कंसोल.लॉग (ऑब्जेक्ट);

प्रसार संचालक

प्रसार ऑपरेटर ... आपको किसी सरणी से अलग से मान लेने की अनुमति देता है:

संख्या दो \u003d; कंसोल.लॉग (... नंबर); // 1 2 3 4 कंसोल.लॉग (संख्या); //

प्रसार ऑपरेटर सरणी से पहले निर्दिष्ट किया गया है। नतीजतन, अभिव्यक्ति ... संख्याओं का एक सेट वापस आ जाएगा, लेकिन यह एक सरणी नहीं, बल्कि व्यक्तिगत मूल्य होगा।

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

Arrays एक आयामी और बहुआयामी हो सकता है। एक बहुआयामी सरणी में प्रत्येक तत्व एक अलग सरणी हो सकता है। ऊपर हमने एक-आयामी सरणी पर विचार किया, अब एक बहुआयामी सरणी बनाते हैं:

वार नंबर 1 \u003d; // एक-आयामी सरणी var संख्या 2 \u003d [,]; // दो आयामी सरणी

नेत्रहीन, दोनों सरणियों को निम्नानुसार दर्शाया जा सकता है:

एक आयामी सरणी नंबर 1

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

वार tomInfo \u003d लोग;

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

Console.log ("नाम:" + लोग); // टॉम कंसोल.लॉग ("आयु:" + लोग); // 25

यही है, अगर हम एक तालिका के रूप में दो आयामी सरणी का प्रतिनिधित्व कर सकते हैं, तो लोग तत्व तालिका सेल को संदर्भित करेंगे, जो पहली पंक्ति के चौराहे पर स्थित है और दूसरा स्तंभ (पहला आयाम 0 है - एक पंक्ति, दूसरा आयाम - 1 - एक स्तंभ)।

हम असाइनमेंट भी कर सकते हैं:

वर लोग \u003d [["टॉम", 25, झूठे], ["बिल", 38, सच्चे], ["एलिस", 21, झूठे]]; लोग \u003d 56; // एक अलग वैल्यू कंसोल असाइन करें। लोग (लोग); // 56 लोग \u003d ["बॉब", 29, झूठे]; // एक ऐरो कंसोल प्रदान करें। लोगो (लोग); // बॉब

बहुआयामी सरणियों का निर्माण करते समय, हम केवल दो-आयामी वाले तक सीमित नहीं हैं, लेकिन हम बड़े आयामों के सरणियों का भी उपयोग कर सकते हैं:

वार संख्या \u003d; संख्या \u003d; // अब संख्या एक दो आयामी सरणी संख्या \u003d है; // अब संख्या एक तीन-आयामी सरणी संख्या \u003d 5 है; // 3 डी सरणी का पहला तत्व 5 कंसोल है। नंबर (संख्या);