इंडेक्स किए गए कलेक्शन

इंडेक्स किया गया कलेक्शन एक डेटा स्ट्रक्चर होता है, जिसमें एलिमेंट सेव किए जाते हैं और इसे नंबर वाले इंडेक्स का इस्तेमाल करके ऐक्सेस किया जाता है. इंडेक्स किए गए कलेक्शन में सेव की गई वैल्यू असाइन की गई संख्या वाले इंडेक्स, 0 से शुरू होते हैं. यह "शून्य इंडेक्स करने" का पैटर्न होता है. इसके बाद, इंडेक्स किए गए कलेक्शन में सेव की गई वैल्यू को ऐक्सेस करने के लिए, उनके इंडेक्स.

Array

अरे एक कंटेनर होता है, जिसमें किसी भी डेटा टाइप की शून्य या उससे ज़्यादा वैल्यू हो सकती हैं, इसमें कॉम्प्लेक्स ऑब्जेक्ट या अन्य सरणियां शामिल हैं. किसी कलेक्शन में सेव की गई वैल्यू कभी-कभी "एलिमेंट" भी कहा जाता है चुनें.

कलेक्शन बनाना

प्रिमिटिव डेटा टाइप की तरह ही, अरे बनाने के दो तरीके हैं: लिटरल अरे का इस्तेमाल करके या JavaScript के बिल्ट-इन Array() कंस्ट्रक्टर को चालू करके new Array() के साथ. किसी वैरिएबल के लिए अरे असाइन करने से, ज़्यादा पोर्टेबल और असाइन करने का इटरेबल तरीका होता है एक आइडेंटिफ़ायर के लिए कई वैल्यू.

अरे लिटरल सिंटैक्स में शून्य या उससे ज़्यादा के आस-पास ब्रैकेट ([]) का इस्तेमाल किया जाता है कॉमा लगाकर अलग किए गए डेटा की वैल्यू:

const myArray = [];

अरे कंस्ट्रक्टर सिंटैक्स, JavaScript के बिल्ट-इन Array ऑब्जेक्ट को new कीवर्ड वाला कंस्ट्रक्टर:

const myArray = new Array();

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

const myArray = [ true, null, "String", false ];

myArray;
> [ true, null, "String", false ]

अरे कंस्ट्रक्टर सिंटैक्स, कॉमा लगाकर अलग की गई वैल्यू को आर्ग्युमेंट के तौर पर इस्तेमाल करता है. इनमें एक वैल्यू होती है खास व्यवहार से जुड़ा अपवाद:

const myArray = new Array( true, null, "String", false );

myArray;
> Array(4) [ true, null, "String", false ]

जब Array कंस्ट्रक्टर को एक संख्यात्मक वैल्यू पास की जाती है, तो वह वैल्यू नतीजे के तौर पर बने अरे में, शून्य रैंक के लिए असाइन नहीं किया जाता है. इसके बजाय, एक अरे को वैल्यू के लिए खाली स्लॉट की उस संख्या के साथ बनाया जाता है. इससे कॉन्टेंट पर कोई फ़र्क़ नहीं पड़ता की सीमा तय कर सकते हैं. इसमें आइटम को उसी तरह से जोड़ा और हटाया जा सकता है मिलती है.

// Firefox:\
const myArray = new Array( 10 );

myArray;
> Array(10) [ <10 empty slots> ]

// Chrome:
const myArray = new Array( 10 );

myArray;
> (10) [empty × 10]

खाली स्लॉट वाली कलेक्शन (कभी-कभी इसे "स्पार्स अरे" भी कहा जाता है) खास होती हैं मामले. undefined या साफ़ तौर पर null वैल्यू शामिल करने के बजाय, फ़ील्ड खाली है स्लॉट को अक्सर, लेकिन हमेशा नहीं, undefined वैल्यू माना जाता है. भाषा.

आप अरे लिटरल सिंटैक्स का इस्तेमाल करके गलती से एक स्पार्स अरे बना सकते हैं लिटरल वैल्यू वाला अरे बनाते समय, कॉमा के बीच के किसी वैल्यू को छोड़ना:

const myArray = [ true,, true, false ];

myArray;
> Array(4) [ true, <1 empty slot>, true, false ]

सभी कॉन्टेक्स्ट में अहम वैल्यू न माने जाने के बावजूद, एक खाली स्लॉट को अरे की कुल लंबाई में फ़ैक्टर किया जाता है, जिससे संभावित रूप से बार-बार होने पर ऐसे नतीजे मिल सकते हैं जिनकी उम्मीद नहीं थी किसी अरे की वैल्यू:

const myArray = [ 1,, 3, 4 ];

myArray.length;
> 4

for( const myValue of myArray ) {
  console.log( myValue + 10 );
}
> 11
> NaN
> 13
> 14

यह व्यवहार JavaScript के कुछ शुरुआती डिज़ाइन फ़ैसलों का एक होल्डओवर है. आधुनिक डेवलपमेंट में, कम अरे का इस्तेमाल करने से बचें.

प्रिमिटिव की तरह, लिटरल वैल्यू इसके कंस्ट्रक्टर से प्रॉपर्टी और मेथड इनहेरिट करता है. क्योंकि अरे ऑब्जेक्ट का एक खास फ़ॉर्मैट है, इसलिए अरे लिटरल सिंटैक्स और new Array() सिंटैक्स, फ़ंक्शनल रूप से एक जैसे नतीजे बनाता है: एक ऑब्जेक्ट जो इसका प्रोटोटाइप, Array कंस्ट्रक्टर से इनहेरिट करता है.

const arrayLiteral = [];
const arrayConstructor = new Array();

typeof arrayLiteral;
> "object"

arrayLiteral;
> Array []
    length: 0
    <prototype>: Array []

typeof arrayConstructor;
> "object"

arrayConstructor;
> Array []
    length: 0
    <prototype>: Array []

दोनों नतीजे एक जैसे हैं और अरे का लिटरल सिंटैक्स ज़्यादा छोटा है और लिटरल है, तो हम आपको इसके बजाय हमेशा अरे लिटरल सिंटैक्स का इस्तेमाल करने का सुझाव देते हैं new Array() सिंटैक्स.

अरे की वैल्यू ऐक्सेस करना

ब्रैकेट नोटेशन का इस्तेमाल करके, कलेक्शन में मौजूद अलग-अलग एलिमेंट को ऐक्सेस किया जा सकता है ब्रैकेट ([]) का सेट, जो अरे या इसके आइडेंटिफ़ायर के बाद होता है. इसमें नंबर:

[ "My string", "My other string" ][ 1 ];
> "My other string"

const myArray = [ "My string", 50, true ];

myArray[ 0 ];
> "My string"

myArray[ 1 ];
> 50

myArray[ 2 ];
> true

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

const myArray = [ "My string", 50, true ];

myArray[ 2 ];
> true

myArray[ "2" ];
> true

अरे में तय किए गए एलिमेंट से बाहर के किसी एलिमेंट को ऐक्सेस करने की कोशिश करने पर, ऐसा होता है undefined, गड़बड़ी नहीं:

const myArray = [ "My string", 50, true ];

myArray[ 9 ];
> undefined

असाइनमेंट बंद किया जा रहा है

असाइनमेंट को डिस्ट्रक्चर करना, यहां से वैल्यू की रेंज को निकालने का एक छोटा तरीका है अरे या ऑब्जेक्ट को असाइन कर सकते हैं और उन्हें आइडेंटिफ़ायर हैं, इस प्रोसेस को कभी-कभी "अनपैकिंग" भी कहा जाता है ओरिजनल डेटा स्ट्रक्चर, हालांकि, यह ओरिजनल अरे या ऑब्जेक्ट में बदलाव नहीं करता.

डिस्ट्रक्चर करने वाला असाइनमेंट, आइडेंटिफ़ायर की अरे या ऑब्जेक्ट जैसी सूची का इस्तेमाल करता है, ताकि वैल्यू को ट्रैक किया जा सकता है. अपने सबसे आसान रूप में, इसे बाइंडिंग पैटर्न कहा जाता है नष्ट करने के बाद, हर वैल्यू को अरे या ऑब्जेक्ट से अनपैक करके संबंधित वैरिएबल, let या const (या var) का इस्तेमाल करके शुरू किया गया:

const myArray = [ "A string", "A second string" ];
const [ myFirstElement, mySecondElement ] = myArray;

const myObject = { firstValue: false, secondValue: true };
const { myProp, mySecondProp } = myObject;

myFirstElement;
> "My string"

mySecondElement;
> "Second string"

myProp;
> false

mySecondProp;
> true

किसी ऑब्जेक्ट को अलग करने के लिए, कर्ली ब्रैकेट ({}) का इस्तेमाल करें. साथ ही, स्क्वेयर ब्रैकेट ([]) का इस्तेमाल करके, कलेक्शन को अलग करना.

const myArray = [ false, true ];
const myObject = { firstValue: false, secondValue: true };

const [ myProp, mySecondProp ] = myObject;
> Uncaught TypeError: myObject is not iterable

const { myElement, mySecondElement } = myArray;

myElement
> undefined

mySecondElement;
> undefined

किसी अरे को बनाने का काम, बाईं से दाईं ओर क्रम में होता है. हर डिस्ट्रक्चरिंग असाइनमेंट में आइडेंटिफ़ायर समान इंडेक्स वाली अरे:

const myArray = [ 1, 2, 3 ];
const [ myElement, mySecondElement, myThirdElement ] = myArray;

myElement;
> 1

mySecondElement;
> 2

myThirdElement;
> 3

किसी ऑब्जेक्ट को नष्ट करते समय भी यही डिफ़ॉल्ट व्यवहार है. हालांकि, अगर डिस्ट्रक्चरिंग असाइनमेंट में इस्तेमाल किए गए आइडेंटिफ़ायर, ऑब्जेक्ट की कुंजियों से मेल खाते हैं प्रॉपर्टी, उन आइडेंटिफ़ायर से जुड़ी प्रॉपर्टी की जानकारी अपने-आप भर जाती है दिए गए क्रम पर ध्यान दिए बिना:

const myObject = { firstValue: 1, secondValue: 2, thirdValue 3 };
const { secondValue, thirdValue, firstValue } = myObject;

firstValue;
> 1

secondValue;
> 2

thirdValue;
> 3

किसी आइडेंटिफ़ायर को छोड़कर, एलिमेंट को स्किप किया जा सकता है:

const myArray = [ 1, 2, 3 ];
const [ firstValue,, secondValue ] = myArray;

firstValue;
> 1

secondValue;
> 3

सिंटैक्स को डिस्ट्रक्चर करने से, आपको डिफ़ॉल्ट वैल्यू असाइन करने का भी विकल्प मिलता है. ऐसा तब किया जाता है, जब आपके ऐसेट का क्रम डीस्ट्रक्चर होता है मान या तो एक खाली स्लॉट है, जैसा कि विरल अरे के मामले में होता है या undefined वैल्यू.

const myArray = [ true, ];
const [ firstValue = "Default string.", secondValue = "Default string." ] = myArray;

firstValue;
> true

secondValue;
> "Default string."

डिकंस्ट्रक्शन, वैल्यू को खास टाइप के लिए लिंक नहीं करता. इसका मतलब है कि "गलत" वैल्यू, जैसे कि खाली स्ट्रिंग ("") या null को अब भी सही तरीके से डिकोड की गई वैल्यू माना जाता है:

const myArray = [ false, null, 0, "",, undefined ];
const [ falseValue = true, nullValue = true, zeroValue = true, emptyStringValue = true, emptySlot = true, undefinedValue = true ] = myArray;

falseValue;
> false;

nullValue;
> null

zeroValue;
> 0

emptyStringValue;
> ""

emptySlot;
> true

undefinedValue;
> true

स्प्रेड ऑपरेटर

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

const myArray = [ 1, 2, 3 ];

console.log( ...myArray );
> 1 2 3

स्प्रेड सिंटैक्स का इस्तेमाल मुख्य रूप से अरे को कॉपी करने और जोड़ने के लिए किया जाता है:

const myArray = [ 4, 5, 6 ];
const mySecondArray = [1, 2, 3, ...myArray ];

mySecondArray;
> Array(6) [ 1, 2, 3, 4, 5, 6 ]

स्प्रेड सिंटैक्स का इस्तेमाल सिर्फ़ इन कॉन्टेक्स्ट में किया जा सकता है:

सरणियों और स्ट्रिंग के लिए, स्प्रेड सिंटैक्स सिर्फ़ तब लागू होता है, जब शून्य या ज़्यादा आर्ग्युमेंट किसी फ़ंक्शन कॉल में या किसी अरे में मौजूद एलिमेंट की उम्मीद की जाती है. इसका पहला उदाहरण इस सेक्शन में स्प्रेड ऑपरेटर सिंटैक्स काम करता है, क्योंकि यह ...myArray को पहले से मौजूद console.log मेथड के लिए आर्ग्युमेंट.

उदाहरण के लिए, आप डेटा को किसी बाहरी वैरिएबल पर असाइन नहीं कर सकते कोई अन्य अरे:

const myArray = [ 1, 2, 3 ];
const spreadVariable = ...myArray;
> Uncaught SyntaxError: Unexpected token '...'

हालांकि, किसी अरे को कॉपी करने के लिए, ओरिजनल अरे को लिटरल अरे में बांटा जाता है:

const myArray = [ 1, 2, 3 ];
const spreadArray = [ ...myArray ];

spreadArray;
> Array(3) [ 1, 2, 3 ]

दो या उससे ज़्यादा सरणियों को बनाने वाले एलिमेंट को किसी एक अरे में मर्ज करने के लिए:

const myArray = [ 1, 2, 3 ];
const mySecondArray = [ 4, 5, 6 ];
const myNewArray = [ ...myArray, ...mySecondArray ];

myNewArray;
> Array(6) [ 1, 2, 3, 4, 5, 6 ]

इसके अलावा, किसी फ़ंक्शन कॉल में किसी अरे के एलिमेंट को अलग-अलग आर्ग्युमेंट के तौर पर पास करने के लिए:

const myArray = [ true, false ];
const myFunction = ( myArgument, mySecondArgument ) => {
    console.log( myArgument, mySecondArgument );
};

myFunction( ...myArray );
> true false

स्प्रेड ऑपरेटर को ES2018 में ऑब्जेक्ट की लिटरल वैल्यू. कलेक्शन की तरह ही, ऑब्जेक्ट को डुप्लीकेट या मर्ज करने के लिए, स्प्रेड ऑपरेटर का इस्तेमाल किया जा सकता है:

const myObj = { myProperty : true };
const mySecondObj = { ...myObj };

mySecondObj;
> Object { myProperty: true }

const myFirstObj = { myProperty : true };
const mySecondObj = { additionalProperty : true };
const myMergedObj = { ...myFirstObj, ...mySecondObj };

myMergedObj;
> Object { myProperty: true, additionalProperty: true }

स्प्रेड ऑपरेटर "शॉलो" बनाता है कॉपी. इसका मतलब है कि यह ओरिजनल ऑब्जेक्ट का प्रोटोटाइप और जिनकी गिनती नहीं की जा सकती प्रॉपर्टी.

const myCustomPrototype = { protoProp: "My prototype." };
const myObj = Object.create( myCustomPrototype, {
    myEnumerableProp: {
        value: true,
        enumerable: true
    },
    myNonEnumerableProp: {
        value: false,
        enumerable: false
    }
});
const myNewObj = { ...myObj };

myObj;
> Object { myEnumerableProp: true, … }
    myEnumerableProp: true
    myNonEnumerableProp: false
    <prototype>: Object { protoProp: "My prototype." }

myNewObj;
> Object { myEnumerableProp: true }
    myEnumerableProp: true
    <prototype>: Object { … }

ध्यान रखें कि अरे और ऑब्जेक्ट को एक-दूसरे की जगह इस्तेमाल नहीं किया जा सकता. आप ये काम नहीं कर सकते किसी अरे में ऑब्जेक्ट, या अरे को ऑब्जेक्ट में बांटकर.

आराम करने वाला ऑपरेटर

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

स्ट्रक्चर को नष्ट करने के असाइनमेंट के साथ इस्तेमाल किए जाने पर, सिंटैक्स को "बाकी प्रॉपर्टी" कहा जाता है सिंटैक्स.

const myArray = [ "First", "Second", "Third", "Fourth", "Fifth" ];

[ myFirstElement, mySecondElement, ...remainingElements ] = myArray;

myFirstElement;
> "First"

mySecondElement;
> "Second"

remainingElements;
> Array(3) [ "Third", "Fourth", "Fifth"]

जब इसका इस्तेमाल किसी फ़ंक्शन में अनिश्चित संख्या में आर्ग्युमेंट देने के लिए किया जाता है, सिंटैक्स को "बाकी पैरामीटर" कहा जाता है सिंटैक्स:

function myFunction( ...myParameters ) {
    let result = 0;
    myParameters.forEach( ( myParam ) => {
        result += myParam;
    });
    return result;
};

myFunction( 2, 2 );
> 4

myFunction( 1, 1, 1, 10, 5 );
> 18

myFunction( 10, 11, 25 );
> 46

%TypedArray%

टाइप की गई सरणियां ES6 की एक सुविधा हैं जिन्हें स्ट्रक्चर्ड बाइनरी डेटा को स्टोर करने के लिए डिज़ाइन किया गया है. उदाहरण के लिए, अपलोड की गई फ़ाइलों पर काम करते समय या WebGL.

प्रतीकों की तरह ही, %TypedArray% इंट्रिन्सिक फ़ंक्शन (आम तौर पर, %TypedArray% या @@TypedArray के तौर पर दस्तावेज़ किया जाता है) इसलिए इसे ग्लोबल प्रॉपर्टी नहीं माना जा सकता) पारंपरिक समझ से मेल खाता है और आप उसे new के साथ शुरू नहीं कर सकते या सीधे तौर पर कॉल नहीं कर सकते. इसके बजाय, %TypedArray% व्यक्ति की पैरंट सुपर क्लास के बारे में बताता है कंस्ट्रक्टर, जिनमें से हर एक खास बाइनरी डेटा फ़ॉर्मैट के साथ काम करता है. कॉन्टेंट बनाने intrinsic %TypedArray% सुपर क्लास ऐसी प्रॉपर्टी और यूटिलिटी मेथड उपलब्ध कराता है जो सभी %TypedArray% कंस्ट्रक्टर की सब-क्लास और उनके इंस्टेंस इनहेरिट किए जाते हैं.

देखें कि आपको कितना समझ आया है