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

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

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

// उपयोगकेस: अंतिम दो तत्वों को छोड़ने के लिए पारित सूचकांक से उद्धरण। arr.slice(1,-2); //

// उपयोगकेस: किसी सरणी की एक उथली प्रतिलिपि बनाएँ arr.slice(); // पहला तरीका [...arr]; // दूसरा तरीका

// 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' ]

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

// गिरफ्तार; //

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

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

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

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

let arr = ['a','b','c','d','e']; चलो arr2 = arr.revers(); गिरफ्तार; गिरफ्तार2;

concat: दो सरणियों को जोड़ता है।

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

रिटर्न: सम्मिलित सरणी

let arr1 = ['a','b','c','d','e']; चलो arr2 = ['f','g','h','i','j']; [...arr1, ...arr2]; // पहला तरीका arr2 = arr1.concat(arr2); // दूसरा तरीका

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

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

रिटर्न: सम्मिलित सरणी

let arr1 = ['a','b','c','d','e']; चलो arr2 = ['f','g','h','i','j']; स्थिरांक x = arr1.concat(arr2); x.join('-'); // 'ए-बी-सी-डी-ई-एफ-जी-एच-आई-जे'

"जैसे-जैसे समय आगे बढ़ेगा, आप उन्हें उनके उपयोग के आधार पर याद रखेंगे।"

at: सूचकांक -1 से शुरू करते हुए, अंत से गिनती शुरू करता है

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

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

let arr = ['a','b','c','d','e']; गिरफ्तार[0]; // पहला तरीका arr.at(0); // दूसरा तरीका // सरणी का अंतिम तत्व प्राप्त करें गिरफ्तारी[एआर.लंबाई - 1]; // पहला तरीका arr.slice(-1)[0]; // दूसरा तरीका arr.at(-1); // तीसरा तरीका arr.at(0); // 'ए' arr.at(-1); // 'ई'

// Looping over array using forEach method.
let account = [2000,-300, 400, -200, -500,  1000, -300];

// Loop over an array using for-of
for(let money of account){
  if(money > 0){
    console.log(`Deposited ${money}`);
  } else {
    console.log(`Withdrawn ${Math.abs(money)}`);
  }
}

// .entries(): returns an array of arrays.
// return the output as index-value pair.
// first element must be index, second element must be element-value
for(let [i,money] of account.entries()){
  if(money > 0){
    console.log(`Transaction ${i 1}, Deposited ${money}`);
  } else {
    console.log(`Transaction ${i 1}, Withdrawn ${Math.abs(money)}`);
  }
}

// Loop over an array using forEach which requires a callback fn.
// forEach will call the callback fn, and not we.
// forEach will pass each element as argument in every iteration.
account.forEach(function(money){
  if(money > 0){
    console.log(`Deposited ${money}`);
  } else {
    console.log(`Withdrawn ${Math.abs(money)}`);
  }
});
// Iteration 1: pass arg1 to CB-fn(arg1)
// Iteration 2: pass arg2 to CB-fn(arg2)
// Iteration 3: pass arg3 to CB-fn(arg3)
// .....
// .....


// forEach will pass each element, index, array as argument in every iteration. Order of arguments matter, not the no of these arguments i.e first element should be the current-Element, second element should be index, third element should be entire array which is being looped-over.
// first element must be element-value, second element should be index, third element must be entire array. This is how its different from array.entries()
account.forEach(function(money, i, arr){
  if(money > 0){
    console.log(`Transaction ${i 1}, Deposited ${money} into ${arr}`);
  } else {
    console.log(`Transaction ${i 1}, Withdrawn ${Math.abs(money)} from ${arr}`);
  }
});

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

// प्रत्येक विधि का उपयोग करके सरणी पर लूपिंग। मान लीजिए खाता = [2000,-300, 400, -200, -500, 1000, -300]; // for-of का उपयोग करके किसी सरणी पर लूप करें के लिए(खाते का पैसा दें){ अगर(पैसा > 0){ कंसोल.लॉग(`जमा किया गया ${पैसा}`); } अन्य { कंसोल.लॉग(`निकाले गए ${Math.abs(money)}`); } } // .entries(): सरणियों की एक सरणी लौटाता है। // आउटपुट को इंडेक्स-वैल्यू पेयर के रूप में लौटाएं। // पहला तत्व इंडेक्स होना चाहिए, दूसरा तत्व एलिमेंट-वैल्यू होना चाहिए for(let [i,money] of account.entries()){ अगर(पैसा > 0){ कंसोल.लॉग(`लेन-देन ${i 1}, जमा किया गया ${पैसा}`); } अन्य { कंसोल.लॉग(`लेन-देन ${i 1}, निकाला गया ${Math.abs(money)}`); } } // forEach का उपयोग करके एक सरणी पर लूप करें जिसके लिए कॉलबैक fn की आवश्यकता होती है। //forEach कॉलबैक fn को कॉल करेगा, हम नहीं। // forEach प्रत्येक तत्व को प्रत्येक पुनरावृत्ति में तर्क के रूप में पारित करेगा। खाता.प्रत्येक के लिए(फ़ंक्शन(पैसा){ अगर(पैसा > 0){ कंसोल.लॉग(`जमा किया गया ${पैसा}`); } अन्य { कंसोल.लॉग(`निकाले गए ${Math.abs(money)}`); } }); // पुनरावृत्ति 1: arg1 को CB-fn(arg1) पर पास करें // पुनरावृत्ति 2: arg2 को CB-fn(arg2) में पास करें // पुनरावृत्ति 3: arg3 को CB-fn(arg3) में पास करें // ..... // ..... // forEach प्रत्येक तत्व, सूचकांक, सरणी को प्रत्येक पुनरावृत्ति में तर्क के रूप में पारित करेगा। तर्कों का क्रम मायने रखता है, न कि इन तर्कों की संख्या यानी पहला तत्व वर्तमान-तत्व होना चाहिए, दूसरा तत्व सूचकांक होना चाहिए, तीसरा तत्व संपूर्ण सरणी होना चाहिए जिसे लूप-ओवर किया जा रहा है। // पहला तत्व तत्व-मूल्य होना चाहिए, दूसरा तत्व सूचकांक होना चाहिए, तीसरा तत्व संपूर्ण सरणी होना चाहिए। इस प्रकार यह array.entries() से भिन्न है account.forEach(function(money, i, arr){ अगर(पैसा > 0){ कंसोल.लॉग(`लेन-देन ${i 1}, ${money} को ${arr}` में जमा किया गया); } अन्य { कंसोल.लॉग(`लेन-देन ${i 1}, ${arr}` से ${Math.abs(money)} निकाला गया); } });

कब उपयोग करें for-of और forEach:

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

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