जावास्क्रिप्ट लूपमध्ये ॲरे तयार करते. Javascript मध्ये ॲरे. ॲरेमध्ये सानुकूल गुणधर्म जोडणे

js मध्ये ॲरे कसे इंडेक्स करायचे, त्यांचे घटक कसे काढायचे आणि जोडायचे ते पाहू.

JavaScript मधील ॲरे ही मूल्यांची सूची संग्रहित करण्यासाठी डिझाइन केलेली जागतिक वस्तू आहे.

हे इतर व्हेरिएबल्ससारखेच आहे की ते कोणत्याही प्रकारचा डेटा संचयित करू शकते. परंतु ॲरेमध्ये व्हेरिएबलमधील एक महत्त्वाचा फरक आहे: तो एका वेळी एकापेक्षा जास्त घटक संचयित करू शकतो.

ॲरे म्हणजे मूल्यांचा क्रमबद्ध संग्रह. प्रत्येक मूल्याला घटक म्हणतात आणि त्याची स्वतःची संख्या असते, ज्याला इंडेक्स म्हणतात.

ॲरेमधील घटक कोणत्याही प्रकारचा असू शकतो. शिवाय, एका ॲरेचे घटक वेगवेगळ्या प्रकारचे असू शकतात: संख्या, तार, तार्किक घटक आणि अगदी ऑब्जेक्ट्स किंवा इतर ॲरे.

ॲरे घटकांचा क्रम 0 पासून सुरू होतो. असे दिसून आले की ॲरेमध्ये नेहमी एक इंडेक्स ऑफसेट असेल: पहिल्या घटकामध्ये इंडेक्स 0, दुसरा 1 इ.

येथे विविध प्रकारच्या घटकांसह ॲरेचे उदाहरण आहे:

ॲरे तयार करणे (घोषणा करणे).

ॲरे खूप सोयीस्कर आहेत कारण ते आपल्याला आवश्यक तेवढा डेटा संग्रहित करू शकतात. js ॲरेचा जास्तीत जास्त संभाव्य आकार 2 32 घटक आहे.

आम्हाला जावास्क्रिप्टला सांगावे लागेल की आम्हाला ॲरे तयार करायचा आहे. यासाठी दोन पर्याय आहेत: चौरस कंसातील मूल्य किंवा नवीन कीवर्ड.

शॉर्ट नोटेशन: स्क्वेअर ब्रॅकेट वापरणे

चौरस कंसात बंद केलेल्या मूल्यांची स्वल्पविरामाने विभक्त केलेली सूची.

var myArray = [ "जॅक", "सॉयर", "जॉन", "डेसमंड"];

ॲरेची सामग्री चौकोनी कंसांमधील काय आहे यावरून निर्धारित केली जाते. प्रत्येक मूल्य स्वल्पविरामाने विभक्त केले आहे.

मूल्ये साध्या व्हेरिएबल्स प्रमाणेच निर्दिष्ट केली जातात, म्हणजे, स्ट्रिंग्स कोट्समध्ये संलग्न घोषित करणे आवश्यक आहे.

रिक्त ॲरे घोषित करण्यासाठी, कंस रिक्त सोडा:

var myArray = ;

लांब एंट्री: Array() कन्स्ट्रक्टर वापरून

var lostArray = नवीन ॲरे("जॅक", "सॉयर", "जॉन", "डेसमंड"); var twinPeaksArray = नवीन ॲरे("लॉरा", 2, ["बॉब", "लेलँड", "डेल"]);

नवीन कीवर्ड JavaScript ला एक नवीन ॲरे तयार करण्यास सांगतो ज्याची मूल्ये पॅरामीटर्स म्हणून पास केली जातात.

तुमच्या ॲरेमध्ये किती घटक असतील हे तुम्हाला आधीच माहीत असल्यास, तुम्ही हे मूल्य ताबडतोब कन्स्ट्रक्टरमध्ये पास करू शकता.

var myArray = नवीन ॲरे(80);

वरील अभिव्यक्ती अपरिभाषित मूल्यांसह 80 स्लॉट असलेली रिक्त ॲरे तयार करेल.

रिक्त ॲरे घोषित करणे:

var myArray = नवीन ॲरे();

ॲरे घटकांमध्ये प्रवेश करणे

प्रत्येक घटकाची अनुक्रमणिका वापरून, आपण ऑपरेटर वापरून ऍक्सेस करून ॲरेमधील कोणत्याही डेटासह कार्य करू शकता:

var myArray = ["जॅक", "सॉयर", "जॉन", "डेसमंड"]; console.log(myArray); // "जॅक" console.log(myArray) मुद्रित करते; // "डेसमंड" मुद्रित करते

ॲरेमध्ये अनेक स्तर असू शकतात, म्हणजेच प्रत्येक घटक स्वतःच ॲरे असू शकतो. परिणाम द्विमितीय js ॲरे असेल. इतरांच्या आत असलेल्या या ॲरेमध्ये आपण कसे प्रवेश करू शकतो - “बहुआयामी ॲरे”?

उदाहरण म्हणून, कुटुंबाचे प्रतिनिधित्व करणाऱ्या ॲरेचा विचार करू. या कुटुंबातील मुले मुख्य घरात एका वेगळ्या ॲरेमध्ये रेकॉर्ड केली जातात:

var familyArray = ["मार्ज", "होमर", ["बार्ट", "लिसा", "मॅगी"]];

आपण त्याची अशी कल्पना करू शकता:

"लिसा" मूल्याचा संदर्भ घेण्यासाठी:

var lisa = familyArray; console.log(lisa); // "लिसा" प्रदर्शित करते

हे जवळजवळ अनिश्चित काळासाठी सुरू ठेवता येते, जे तुम्हाला ॲरेमध्ये नेस्टेड डेटा सेट संचयित करण्यास आणि अनुक्रमणिका वापरून त्यात प्रवेश करण्यास अनुमती देते.

ॲरेमध्ये घटक जोडणे

आम्ही ॲरे घटकांना त्यांच्या संबंधित निर्देशांकांचा वापर करून कसे प्रवेश करायचे ते शोधून काढले. त्याच प्रकारे, तुम्ही घोषित करून घटक जोडू शकता (किंवा बदलू शकता), उदाहरणार्थ:

var myArray = ["केट", "सन"]; myArray = "ज्युलिएट"; console.log(myArray); // "केट, सन, ज्युलिएट" प्रिंट

मी निर्देशांकासह एखादा घटक घोषित केल्यास काय होईल ज्याच्या आधी इतर कोणतेही घटक नाहीत? ॲरे स्वतःच सर्व गहाळ घटक तयार करेल आणि त्यांना अपरिभाषित मूल्य नियुक्त करेल:

var myArray = ["केट", "सन"]; myArray = "ज्युलिएट"; console.log(myArray.length); // "6" console.log(myArray) मुद्रित करते; // प्रिंट्स ["केट", "संग", अपरिभाषित, अपरिभाषित, अपरिभाषित, "ज्युलिएट"]

लांबी गुणधर्म वापरून तुम्ही js ॲरेची लांबी किती आहे हे शोधू शकता. वरील उदाहरणामध्ये, ॲरेमध्ये सहा घटक आहेत आणि त्यापैकी तीनला मूल्य दिलेले नाही - ते अपरिभाषित म्हणून चिन्हांकित आहेत.

पुश() पद्धत

पुश() पद्धतीचा वापर करून, तुम्ही js ॲरेमध्ये एक किंवा अधिक घटक जोडू शकता. पुश() अमर्यादित पॅरामीटर्स स्वीकारते, जे सर्व ॲरेच्या शेवटी जोडले जातील.

var myArray = ["केट", "सूट"]; myArray.push("ज्युलिएट"); // myArray.push("Libby", "Shannon") च्या शेवटी "Juliet" घटक जोडते; // ॲरे console.log(myaArray) च्या शेवटी "Libby" आणि "Shannon" घटक जोडते ); // प्रिंट्स ["केट", "सून", "ज्युलिएट", "लिबी", "शॅनन"]

unshift() पद्धत

unshift() पद्धत पुश() सारखीच कार्य करते, शिवाय ती ॲरेच्या सुरुवातीला घटक जोडते.

var myArray = ["केट", "सन"]; myArray.unshift("ज्युलिएट"); // myArray.unshift("Libby", "Shannon") ॲरेच्या सुरूवातीस "Juliet" घटक जोडते; // ॲरे console.log(myArray) च्या सुरूवातीस "Libby" आणि "Shannon" घटक जोडते; // आउटपुट ["लिबी", "शॅनन", "ज्युलिएट", "केट", "सून"]

Pop() आणि shift() पद्धती ॲरे घटक काढून टाकणे

pop() आणि shift() पद्धती क्रमशः ॲरेचा शेवटचा आणि पहिला घटक काढून टाकतात:

var myArray = ["जॅक", "सॉयर", "जॉन", "डेसमंड", "केट"]; myArray.pop(); // "Kate" घटक myArray.shift() काढून टाकते; // "जॅक" घटक console.log(myArray) काढून टाकते; // प्रिंट्स ["सॉयर", "जॉन", "डेसमंड"]

splice() पद्धत

splice() पद्धतीचा वापर करून, तुम्ही घटकांची अनुक्रमणिका अचूकपणे निर्दिष्ट करताना ॲरेमध्ये घटक काढू किंवा जोडू शकता.

खालील उदाहरण दोन घटक जोडण्यासाठी splice() पद्धत वापरते, अनुक्रमणिका 2 (म्हणजे तिसरा घटक) पासून सुरू होतो:

var fruitArray = ["सफरचंद", "पीच", "संत्रा", "लिंबू", "चुना", "चेरी"]; fruitArray.splice(2, 0, "खरबूज", "केळी"); console.log(fruitArray); // आउटपुट ["सफरचंद", "पीच", "खरबूज", "केळी", "संत्रा", "लिंबू", "चुना", "चेरी"]

splice() पद्धतीचे पहिले पॅरामीटर इंडेक्स आहे. घटक कोणत्या स्थितीत जोडले/काढले जावेत हे सूचित करते. आमच्या उदाहरणात, आम्ही इंडेक्स 2 ("नारंगी" मूल्यासह) निवडले.

दुसरा पॅरामीटर काढणे आवश्यक असलेल्या घटकांची संख्या आहे. आम्ही 0 चे मूल्य निर्दिष्ट केले आहे, त्यामुळे काहीही हटवले जाणार नाही.

खालील पॅरामीटर्स पर्यायी आहेत. ते ॲरेमध्ये नवीन मूल्ये जोडतात. आमच्या बाबतीत, आम्हाला "खरबूज" आणि "केळी" जोडणे आवश्यक आहे, अनुक्रमणिका 2 ने सुरू होईल.

• भाषांतर

• I. रिअल ॲरेवर पुनरावृत्ती
• प्रत्येक पद्धत आणि संबंधित पद्धतींसाठी
• लूपसाठी
• फॉर...इन लूपचा योग्य वापर
• लूपसाठी... (इटरेटरचा अव्यक्त वापर)
• इटरेटरचा स्पष्ट वापर
• रिअल ॲरेवर पुनरावृत्ती करण्यासाठी पद्धती वापरणे
• वास्तविक ॲरेमध्ये रूपांतरित करा
• रनटाइम ऑब्जेक्ट्सवर एक टीप

I. रिअल ॲरेवर पुनरावृत्ती करणे सध्या, रिअल ॲरेच्या घटकांवर पुनरावृत्ती करण्याचे तीन मार्ग आहेत:

पद्धत Array.prototype.forEach ;

लूपसाठी क्लासिक

लूपमध्ये...साठी "योग्यरित्या" तयार केले आहे.

याव्यतिरिक्त, लवकरच, नवीन ECMAScript 6 (ES 6) मानकाच्या आगमनाने, आणखी दोन पद्धती अपेक्षित आहेत:

लूपसाठी... (इटरेटरचा अव्यक्त वापर);

इटरेटरचा स्पष्ट वापर.

1. प्रत्येक पद्धत आणि संबंधित पद्धती जर तुमचा प्रकल्प ECMAScript 5 (ES5) मानकांच्या वैशिष्ट्यांना समर्थन देण्यासाठी डिझाइन केला असेल, तर तुम्ही त्यातील एक नवकल्पना वापरू शकता - forEach पद्धत.

वापर उदाहरण:
var a = ["a", "b", "c"]; a.forEach(function(entry) ( console.log(entry); ));
सर्वसाधारणपणे, forEach वापरण्यासाठी या पद्धतीचे मूळ समर्थन न करणाऱ्या ब्राउझरसाठी es5-shim इम्युलेशन लायब्ररी कनेक्ट करणे आवश्यक आहे. यामध्ये IE 8 आणि त्यापूर्वीचा समावेश आहे, जे अजूनही काही ठिकाणी वापरात आहेत.

forEach चा फायदा असा आहे की वर्तमान ॲरे घटकाची अनुक्रमणिका आणि मूल्य संचयित करण्यासाठी स्थानिक व्हेरिएबल्स घोषित करण्याची आवश्यकता नाही, कारण ते आपोआप कॉलबॅक फंक्शनला वितर्क म्हणून पास केले जातात.

प्रत्येक घटकावर कॉलबॅक कॉल करण्याच्या संभाव्य खर्चाबद्दल तुम्हाला काळजी वाटत असल्यास, काळजी करू नका आणि हे वाचा.

ForEach हे ॲरेच्या सर्व घटकांवर पुनरावृत्ती करण्यासाठी डिझाइन केलेले आहे, परंतु त्याव्यतिरिक्त, ES5 सर्व किंवा काही घटकांद्वारे पुनरावृत्ती करण्यासाठी तसेच त्यांच्यावर काही क्रिया करण्यासाठी अनेक उपयुक्त पद्धती ऑफर करते:

• प्रत्येक - ॲरेच्या प्रत्येक घटकासाठी कॉलबॅक एक मूल्य परत करत असल्यास सत्यात रूपांतरित केले जाऊ शकते.
• काही - ॲरेच्या कमीत कमी एका घटकासाठी कॉलबॅकने सत्यात रूपांतरित केले जाऊ शकणारे मूल्य परत केल्यास सत्य परत येते.
• फिल्टर - एक नवीन ॲरे तयार करते ज्यामध्ये मूळ ॲरेचे घटक समाविष्ट असतात ज्यासाठी कॉलबॅक सत्य परत येतो.
• नकाशा - कॉलबॅकद्वारे परत केलेल्या मूल्यांचा समावेश असलेला नवीन ॲरे तयार करतो.
• कमी करा - ॲरेला एका मूल्यावर कमी करते, प्रत्येक ॲरे घटकावर कॉलबॅक लागू करून, पहिल्यापासून सुरू होते (ॲरे घटकांची बेरीज आणि इतर सारांश फंक्शन्सची गणना करण्यासाठी उपयुक्त असू शकते).
• reduceRight - कमी करण्यासारखे कार्य करते, परंतु घटकांद्वारे उलट क्रमाने पुनरावृत्ती होते.

2. लूपसाठी नियमांसाठी चांगले जुने:

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

Var a = ["a", "b", "c"]; var निर्देशांक, len; साठी (इंडेक्स = 0, len = a.length; अनुक्रमणिका< len; ++index) { console.log(a); }
सिद्धांतानुसार, हा कोड मागील कोडपेक्षा थोडा वेगवान चालला पाहिजे.

जर घटकांचा क्रम महत्त्वाचा नसेल, तर तुम्ही ऑप्टिमायझेशनच्या बाबतीत आणखी पुढे जाऊ शकता आणि ॲरेची लांबी संचयित करण्यासाठी व्हेरिएबलपासून मुक्त होऊ शकता, शोधाचा क्रम उलटा बदलू शकता:

Var a = ["a", "b", "c"]; var निर्देशांक; साठी (index = a.length - 1; index >= 0; --index) ( console.log(a); )
तथापि, आधुनिक JavaScript इंजिनमध्ये अशा ऑप्टिमायझेशन गेमचा सहसा काहीच अर्थ नसतो.

3. a for...in loop चा योग्य वापर जर तुम्हाला a for...in loop वापरण्याचा सल्ला दिला जात असेल, तर लक्षात ठेवा की ॲरे वर पुनरावृत्ती करणे हे ज्यासाठी आहे ते नाही. सामान्य गैरसमजाच्या विरुद्ध, फॉर...इन लूप ॲरे निर्देशांकांवर पुनरावृत्ती करत नाही, तर ऑब्जेक्टच्या असंख्य गुणधर्मांद्वारे.

तथापि, काही प्रकरणांमध्ये, जसे की विरळ ॲरेवर पुनरावृत्ती करणे, खालील उदाहरणात दर्शविल्याप्रमाणे, जोपर्यंत तुम्ही सावधगिरी बाळगता तोपर्यंत...in उपयुक्त ठरू शकते:

// a - विरळ ॲरे var a = ; a = "a"; a = "b"; a = "c"; (a मध्ये var की) ( जर (a.hasOwnProperty(की) && /^0$|^\d*$/.test(की) && की) साठी