सरणियाँ

docs.scrimba.com

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

सरणी बनाना और पढ़ना

एक सरणी मानों की एक क्रमबद्ध सूची है। आप इसे वर्गाकार कोष्ठक के साथ लिखते हैं, मानों को अल्पविराम से अलग करते हैं:

const prices = [4, 9, 2, 7];

यह एक चर है, prices, जो चार संख्याएँ रखता है। एक एकल मान पढ़ने के लिए आप इसकी स्थिति का उपयोग करते हैं, जिसे index कहा जाता है, वर्गाकार कोष्ठक में। पकड़ जो शुरुआत में लगभग सभी को भ्रमित करती है: गिनती एक से नहीं, शून्य से शुरू होती है।

const names = ["अमित", "राज", "योगी"];
console.log(names[0]); // अमित
console.log(names[1]); // राज

यह पूछने के लिए कि एक सरणी में कितने आइटम हैं, .length का उपयोग करें:

console.log(names.length); // 3

चूंकि गिनती शून्य से शुरू होती है, अंतिम आइटम length - 1 पर बैठता है, न कि length पर। तो अंतिम नाम यहाँ names[2] है, और names[3] अंत से आगे होगा।

एक सरणी एक नाम के तहत मानों का एक क्रमबद्ध संग्रह है। आप इसे एक वर्गाकार-कोष्ठक शाब्दिक से बनाते हैं, और आप किसी भी आइटम को अपने index से पढ़ते हैं, शून्य से गिनी गई इसकी स्थिति:

const prices = [4, 9, 2, 7];
console.log(prices[0]); // 4
console.log(prices[2]); // 2

शून्य-आधारित अनुक्रमण अधिकांश शुरुआती off-by-one बग का स्रोत है, इसलिए इसे अभी अपने सिर में ठीक करना उचित है: पहला आइटम index 0 पर है, और अंतिम length - 1 पर है।

console.log(prices.length); // 4
console.log(prices[prices.length - 1]); // 7, अंतिम आइटम

एक index पढ़ना जो मौजूद नहीं है एक त्रुटि नहीं फेंकता है। prices[10] आपको undefined देता है, जो JavaScript का यह कहने का तरीका है "यहाँ कुछ नहीं है"। यह शांत परिणाम सुविधाजनक है और कभी-कभी एक जाल है, क्योंकि एक index में टाइपो आपको एक तेज़ विफलता के बजाय undefined देता है।

एक सरणी एक क्रमबद्ध, index-संबोधित संग्रह है जो एक कोष्ठक शाब्दिक से बनाया गया है। आइटम शून्य से गिनी गई index द्वारा पढ़े जाते हैं, और .length गिनती की रिपोर्ट करता है:

const prices = [4, 9, 2, 7];
console.log(prices[0]); // 4
console.log(prices.length); // 4
console.log(prices[prices.length - 1]); // 7, अंतिम आइटम

दो गुण सटीक रूप से नाम देने के लायक हैं। सबसे पहले, .length एक निश्चित आकार नहीं है जिसे आपने आगे की ओर घोषित किया है; यह उपयोग में उच्चतम index को ट्रैक करता है और जैसे-जैसे आप आइटम जोड़ते और निकालते हैं अपडेट होता है। दूसरा, एक out-of-range पढ़ना फेंकने के बजाय undefined लौटाता है, इसलिए एक off-by-one त्रुटि गलती के बिंदु पर एक अपवाद के रूप में नहीं बल्कि undefined के रूप में आपके तर्क के माध्यम से प्रवाहित होती है। जब आप विफलता को तेज़ चाहते हैं, तो स्वयं index को length के विरुद्ध सुरक्षा दें।

सरणियाँ मिश्रित मान प्रकार रख सकती हैं ([1, "two", true]), लेकिन एक कार्यशील कोडबेस लगभग हमेशा एक सरणी को एक प्रकार की चीज़ के लिए रखता है, क्योंकि सरणी को पढ़ने वाला हर कोड तब जानता है कि यह क्या प्राप्त कर रहा है। यहाँ संगति एक भाषा नियम नहीं, एक readability निर्णय है।

Junoसरणी बनाना और पढ़ना एक सरणी एक नाम के तहत वर्गाकार कोष्ठक में मानों की एक सूची है। एक आइटम को names[0] से अपनी स्थिति से पढ़ें, और याद रखें कि गिनती शून्य से शुरू होती है, इसलिए पहला आइटम [0] है, [1] नहीं। वह शून्य मुझे एक हफ्ते के लिए भ्रमित करता था, इसलिए जब भी आपकी सूची एक से बंद हो तो इसे जांचें। आइटम को गिनने के लिए .length का उपयोग करें, और अंतिम आइटम length - 1 पर रहता है।

Junoसरणी बनाना और पढ़ना एक सरणी एक नाम के तहत एक क्रमबद्ध सूची रखती है, और आप शून्य से गिनी गई index द्वारा आइटम पढ़ते हैं। अंतिम आइटम length - 1 पर है, जहाँ से अधिकांश शुरुआती off-by-one बग आते हैं। अंत से परे पढ़ना त्रुटि के बजाय undefined लौटाता है, इसलिए एक टाइपो किया गया index तेज़ के बजाय शांत हो जाता है। यह ध्यान में रखें जब कोई मान स्पष्ट कारण के बिना undefined के रूप में दिखाई दे।

Junoसरणी बनाना और पढ़ना कोष्ठक शाब्दिक, शून्य-आधारित index, और .length जो उपयोग में उच्चतम index को ट्रैक करता है न कि आपने घोषित किया गया आकार। एक out-of-range पढ़ना फेंकने के बजाय undefined वापस करता है, इसलिए एक off-by-one त्रुटि इससे पहले कि वह काटे downstream जाती है। जब आप उस विफलता को तेज़ चाहते हैं तो स्वयं index को length के विरुद्ध सुरक्षा दें। और एक सरणी को एक प्रकार की चीज़ में रखें, न कि क्योंकि भाषा इसे बाध्य करती है, बल्कि क्योंकि सरणी के हर पाठक को तब पता है कि यह क्या रखता है।

सरणी को बदलना

सरणियाँ बदलने के लिए बनाई गई हैं। दो जो आप सबसे अधिक अंत में जोड़ते हैं: push एक आइटम जोड़ता है, pop अंतिम को हटाता है।

const cart = ["सेब", "ब्रेड"];
cart.push("दूध");
console.log(cart); // ["सेब", "ब्रेड", "दूध"]
cart.pop();
console.log(cart); // ["सेब", "ब्रेड"]

मिलान करने वाली जोड़ी शुरुआत पर काम करती है: unshift सामने जोड़ता है, shift पहली आइटम को हटाता है।

cart.unshift("अंडे");
console.log(cart); // ["अंडे", "सेब", "ब्रेड"]

आप अपनी index को सीधे assign करके एक आइटम को भी बदल सकते हैं:

cart[0] = "केला";
console.log(cart); // ["केला", "सेब", "ब्रेड"]

कुछ खोजने के लिए, includes आपको हाँ या नहीं बताता है, और indexOf आपको बताता है कि यह कहाँ है (या -1 यदि यह नहीं है):

console.log(cart.includes("सेब")); // true
console.log(cart.indexOf("ब्रेड")); // 2

जल्दी जानने के लिए एक चीज़: एक const सरणी अभी भी बदली जा सकती है। const आपको नाम cart को एक पूरी नई सरणी में reassign करने से रोकता है, लेकिन जो सूची यह इंगित करती है वह अभी भी push, pop, और index assignment के लिए खुली है।

सरणियाँ जगह पर संशोधित होने के लिए बनाई गई हैं। दो विधियों की जोड़ियाँ अधिकांश काम करती हैं, प्रत्येक सिरे पर एक:

const cart = ["सेब", "ब्रेड"];
cart.push("दूध"); // अंत में जोड़ें
cart.pop(); // अंत से हटाएँ
cart.unshift("अंडे"); // शुरुआत में जोड़ें
cart.shift(); // शुरुआत से हटाएँ

push और pop सस्ते, सामान्य जोड़ी हैं; आप इन्हें लगातार पहुँचते हैं। shift और unshift सामने को छूते हैं, जिसका अर्थ है कि हर दूसरी आइटम को एक स्लॉट ऊपर या नीचे जाना होगा, इसलिए एक बड़ी सरणी पर वे अधिक काम करते हैं। जब आदेश आपका है चुनने के लिए अंत को प्राथमिकता दें।

आप किसी भी स्थान को अपनी index को assign करके overwrite कर सकते हैं, और आप आइटम दो तरीकों से खोज सकते हैं:

const names = ["अमित", "राज", "योगी"];
names[1] = "प्रिया";
console.log(names.indexOf("योगी")); // 2, या -1 यदि अनुपस्थित
console.log(names.includes("अमित")); // true

includes का उपयोग तब करें जब आप केवल यह परवाह करते हैं कि कुछ मौजूद है या नहीं, और indexOf जब आपको स्थिति भी चाहिए। दोनों === से तुलना करते हैं, इसलिए indexOf("2") संख्या 2 नहीं खोजेगा।

एक const सरणी अभी भी पूरी तरह परिवर्तनशील है: const नाम को लॉक करता है, सामग्री को नहीं। आप cart को एक नई सरणी की ओर इंगित नहीं कर सकते, लेकिन आप जो सरणी यह रखता है उसमें सारा दिन push कर सकते हैं।

सरणियाँ परिवर्तनशील हैं, और मुख्य विधियाँ एक ताज़ी के बजाय सरणी को जगह पर बदलती हैं। push/pop अंत पर काम करते हैं, shift/unshift सामने पर:

const cart = ["सेब", "ब्रेड"];
cart.push("दूध"); // नई लंबाई लौटाता है, cart को उत्परिवर्तित करता है
const removed = cart.pop(); // हटाई गई आइटम लौटाता है, cart को उत्परिवर्तित करता है

अंत और सामने लागत में बराबर नहीं हैं। push और pop एक एकल स्लॉट को छूते हैं। shift और unshift हर शेष तत्व को पुनः सूचीबद्ध करते हैं, जो सरणी की लंबाई पर रैखिक काम है, इसलिए एक गर्म लूप जो बार-बार एक बड़ी सरणी को shift करता है वह चुपचाप बहुत अधिक कर रहा है जितना वह दिखता है। जब आदेश आपके नियंत्रण में हो, तब अंत पर चर्न रखें।

किसी index को assign करना जगह पर लिखता है, और search आवश्यकता से विभाजित होता है: उपस्थिति के लिए includes, स्थिति के लिए indexOf (अनुपस्थित के लिए -1 के साथ)। दोनों कठोर समानता (===) का उपयोग करते हैं, इसलिए प्रकार महत्वपूर्ण है:

const ids = [1, 2, 3];
console.log(ids.indexOf("2")); // -1, string संख्या से मेल नहीं खाता
console.log(ids.includes(2)); // true

const बिंदु बिल्कुल सटीक रूप से कहने लायक है, क्योंकि यह पहली जगह है जहाँ संदर्भ मॉडल के माध्यम से दिखाई देता है: const नाम को एक सरणी से जोड़ता है और इसे rebind करने से मना करता है, लेकिन सरणी की सामग्री के बारे में कुछ नहीं कहता है। cart.push(...) उस वस्तु को उत्परिवर्तित करता है जिसे नाम इंगित करता है, जो cart = [...] से एक अलग ऑपरेशन है। वह भेद अगले भाग का पूरा विषय है।

Junoसरणी को बदलनाpush और pop अंत में जोड़ते और हटाते हैं; unshift और shift शुरुआत में भी ऐसा करते हैं। एक आइटम को cart[0] = "केला" की तरह बदलने के लिए एक index को assign करें, और एक को खोजने के लिए includes या indexOf का उपयोग करें। जो भाग मुझे आश्चर्य हुआ: एक const सरणी अभी भी बदल सकती है, क्योंकि const केवल आपको पूरी सरणी को एक नई सरणी के लिए स्वैप करने से रोकता है।

Junoसरणी को बदलना दो जोड़ियाँ अधिकांश edits को कवर करती हैं: अंत पर push/pop, शुरुआत में shift/unshift। सामने की जोड़ी हर दूसरी आइटम को move करती है, इसलिए जब आदेश आपका हो अंत को पसंद करें। includes उपस्थिति को जांचता है, indexOf स्थिति देता है, और दोनों === से मेल खाते हैं, इसलिए "2" संख्या 2 नहीं खोजेगा। और const नाम को लॉक करता है, कभी सामग्री को नहीं, इसलिए आप एक const सरणी में सारा दिन push कर सकते हैं।

Junoसरणी को बदलना ये विधियाँ जगह पर उत्परिवर्तित करती हैं: push/pop एक स्लॉट को छूते हैं, shift/unshift पूरी सरणी को पुनः सूचीबद्ध करते हैं, इसलिए एक लूप जो एक बड़ी सरणी को shift करता रहता है हर बार रैखिक काम कर रहा है। includes और indexOf दोनों === का उपयोग करते हैं, इसलिए एक string index एक संख्या से मेल नहीं खाएगा। और const केवल नाम को rebind करने से मना करता है; cart.push() सरणी को उत्परिवर्तित करना cart = [] से एक अलग चीज़ है। वह अंतराल बिल्कुल आने वाली संदर्भ कहानी है।

सरणी के ऊपर लूप करना

एक बार जब आपके पास एक सूची हो, तो आप आमतौर पर हर आइटम के साथ कुछ करना चाहते हैं। एक सरणी के माध्यम से पढ़ने का सबसे स्वच्छ तरीका for...of है, जो आपको एक बार में एक आइटम देता है:

const prices = [4, 9, 2, 7];
for (const price of prices) {
  console.log(price);
}
// 4
// 9
// 2
// 7

आप एक index या एक counter को प्रबंधित नहीं करते। for...of आपको क्रम में प्रत्येक मान देता है, और आप इसे जैसे चाहें नाम दे सकते हैं (price)। यदि आपने पहले से loops से मिल गए हैं, यह सरणियों के लिए सबसे मैत्रीपूर्ण है।

यहाँ forEach भी है, जो हर आइटम के लिए एक बार एक छोटा function चलाता है:

const names = ["अमित", "राज", "योगी"];
names.forEach(function (name) {
  console.log("नमस्ते " + name);
});

दोनों पूरी सरणी को चलाते हैं। जब आप स्वच्छ रूप से पढ़ना चाहते हैं तो for...of पहुँचें, और जब आप सरणी को transform करना सीखेंगे तो आप forEach और इसके भाई-बहनों से फिर मिलेंगे।

एक सरणी पढ़ने के लिए आधुनिक डिफ़ॉल्ट for...of है। यह आपको सीधे प्रत्येक मान देता है, manage करने के लिए कोई index नहीं है और एक off-by-one slip की कोई संभावना नहीं है:

const prices = [4, 9, 2, 7];
let total = 0;
for (const price of prices) {
  total = total + price;
}
console.log(total); // 22

जब आप मान चाहते हैं क्रम में और स्वच्छ कोड में for...of का उपयोग करें। यदि आपको index भी चाहिए (कहते हैं, एक सूची को संख्या देने के लिए), classic गिनती for लूप या forEach का दूसरा argument इसे देता है।

forEach एक callback, एक function चलाता है जो आप इसे देते हैं, एक बार प्रति आइटम:

const names = ["अमित", "राज", "योगी"];
names.forEach((name) => {
  console.log("नमस्ते " + name);
});

forEach एक side effect प्रति आइटम के लिए अच्छा पढ़ता है, जैसे logging। क्या यह नहीं कर सकता है जल्दी break है, इसलिए जब आपको आधे रास्ते में रुकना चाहिए, for...of का उपयोग करें। एक पुरानी सरणी से एक नई सरणी बनाना एक अलग काम है जिसके अपने tools हैं, array methods में शामिल।

एक सादे पढ़ने के लिए, for...of idiomatic विकल्प है: यह directly मानों पर iterate करता है, index arithmetic को sidestep करता है, और break और continue को समर्थन करता है:

const prices = [4, 9, 2, 7];
let total = 0;
for (const price of prices) {
  if (price > 8) continue;
  total = total + price;
}
console.log(total); // 13, 9 को छोड़ दिया

forEach प्रति तत्व एक callback लेता है और side effects के लिए स्वच्छ रूप से पढ़ता है, लेकिन यह दो बाधाओं के साथ आता है जिन्हें जानना इससे पहले लायक है कि आप इस पर standardise करें। यह break नहीं कर सकता, इसलिए यह हमेशा अंत तक चलता है, और यह एक returned मान को ignore करता है, इसलिए यह गलत tool है जब आप एक परिणाम produce करने की कोशिश कर रहे हों। उसके लिए, transforming विधियाँ (map, filter, reduce) मौजूद हैं, और array methods यही जगह है जहाँ वे संबंधित हैं।

const names = ["अमित", "राज", "योगी"];
names.forEach((name, index) => {
  console.log(index + ": " + name);
});

callback का दूसरा argument index है, जो आपको एक manual counter के बिना position को recover करने का तरीका है। थंब का नियम: जब आपको control flow चाहिए या एक बाहरी variable में accumulating हो for...of, जब एक per-item side effect अधिक स्वच्छ रूप से पढ़ता है forEach, और जब आप एक mutation या एक log के बजाय एक नई सरणी वापस चाहते हैं एक transforming method।

Junoसरणी के ऊपर लूप करनाfor...of एक सरणी के माध्यम से चलने का स्वच्छ तरीका है: यह आपको क्रम में प्रत्येक आइटम देता है और आप कभी एक index को नहीं छूते हैं। forEach एक छोटे function को एक बार प्रति आइटम चलाता है, जो भी सुविधाजनक है। दोनों पूरी सूची के माध्यम से जाते हैं, इसलिए जब आप सीधे इसके माध्यम से पढ़ना चाहते हैं तो for...of को चुनें। आप सरणियों को transform करने का तरीका सीखने के बाद अधिक सरणी tools देखेंगे।

Junoसरणी के ऊपर लूप करनाfor...of एक सरणी पढ़ने के लिए डिफ़ॉल्ट है: क्रम में मान, manage करने के लिए कोई index नहीं, और जब आपको जल्दी रुकना चाहिए break काम करता है। forEach एक callback प्रति आइटम चलाता है और logging जैसे side effects के लिए अच्छी तरह पढ़ता है, लेकिन यह break नहीं कर सकता, इसलिए यह हमेशा अंत तक चलता है। एक पुरानी सरणी से एक नई सरणी बनाना एक अलग काम है जिसके अपने विधियाँ हैं। संदेह में, for...of।

Junoसरणी के ऊपर लूप करनाfor...of directly मानों पर iterate करता है और break और continue को समर्थन करता है, इसलिए यह जीत जाता है जब भी आपको control flow चाहिए या एक बाहरी variable में accumulating हो। forEach एक per-item side effect के लिए स्वच्छ रूप से पढ़ता है लेकिन break नहीं कर सकता और return value को ignore करता है, जो इसे एक परिणाम produce करने के लिए गलत tool बनाता है। जब आप एक नई सरणी वापस चाहते हैं, एक लूप के बजाय transforming विधियों के लिए पहुँचें। इसका दूसरा callback argument index देता है यदि आपको स्थिति चाहिए।

सरणियाँ संदर्भ द्वारा रखी जाती हैं

यहाँ behaviour है जो लोगों को आश्चर्य चकित करता है, इसलिए इसे जल्दी देखना लायक है। जब आप एक सरणी चर को दूसरे नाम में copy करते हैं, आप दूसरी सरणी नहीं प्राप्त करते। दोनों नाम एक ही की ओर इंगित करते हैं।

const original = [1, 2, 3];
const copy = original;
copy.push(4);
console.log(original); // [1, 2, 3, 4]

copy में pushing ने original को बदल दिया, क्योंकि केवल एक सरणी कभी थी। = ने दूसरे नाम को समान सूची दी, इसका एक ताज़ा copy नहीं। यह वह है जो लोग मतलब करते हैं जब वे कहते हैं कि सरणियाँ संदर्भ द्वारा रखी जाती हैं: चर एक सूची के लिए एक pointer रखता है, सूची स्वयं नहीं।

एक असली, अलग copy पाने के लिए, सरणी को ... से एक नई सरणी में spread करें:

const original = [1, 2, 3];
const copy = [...original];
copy.push(4);
console.log(original); // [1, 2, 3], untouched

एक संख्या या एक string value द्वारा रखी जाती है: चर को copy करना मान को copy करता है। एक सरणी अलग है। यह संदर्भ द्वारा रखी जाती है, इसलिए चर को copy करना pointer को copy करता है, और दोनों नाम एक ही सरणी को लक्ष्य करते हैं।

const original = [1, 2, 3];
const shared = original;
shared.push(4);
console.log(original); // [1, 2, 3, 4], समान सरणी

यह समान fact है const नोट के पीछे earlier: एक सरणी एक object है, और एक चर उस object को एक reference रखता है, object स्वयं नहीं। किसी भी नाम के माध्यम से mutating एक सरणी को mutate करता है जो वे साझा करते हैं।

जब आप एक independent copy चाहते हैं, इसे एक नई सरणी में spread करें। ... प्रत्येक आइटम को across copy करता है:

const original = [1, 2, 3];
const copy = [...original];
copy.push(4);
console.log(original); // [1, 2, 3], अलग

यह एक shallow copy है: नई सरणी इसकी अपनी सूची है, लेकिन यदि items स्वयं सरणियाँ थीं, दोनों copies अभी भी उन inner arrays को साझा करेंगे। सादी संख्याओं और strings के साथ, shallow सब कुछ है जो आपको चाहिए।

Primitives (संख्याएँ, strings, booleans) value द्वारा रखे जाते हैं; सरणियाँ objects हैं और संदर्भ द्वारा रखी जाती हैं। एक चर जो एक सरणी को "contain" करता है actually उसे एक reference रखता है, इसलिए assignment reference को copy करता है, और हर नाम जो उस सरणी की ओर इंगित करता है हर mutation को देखता है:

const original = [1, 2, 3];
const alias = original;
alias.push(4);
console.log(original); // [1, 2, 3, 4]
console.log(original === alias); // true, समान सरणी

यह वह है जिससे const और mutability अलग concerns हैं: const reference को ठीक करता है, mutation जो reference इंगित करता है को बदलता है। यह immutability को पसंद करने का argument भी है, एक नई सरणी produce करना एक को जगह पर बदलने के बजाय। Shared mutable state का मतलब है एक function जो एक सरणी को mutate करता है जो यह received करता है quietly इसे हर दूसरे holder के लिए बदलता है उस reference का, जो एक bug की एक class है जो trace करना मुश्किल है। एक नई सरणी को return करना हर caller के डेटा को इसका अपना रखता है।

Spread operator एक shallow copy बनाता है: एक नई बाहरी सरणी एक ही items copy के साथ।

const original = [1, 2, 3];
const copy = [...original];
console.log(copy === original); // false, अलग सरणियाँ

Shallow word जो महत्वपूर्ण है। नई सरणी independent है, लेकिन इसके अंदर nested arrays अभी भी reference द्वारा साझा किए जाते हैं, इसलिए एक deep structure को spread से अधिक की आवश्यकता है। Primitives की सरणियों के साथ, जो आप अभी तक हैं, एक spread एक पूर्ण copy है।

Structure को सभी चुनने के लिए: एक सरणी सही tool है जब आपके पास similar चीजों की एक ordered list हो और position या count महत्वपूर्ण हो, prices की एक queue, names की एक sequence। जब आप इसके बजाय एक meaningful key द्वारा values को look up करना चाहते हैं एक position के बजाय, यह एक object के लिए है, और function यह है जहाँ बहुत सारे array work समाप्त होते हैं।

Junoसरणियाँ संदर्भ द्वारा रखी जाती हैं एक सरणी चर को = से copy करना एक दूसरी सरणी नहीं बनाता है; दोनों नाम एक ही की ओर इंगित करते हैं, इसलिए या तो के माध्यम से एक परिवर्तन दोनों में दिखाई देता है। यह एक मुझे एक से अधिक बार bite किया है। जब आप एक असली अलग copy चाहते हैं, इसे [...original] से spread करें, जो एक ताज़ी सरणी बनाता है जिसे आप अपने पर बदल सकते हैं।

Junoसरणियाँ संदर्भ द्वारा रखी जाती हैं संख्याएँ और strings value द्वारा copy किए जाते हैं; सरणियाँ reference द्वारा copy की जाती हैं, इसलिए const b = a आपको एक सरणी के दो नाम देता है, और या तो के माध्यम से mutating दोनों को hits करता है। यह समान कारण है कि एक const सरणी अभी भी परिवर्तनशील है। एक independent copy के लिए [...original] का उपयोग करें, यह ध्यान में रखते हुए कि यह shallow है, जो बिल्कुल वही है जो आप संख्याओं और strings की सरणियों के लिए चाहते हैं।

Junoसरणियाँ संदर्भ द्वारा रखी जाती हैं सरणियाँ objects हैं reference द्वारा रखी गई हैं, इसलिए assignment pointer को copy करता है और हर नाम हर mutation को देखता है। यह const (reference को ठीक करता है) को mutability (target को बदलता है) से विभाजित करता है, और यह जगह पर एक परिवर्तन पर एक नई सरणी को पसंद करने का मामला है: एक function जो एक received सरणी को mutate करता है उसे हर किसी के लिए बदलता है उस reference को रखने वाला। Spread एक shallow copy बनाता है, top level पर independent लेकिन किसी भी nested arrays को साझा करते हुए। एक सरणी तक पहुँचें जब आदेश और गिनती महत्वपूर्ण हों, और एक object जब आप चीजों को key द्वारा देखना चाहते हों।

सरणियाँ यहाँ से कहाँ जाती हैं

एक सरणी एक नाम के तहत एक ordered list देता है: इसे [] से बनाएँ, शून्य से पढ़ें, इसे push और pop से बदलें, और इसे for...of से चलाएँ। एक idea जो इस chapter को past carry करता है कि एक सरणी reference द्वारा रखी जाती है, इसलिए चर को copy करना सूची के बजाय slist को साझा करता है।

प्राकृतिक अगला कदम एक सरणी को दूसरी में बदलना है, एक सूची को filter करना, हर आइटम को transform करना, सब कुछ add करना, बिना लूप को हाथ से लिखे। यह array methods है। जब आपको एक स्थिति के बजाय एक नाम से values को look up करना चाहिए, objects वह structure हैं।