] एरेज़ ऑब्जेक्ट हैं, इसलिए उनके पास जेएस में भी तरीके हैं।

स्लाइस (शुरुआत): मूल सरणी को म्यूट किए बिना, एक नए सरणी में सरणी का हिस्सा निकालें।

] // usecase: अनुक्रमित के रूप में पारित होने तक निकालें arr.slice (2); // ['सी', 'डी', 'ई'] // usecase: [प्रथम सूचकांक] से [दूसरा सूचकांक -1] मान तक निकालें। arr.slice (2,4); // ['C', 'D'] यानी सरणी की लंबाई अंत-बेगिन या 4-2 = 2 होगी // usecase: अंतिम 2 तत्वों को निकालें arr.slice (-2); // ['डी', 'ई'] // usecase: अंतिम तत्व निकालें। arr.slice (-1); // ['ई'] // usecase: अंतिम दो तत्वों को छोड़ने के लिए पारित सूचकांक से निकालें। arr.slice (1, -2); // ['ई'] // usecase: एक सरणी की एक उथली प्रतिलिपि बनाएँ arr.slice (); // 1 तरीका [... गिरफ्तारी]; // दूसरा रास्ता

स्प्लिस: मूल सरणी को म्यूट करता है

] उत्पत्ति को उत्परिवर्तित करता है। सरणी। // रिटर्न: हटाए गए सरणी का हिस्सा लेट गिरफ्तार = ['ए', 'बी', 'सी', 'डी', 'ई']; // arr.splice (2); // ['सी', 'डी', 'ई'] // गिरफ्तारी; // ['ए', 'बी'] // usecase: सरणी के अंतिम तत्व को हटा दें // arr.splice (-1); // ['ई'] // गिरफ्तारी; //

// usecase: तत्वों के किसी भी को हटा दें। स्प्लिस (सूचकांक, हटाना) arr.splice (1, 3); // ['बी', 'सी', 'डी'] गिरफ्तारी; // ['ए', 'ई']

let arr = ['a','b','c','d','e'];

// Usecase: Extract till index passed as argument
arr.slice(2); // [ 'c', 'd', 'e' ]

// Usecase: Extract from [first index] to [second index-1] value.
arr.slice(2,4); // [ 'c', 'd' ] i.e Length of array will be end-begin or 4-2 = 2 

// Usecase: Extract last 2 elements
arr.slice(-2); // [ 'd', 'e' ]

// Usecase: Extract the last element.
arr.slice(-1);  // [ 'e' ]  

// Usecase: Extract from index passed to leaving the last two elements.
arr.slice(1,-2);  // [ 'e' ]  

// Usecase: Create a shallow copy of an array
arr.slice(); // 1st way
[...arr]; // 2nd way

रिटर्न: उलट सरणी

// splice: remove the elements begining from the index passed. Mutates the orig. array.
// returns: part of the removed array
let arr = ['a','b','c','d','e'];
// arr.splice(2); // [ 'c', 'd', 'e' ]
// arr; // [ 'a', 'b' ]

// Usecase: Remove last element of the array
// arr.splice(-1); // [ 'e' ]
// arr; // [ 'a', 'b', 'c', 'd' ]

// Usecase: Delete no of elements. splice(index, deleteCount)
arr.splice(1, 3); // [ 'b', 'c', 'd' ]
arr; // [ 'a', 'e' ]

CONCAT: दो सरणियों में शामिल होता है।

रिटर्न: शामिल सरणी

] Arr2 = ['f', 'g', 'h', 'i', 'j']; [... arr1, ... arr2]; // 1 तरीका arr2 = arr1.concat (arr2); // दूसरा रास्ता

let arr = ['a','b','c','d','e'];
let arr2 = arr.reverse();
arr;
arr2;

जुड़ें: दो सरणियों में शामिल होते हैं।

रिटर्न: शामिल सरणी

] Arr2 = ['f', 'g', 'h', 'i', 'j']; const x = arr1.concat (arr2); x.join ('-'); // 'ए-बी-सी-डी-ई-एफ-जी-एच-एच-आई-जे'

let arr1 = ['a','b','c','d','e'];
let arr2 = ['f','g','h','i','j'];

[...arr1, ...arr2];       // 1st way
arr2 = arr1.concat(arr2); // 2nd way

AT: अंत से गिनती शुरू करता है, -1 के रूप में सूचकांक के साथ भीख करना शुरू करता है

suports विधि चेनिंग। सरणियों पर काम करता है, स्ट्रिंग्स

] गिरफ्तारी [0]; // 1 तरीका arr.at (0); // दूसरा रास्ता // सरणी का अंतिम तत्व प्राप्त करें arr [arr.length - 1]; // 1 तरीका arr.slice (-1) [0]; // दूसरा रास्ता arr.at (-1); // तीसरा रास्ता arr.at (0); // 'ए' arr.at (-1); // 'ई'

let arr = ['a','b','c','d','e'];
let arr2 = arr.reverse();
arr;
arr2;

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

// foreach विधि का उपयोग करके सरणी पर लूपिंग। खाता = [2000, -300, 400, -200, -500, 1000, -300]; // एक सरणी पर लूप का उपयोग करके एक सरणी पर के लिए (खाते का पैसा) { if (पैसा> 0) { Console.log (`$ {पैसा}}` जमा किया गया); } अन्य { कंसोल.लॉग (`$ {math.abs (पैसा)}}`); } } // .entries (): सरणियों की एक सरणी लौटाता है। // इंडेक्स-वैल्यू जोड़ी के रूप में आउटपुट लौटाएं। // पहला तत्व सूचकांक होना चाहिए, दूसरा तत्व तत्व-मूल्य होना चाहिए for (चलो [i, पैसा] खाता। if (पैसा> 0) { कंसोल.लॉग (`लेनदेन $ {i 1}, $ {पैसा}}`) जमा किया गया; } अन्य { कंसोल.लॉग (`लेनदेन $ {i 1}, $ {math.abs (पैसा)}}`) वापस ले लिया; } } // फोरच का उपयोग करके एक सरणी पर लूप करें जिसे कॉलबैक एफएन की आवश्यकता होती है। // foreach कॉलबैक fn को कॉल करेगा, न कि हम। // foreach प्रत्येक तत्व को हर पुनरावृत्ति में तर्क के रूप में पारित करेगा। खाता.फ़ोरच (फ़ंक्शन (पैसा) { if (पैसा> 0) { Console.log (`$ {पैसा}}` जमा किया गया); } अन्य { कंसोल.लॉग (`$ {math.abs (पैसा)}}`); } }); // पुनरावृत्ति 1: Arg1 को CB-FN (ARG1) से पास करें // पुनरावृत्ति 2: ARG2 को CB-FN (ARG2) को पास करें // पुनरावृत्ति 3: Arg3 को CB-FN (ARG3) से पास करें // ..... // ..... // foreach प्रत्येक तत्व, सूचकांक, सरणी को हर पुनरावृत्ति में तर्क के रूप में पास करेगा। तर्क का आदेश मायने रखता है, इन तर्कों में से कोई नहीं, यानी पहला तत्व वर्तमान-तत्व होना चाहिए, दूसरा तत्व सूचकांक होना चाहिए, तीसरा तत्व पूरा सरणी होना चाहिए जिसे लूप-ओवर किया जा रहा है। // पहला तत्व तत्व-मूल्य होना चाहिए, दूसरा तत्व सूचकांक होना चाहिए, तीसरा तत्व पूरा सरणी होना चाहिए। यह है कि कैसे सरणी से अलग है। खाता। फ़ॉरेच (फ़ंक्शन (पैसा, i, arr) { if (पैसा> 0) { कंसोल.लॉग (`लेनदेन $ {i 1}, $ {धन} को $ {arr}} में जमा किया गया; } अन्य { Console.log (`लेनदेन $ {i 1}, $ {math.abs (पैसा)} $ {arr}`) से वापस ले लिया गया; } });

कब और foreach का उपयोग करने के लिए:

foreach: इसे तोड़ नहीं सकते। जारी रखें-ब्रेक इसके अंदर काम न करें। हमेशा पूरे सरणी पर लूप करेगा, और इसे रोकने के लिए कुछ भी नहीं किया जा सकता है।

let arr = ['a','b','c','d','e'];

arr[0];    // 1st way
arr.at(0); // 2nd way

// Get the last element of the array
arr[arr.length - 1];  // 1st way
arr.slice(-1)[0];     // 2nd way
arr.at(-1);           // 3rd way

arr.at(0); // 'a'
arr.at(-1); // 'e'

"जैसा कि आप अधिक और अधिक अभ्यास करते हैं, आप अपने कौशल में बेहतर हो जाएंगे।"