सरणी जावास्क्रिप्ट में सबसे अधिक उपयोग की जाने वाली डेटा संरचनाओं में से एक है। वे आपको एक ही वेरिएबल में कई मानों को संग्रहीत करने की अनुमति देते हैं और अंतर्निहित कार्यों के एक समृद्ध सेट के साथ आते हैं जो डेटा के साथ हेरफेर करना और काम करना सरल और कुशल बनाते हैं। इस लेख में, हम जावास्क्रिप्ट ऐरे फ़ंक्शंस का विस्तार से पता लगाएंगे, आपको उनमें महारत हासिल करने में मदद करने के लिए स्पष्टीकरण, उदाहरण और टिप्पणियाँ प्रदान करेंगे।

जावास्क्रिप्ट में ऐरे का परिचय

एक सरणी वस्तुओं का एक क्रमबद्ध संग्रह है जो संख्याओं, स्ट्रिंग्स, ऑब्जेक्ट्स और यहां तक ​​​​कि अन्य सरणी सहित विभिन्न प्रकार के डेटा को संग्रहीत कर सकता है।

let fruits = ["Apple", "Banana", "Cherry"];
let numbers = [1, 2, 3, 4, 5];
let mixed = [1, "Apple", true, {name: "John"}, [1, 2, 3]];

सारणियाँ बनाना

ऐरे शाब्दिक या ऐरे कंस्ट्रक्टर का उपयोग करके ऐरे बनाए जा सकते हैं।

let arr1 = [1, 2, 3];
let arr2 = new Array(1, 2, 3);
console.log(arr1); // Output: [1, 2, 3]
console.log(arr2); // Output: [1, 2, 3]

सरणी गुण

• length: किसी सरणी में तत्वों की संख्या लौटाता है।

let arr = [1, 2, 3, 4, 5];
console.log(arr.length); // Output: 5

सारणी विधियाँ

1. धक्का()

किसी सरणी के अंत में एक या अधिक तत्व जोड़ता है और नई लंबाई लौटाता है।

let arr = [1, 2, 3];
arr.push(4);
console.log(arr); // Output: [1, 2, 3, 4]

2. पॉप()

किसी सरणी से अंतिम तत्व को हटाता है और उस तत्व को लौटाता है।

let arr = [1, 2, 3];
let last = arr.pop();
console.log(arr); // Output: [1, 2, 3]
console.log(last); // Output: 3

3. शिफ्ट()

किसी सरणी से पहला तत्व हटाता है और वह तत्व लौटाता है।

let arr = [1, 2, 3];
let first = arr.shift();
console.log(arr); // Output: [2, 3]
console.log(first); // Output: 1

4. अनशिफ्ट()

किसी सरणी की शुरुआत में एक या अधिक तत्व जोड़ता है और नई लंबाई लौटाता है।

let arr = [2, 3];
arr.unshift(1);
console.log(arr); // Output: [1, 2, 3]

5. कॉनकैट()

दो या दो से अधिक सारणियों को मर्ज करता है और एक नई सारणी लौटाता है।

let arr1 = [1, 2];
let arr2 = [3, 4];
let merged = arr1.concat(arr2);
console.log(merged); // Output: [1, 2, 3, 4]

6. सम्मिलित हों()

किसी सरणी के सभी तत्वों को एक स्ट्रिंग में जोड़ता है।

let arr = [1, 2, 3];
let str = arr.join("-");
console.log(str); // Output: "1-2-3"

7. उलटा()

किसी सरणी में तत्वों के क्रम को उलट देता है।

let arr = [1, 2, 3];
arr.reverse();
console.log(arr); // Output: [3, 2, 1]

8. स्लाइस()

किसी सरणी के एक हिस्से की एक उथली प्रतिलिपि को एक नई सरणी ऑब्जेक्ट में लौटाता है।

let arr = [1, 2, 3, 4, 5];
let sliced = arr.slice(1, 3);
console.log(sliced); // Output: [2, 3]

9. ब्याह()

तत्वों को हटाकर, प्रतिस्थापित करके या जोड़कर किसी सरणी की सामग्री को बदलता है।

let arr = [1, 2, 3, 4, 5];
arr.splice(1, 2, "a", "b");
console.log(arr); // Output: [1, "a", "b", 4, 5]

10. क्रमबद्ध करें()

किसी सरणी के तत्वों को उनके स्थान पर क्रमबद्ध करता है और क्रमबद्ध सरणी को लौटाता है।

let arr = [3, 1, 4, 1, 5, 9];
arr.sort((a, b) => a - b);
console.log(arr); // Output: [1, 1, 3, 4, 5, 9]

11. फ़िल्टर()

सभी तत्वों के साथ एक नई सरणी बनाता है जो दिए गए फ़ंक्शन द्वारा कार्यान्वित परीक्षण पास करता है।

let arr = [1, 2, 3, 4, 5];
let filtered = arr.filter(x => x > 2);
console.log(filtered); // Output: [3, 4, 5]

12. मानचित्र()

कॉलिंग सरणी में प्रत्येक तत्व पर दिए गए फ़ंक्शन को कॉल करने के परिणामों के साथ एक नई सरणी बनाता है।

let arr = [1, 2, 3];
let mapped = arr.map(x => x * 2);
console.log(mapped); // Output: [2, 4, 6]

13. कम करें()

इसे एक मान तक कम करने के लिए एक संचायक और सरणी में प्रत्येक तत्व के विरुद्ध एक फ़ंक्शन लागू करता है।

let arr = [1, 2, 3, 4];
let sum = arr.reduce((acc, curr) => acc   curr, 0);
console.log(sum); // Output: 10

14. खोजें()

सरणी में पहले तत्व का मान लौटाता है जो दिए गए परीक्षण फ़ंक्शन को संतुष्ट करता है।

let arr = [1, 2, 3, 4, 5];
let found = arr.find(x => x > 3);
console.log(found); // Output: 4

15. खोज सूचकांक()

सरणी में पहले तत्व का सूचकांक लौटाता है जो दिए गए परीक्षण फ़ंक्शन को संतुष्ट करता है।

let arr = [1, 2, 3, 4, 5];
let index = arr.findIndex(x => x > 3);
console.log(index); // Output: 3

16. हर()

परीक्षण करता है कि सरणी के सभी तत्व दिए गए फ़ंक्शन द्वारा कार्यान्वित परीक्षण पास करते हैं या नहीं।

let arr = [1, 2, 3, 4, 5];
let allBelowTen = arr.every(x => x 




  
  
  17. कुछ()


परीक्षण करता है कि सरणी में कम से कम एक तत्व दिए गए फ़ंक्शन द्वारा कार्यान्वित परीक्षण पास करता है या नहीं।



let arr = [1, 2, 3, 4, 5];
let anyAboveThree = arr.some(x => x > 3);
console.log(anyAboveThree); // Output: true





  
  
  18. शामिल है()


यह निर्धारित करता है कि किसी सरणी में उसकी प्रविष्टियों के बीच एक निश्चित मान शामिल है या नहीं।



let arr = [1, 2, 3, 4, 5];
let hasThree = arr.includes(3);
console.log(hasThree); // Output: true





  
  
  19. इंडेक्सऑफ()


पहला सूचकांक लौटाता है जिस पर किसी दिए गए तत्व को सरणी में पाया जा सकता है, या -1 यदि यह मौजूद नहीं है।



let arr = [1, 2, 3, 4, 5];
let index = arr.indexOf(3);
console.log(index); // Output: 2





  
  
  20. लास्टइंडेक्सऑफ()


अंतिम सूचकांक लौटाता है जिस पर किसी दिए गए तत्व को सरणी में पाया जा सकता है, या -1 यदि यह मौजूद नहीं है।



let arr = [1, 2, 3, 4, 5, 3];
let index = arr.lastIndexOf(3);
console.log(index); // Output: 5





  
  
  21. फ्लैट()


सभी उप-सरणी तत्वों को निर्दिष्ट गहराई तक पुनरावर्ती रूप से संयोजित करके एक नई सारणी बनाता है।



let arr = [1, [2, [3, [4]]]];
let flattened = arr.flat(2);
console.log(flattened); // Output: [1, 2, 3, [4]]





  
  
  22. फ़्लैटमैप()


पहले मैपिंग फ़ंक्शन का उपयोग करके प्रत्येक तत्व को मैप करता है, फिर परिणाम को एक नई सरणी में समतल करता है।



let arr = [1, 2, 3];
let flatMapped = arr.flatMap(x => [x, x * 2]);
console.log(flatMapped); // Output: [1, 2, 2, 4, 3, 6]





  
  
  23. से()


एक सरणी-जैसी या पुनरावृत्त ऑब्जेक्ट से एक नया, उथला-कॉपी किया गया सरणी उदाहरण बनाता है।



let str = "Hello";
let arr = Array.from(str);
console.log(arr); // Output: ["H", "e", "l", "l", "o"]





  
  
  24. isArray()


यह निर्धारित करता है कि पारित मान एक ऐरे है या नहीं।



console.log(Array.isArray([1, 2, 3])); // Output: true
console.log(Array.isArray("Hello")); // Output: false





  
  
  25. का()


एक बनाता है

तर्कों की एक परिवर्तनीय संख्या के साथ नया ऐरे उदाहरण, तर्कों की संख्या या प्रकार की परवाह किए बिना।



let arr = Array.of(1, 2, 3);
console.log(arr); // Output: [1, 2, 3]





  
  
  व्यावहारिक उदाहरण



  
  
  उदाहरण 1: किसी सारणी से डुप्लिकेट हटाना




let arr = [1, 2, 3, 3, 4, 4, 5];
let unique = [...new Set(arr)];
console.log(unique); // Output: [1, 2, 3, 4, 5]





  
  
  उदाहरण 2: एक सरणी में सभी मानों का योग




let arr = [1, 2, 3, 4, 5];
let sum = arr.reduce((acc, curr) => acc   curr, 0);
console.log(sum); // Output: 15





  
  
  उदाहरण 3: एक गहरे घोंसले वाले सरणी को समतल करना




let arr = [1, [2, [3, [4, [5]]]]];
let flattened = arr.flat(Infinity);
console.log(flattened); // Output: [1, 2, 3, 4, 5]





  
  
  उदाहरण 4: किसी सारणी में अधिकतम मान ज्ञात करना




let arr = [1, 2, 3, 4, 5];
let max = Math.max(...arr);
console.log(max); // Output: 5





  
  
  उदाहरण 5: कुंजी-मूल्य युग्मों की एक श्रृंखला बनाना




let obj = { a: 1, b: 2, c: 3 };
let entries = Object.entries(obj);
console.log(entries); // Output: [["a", 1], ["b", 2], ["c", 3]]





  
  
  निष्कर्ष


ऐरे जावास्क्रिप्ट का एक अनिवार्य हिस्सा हैं, जो डेटा के संग्रह को प्रबंधित करने का एक शक्तिशाली तरीका प्रदान करते हैं। सरणी फ़ंक्शंस में महारत हासिल करके, आप जटिल डेटा हेरफेर आसानी से कर सकते हैं और अधिक कुशल और पठनीय कोड लिख सकते हैं। इस व्यापक मार्गदर्शिका में विस्तृत उदाहरणों और स्पष्टीकरणों के साथ जावास्क्रिप्ट में सबसे महत्वपूर्ण सरणी कार्यों को शामिल किया गया है। इन फ़ंक्शंस का उपयोग करने का अभ्यास करें और अपनी समझ को गहरा करने और अपने कोडिंग कौशल को बढ़ाने के लिए विभिन्न उपयोग मामलों के साथ प्रयोग करें।