ऐरे रूपांतरण में

ऐरे रूपांतरण के बारे में

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

const arr = [3, 1, 2, 10];
arr.sort();
// => [1, 10, 2, 3]
// Because the string '10' comes before '2' in dictionary order.

सॉर्टिंग का व्यवहार अपनी पसंद के मुताबिक बनाने के लिए आप एक तुलना फंक्शन को आर्गुमेंट के तौर पर पास कर सकते हैं। तुलना फंक्शन को खुद दो आर्गुमेंट के साथ कॉल किया जाता है, जो ऐरे के दो एलिमेंट होते हैं। फिर उसे यह लौटाना होता है:

• एक ऋणात्मक संख्या, अगर पहला आर्गुमेंट दूसरे से पहले होना चाहिए
• एक धनात्मक संख्या, अगर पहला आर्गुमेंट दूसरे के बाद होना चाहिए
• 0, अगर एलिमेंट का क्रम वैसा ही रहना चाहिए

इस तरह, सही तुलना फंक्शन पास करके संख्याओं को सॉर्ट करने की समस्या ठीक की जा सकती है।

const arr = [3, 1, 2, 10];
arr.sort((a, b) => a - b);
// => [1, 2, 3, 10]
// "a - b" is negative when b is greater than a, positive when
// a is greater than b and 0 when they are equal.

यहाँ एक उदाहरण है कि ऑब्जेक्ट के ऐरे को सॉर्ट करने के लिए अपना तुलना फंक्शन कैसे इस्तेमाल किया जा सकता है।

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 } ]

2019 से भाषा का स्पेसिफिकेशन कहता है कि सॉर्टिंग स्टेबल होनी चाहिए, लेकिन प्रदर्शन (समय और स्थान की जटिलता) के बारे में कोई गारंटी नहीं है।