JavaScript में Array क्लास के पास ऐरे बदलने के लिए बहुत सारे शक्तिशाली और पहले से मौजूद मेथड हैं।
ये मेथड एक ऐरे को दूसरे ऐरे में बदलना बहुत आसान बना देते हैं। साधारण for लूप या सीधे-सीधे बदलाव करके यही काम करना उसके मुकाबले कहीं ज़्यादा मुश्किल होता है।
कुछ मेथड प्योर होते हैं, यानी वे मूल ऐरे को नहीं बदलते।
इसके बजाय वे एक नया ऐरे लौटाते हैं।
लेकिन कुछ मेथड ऐसे भी हैं जो उस ऐरे को बदल देते हैं जिस पर उन्हें कॉल किया जाता है, और बदला हुआ ऐरे नहीं लौटाते।
ऐरे बदलने के लिए सबसे ज़्यादा इस्तेमाल होने वाले कुछ मेथड नीचे दिए गए हैं।
उपलब्ध सभी मेथड की पूरी सूची MDN दस्तावेज़ में मिल सकती है।
map (प्योर)
यह हर एलिमेंट को बदलकर एक नया ऐरे बनाता है, और इसके लिए आर्गुमेंट के रूप में दिया गया फंक्शन इस्तेमाल करता है।
ये कॉलबैक फंक्शन अक्सर एरो फंक्शन के रूप में लिखे जाते हैं।
let arr = [1, 2, 3, 4];
const newArr = arr.map((value) => value - 1);
console.log(newArr);
// => [0, 1, 2, 3]
console.log(arr);
// => [1, 2, 3, 4]
ध्यान देने की बात है कि बने हुए ऐरे की लंबाई हमेशा मूल ऐरे के बराबर ही होती है।
filter (प्योर)
मौजूदा ऐरे को एक फ़िल्टरिंग फंक्शन की मदद से छानकर एक नया ऐरे बनाता है (यह फंक्शन सही लौटाता है अगर एलिमेंट रखा जाना चाहिए, और गलत अगर उसे हटाया जाना चाहिए)।
let arr = [1, 2, 3, 4];
arr.filter((value) => value % 2 === 0);
// => [2, 4]
reduce (प्योर)
एक फंक्शन की मदद से ऐरे को घटाकर एक ही वैल्यू बना देता है।
यह फंक्शन एक एक्युमुलेटर और ऐरे के मौजूदा एलिमेंट को पैरामीटर के रूप में लेता है।
फिर यह बताता है कि मौजूदा एलिमेंट को एक्युमुलेटर में कैसे जोड़ा जाए, और वह एक्युमुलेटर लौटाता है जो अगले इटरेशन में इस्तेमाल होगा।
let arr = [1, 2, 3, 4];
// Get the sum of elements
arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
// => 10
// Classify the numbers by whether they are odd or not
arr.reduce(
(accumulator, currentValue) => {
if (currentValue % 2 === 0) {
accumulator.even.push(currentValue);
} else {
accumulator.odd.push(currentValue);
}
return accumulator;
},
{ even: [], odd: [] },
);
// => { even: [2, 4], odd: [1, 3] }
reverse
ऐरे के एलिमेंट का क्रम उलट देता है।
const arr = [1, 2, 3, 4];
arr.reverse();
// => [4, 3, 2, 1]
यह मेथड उसी ऐरे को बदल देता है जिस पर इसे कॉल किया जाता है।
slice (प्योर)
एक शुरुआती और एक अंतिम इंडेक्स दिए जाने पर, पैरामीटर के रूप में दिए गए ऐरे से एक उप-ऐरे बनाता है।
अंतिम इंडेक्स वाला एलिमेंट इसमें शामिल नहीं होता।
साथ ही, सारे पैरामीटर वैकल्पिक हैं:
शुरुआती इंडेक्स का डिफ़ॉल्ट 0 होता है, और अंतिम इंडेक्स का डिफ़ॉल्ट ऐरे की लंबाई होती है।
const arr = [1, 2, 3, 4];
arr.slice(1, 2); // [2]
arr.slice(1); // [2, 3, 4]
// You can also use negative numbers, that represent the indexes
// starting from the end of the array
arr.slice(-2); // [3, 4]
splice
ऐरे के एलिमेंट हटाता है या बदल देता है, और/या नए एलिमेंट जोड़ता है।
यह निम्नलिखित पैरामीटर लेता है:
- उस एलिमेंट का इंडेक्स जहाँ से ऐरे बदलना शुरू करना है
- हटाए जाने वाले एलिमेंट की संख्या
- ऐरे में डाले जाने वाले एलिमेंट (वैकल्पिक)
splice हटाए गए एलिमेंट लौटाता है।
const arr = ['1', '2', '5', '6'];
// Insert an element at index 2
arr.splice(2, 0, '3');
console.log(arr);
// => ['1', '2', '3', '5', '6']
// Remove 2 elements, starting at index 3 and insert 2 elements
const removed = arr.splice(3, 2, '4', '5');
console.log(removed);
// => ['5', '6']
console.log(arr);
// => ['1', '2', '3', '4', '5']
// Remove 1 element at index 1
arr.splice(1, 1);
console.log(arr);
// => ['1', '3', '4', '5']
sort
डिफ़ॉल्ट रूप से, sort ऐरे के एलिमेंट को पहले स्ट्रिंग में बदलकर, फिर स्ट्रिंग तुलना लगाकर क्रम में लगाता है (देखिए तुलना)।
यह छँटाई जगह पर ही होती है, यानी मूल ऐरे बदल जाता है।
sort वह बदला हुआ ऐरे भी लौटाता है, जो तब काम आता है जब आप उस पर दूसरे मेथड की चेन लगाना चाहते हैं।
const arr = ['c', 'a', 'z', 'b'];
const result = arr.sort();
console.log(result);
// => ['a', 'b', 'c', 'z']
console.log(arr);
// => ['a', 'b', 'c', 'z']
छँटाई का व्यवहार अपने हिसाब से बदलने के लिए आप आर्गुमेंट के रूप में एक तुलना फंक्शन दे सकते हैं।
इस तुलना फंक्शन को ऐरे के दो एलिमेंट के साथ, यानी दो आर्गुमेंट के साथ कॉल किया जाता है।
फिर इसे निम्नलिखित लौटाना होता है:
- एक ऋणात्मक संख्या, अगर पहला आर्गुमेंट दूसरे से पहले होना चाहिए
- एक धनात्मक संख्या, अगर पहला आर्गुमेंट दूसरे के बाद होना चाहिए
-
0, अगर एलिमेंट का क्रम वैसा ही रहना चाहिए
यहाँ एक उदाहरण दिया गया है कि ऑब्जेक्ट के ऐरे को क्रम में लगाने के लिए अपना तुलना फंक्शन कैसे इस्तेमाल किया जा सकता है।
const arr = [
{ name: 'Lydia', age: 7 },
{ name: 'Anne', age: 34 },
{ name: 'Holger', age: 59 },
];
arr.sort((item1, item2) => {
if (item1.name < item2.name) {
return -1;
}
if (item1.name > item2.name) {
return 1;
}
return 0;
});
// => [ { name: 'Anne', age: 34 }, { name: 'Holger', age: 59 },
// { name: 'Lydia', age: 7 } ]
सीखने का अभ्यास
