2020 में काम करने वाले सरणियों के साथ काम करने के लिए 15 जावास्क्रिप्ट तरीके जिन्हें आपको 2020 में जानना होगा

यहाँ dev.to पर प्रकाशित एक लेख का अनुवाद है। द्वारा पोस्ट किया गया: इब्राहिमा Ndaw
मूल लेखक के ब्लॉग में प्रकाशित होता है।

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

इस लेख में, हम 15 तरीकों को कवर करेंगे जो आपको जावास्क्रिप्ट में सरणियों के साथ अधिक कुशलता से काम करने में मदद करेंगे।



कृपया ध्यान दें कि मूल रूप से हम उस फ़ंक्शन को सरल करेंगे जो एक पैरामीटर के रूप में पारित किया गया है।

// Instead of using this way myAwesomeArray.some(test => { if (test === "d") { return test } }) // We'll use the shorter one myAwesomeArray.some(test => test === "d") 

1. कुछ ()

यह विधि जांचती है कि सरणी का कोई तत्व पारित फ़ंक्शन में निर्दिष्ट स्थिति को संतुष्ट करता है या नहीं। यह true अगर कम से कम एक तत्व परीक्षण किए जा रहे फ़ंक्शन से मेल खाता है, और यदि नहीं तो false ।

 const myAwesomeArray = ["a", "b", "c", "d", "e"] myAwesomeArray.some(test => test === "d") //-------> Output : true 

2. कम करना ()

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

 const myAwesomeArray = [1, 2, 3, 4, 5] myAwesomeArray.reduce((total, value) => total * value) // 1 * 2 * 3 * 4 * 5 //-------> Output = 120 

3. हर ()

यह विधि जांचती है कि क्या सरणी के सभी तत्व पारित किए जा रहे फ़ंक्शन में निर्दिष्ट शर्त को पूरा करते हैं या नहीं। यह true अगर प्रत्येक तत्व परीक्षण किए जा रहे फ़ंक्शन से मेल खाता है, और यदि नहीं तो false ।

 const myAwesomeArray = ["a", "b", "c", "d", "e"] myAwesomeArray.every(test => test === "d") //-------> Output : false const myAwesomeArray2 = ["a", "a", "a", "a", "a"] myAwesomeArray2.every(test => test === "a") //-------> Output : true 

4. नक्शा ()

यह विधि एक फ़ंक्शन को पैरामीटर के रूप में लेती है और सरणी के प्रत्येक तत्व के लिए निर्दिष्ट फ़ंक्शन को कॉल करने के परिणामस्वरूप एक नया सरणी बनाती है। यह हमेशा समान संख्या में आइटम लौटाएगा।

 const myAwesomeArray = [5, 4, 3, 2, 1] myAwesomeArray.map(x => x * x) //-------> Output : 25 // 16 // 9 // 4 // 1 

5.फ्लैट ()

यह विधि एक तर्क के रूप में सरणियों का एक सरणी लेती है और नेस्टेड सरणियों को एक शीर्ष-स्तरीय सरणी में सुचारू करती है। कृपया ध्यान दें कि यह विधि केवल एक स्तर के लिए काम करती है।

 const myAwesomeArray = [[1, 2], [3, 4], 5] myAwesomeArray.flat() //-------> Output : [1, 2, 3, 4, 5] 

6. फ़िल्टर ()

यह विधि एक पैरामीटर के रूप में एक फ़ंक्शन लेती है और सरणी के सभी तत्वों से युक्त एक नया सरणी लौटाती है जिसके लिए फ़िल्टर फ़ंक्शन को एक तर्क के रूप में पारित किया गया था, और इसे true लौटाता true ।

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, { id: 4, name: "Mass" }, ] myAwesomeArray.filter(element => element.name === "Mass") //-------> Output : 0:{id: 3, name: "Mass"}, // 1:{id: 4, name: "Mass"} 

7. forEach ()

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

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, ] myAwesomeArray.forEach(element => console.log(element.name)) //-------> Output : john // Ali // Mass 

8. findIndex ()

यह विधि एक फ़ंक्शन को पैरामीटर के रूप में लेती है और फिर इसे ऐरे पर लागू करती है। यह पाया तत्व के सूचकांक को लौटाता है यदि तत्व एक तर्क के रूप में पारित चेकिंग फ़ंक्शन की स्थिति को संतुष्ट करता है। संतुष्ट नहीं होने पर –1 लौटा दिया जाता है।

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, ] myAwesomeArray.findIndex(element => element.id === 3) //-------> Output : 2 myAwesomeArray.findIndex(element => element.id === 7) //-------> Output : -1 

9. खोजें ()

यह विधि एक फ़ंक्शन को तर्क के रूप में लेती है और फिर इसे ऐरे पर लागू करती है। यह सरणी में पाए गए तत्व का मान लौटाता है यदि तत्व चेकिंग फ़ंक्शन की स्थिति को संतुष्ट करता है। अन्यथा, यह undefined मूल्य के साथ लौटता है।

 const myAwesomeArray = [ { id: 1, name: "john" }, { id: 2, name: "Ali" }, { id: 3, name: "Mass" }, ] myAwesomeArray.find(element => element.id === 3) //-------> Output : {id: 3, name: "Mass"} myAwesomeArray.find(element => element.id === 7) //-------> Output : undefined 

10. सॉर्ट ()

यह विधि एक पैरामीटर के रूप में एक फ़ंक्शन लेती है। यह एरे के तत्वों को सॉर्ट करता है और उन्हें लौटाता है।

 const myAwesomeArray = [5, 4, 3, 2, 1] // Sort from smallest to largest myAwesomeArray.sort((a, b) => a - b) //-------> Output : [1, 2, 3, 4, 5] // Sort from largest to smallest myAwesomeArray.sort((a, b) => b - a) //-------> Output : [5, 4, 3, 2, 1] 

11. समतल ()

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

 const myAwesomeArray = [1, 2, 3, 4, 5] const myAwesomeArray2 = [10, 20, 30, 40, 50] myAwesomeArray.concat(myAwesomeArray2) //-------> Output : [1, 2, 3, 4, 5, 10, 20, 30, 40, 50] 

12. भरें ()

यह विधि सरणी के सभी तत्वों को एक ही मान से भरती है, जिसमें शुरुआती इंडेक्स (डिफ़ॉल्ट 0) से लेकर एंडिंग इंडेक्स (डिफॉल्ट अरेंजमेंट)।

 const myAwesomeArray = [1, 2, 3, 4, 5] // The first argument (0) is the value // The second argument (1) is the starting index // The third argument (3) is the ending index myAwesomeArray.fill(0, 1, 3) //-------> Output : [1, 0, 0, 4, 5] 

13. शामिल ()

यह विधि true यदि सरणी में एक विशिष्ट तत्व होता है, और यदि नहीं तो false ।

 const myAwesomeArray = [1, 2, 3, 4, 5] myAwesomeArray.includes(3) //-------> Output : true myAwesomeArray.includes(8) //-------> Output : false 

14. उल्टा ()

यह विधि सरणी में तत्वों के क्रम को उलट देती है। पहला तत्व आखिरी हो जाता है, और आखिरी पहला हो जाता है।

 const myAwesomeArray = ["e", "d", "c", "b", "a"] myAwesomeArray.reverse() //-------> Output : ['a', 'b', 'c', 'd', 'e'] 

15. फ्लैटपाइप ()

यह विधि सरणी के प्रत्येक तत्व पर एक फ़ंक्शन लागू करती है, और फिर परिणाम को एक नए सरणी में सुचारू करती है। यह एक फ़ंक्शन में flat() विधि और map() विधि को जोड़ती है।

 const myAwesomeArray = [[1], [2], [3], [4], [5]] myAwesomeArray.flatMap(arr => arr * 10) //-------> Output : [10, 20, 30, 40, 50] // With .flat() and .map() myAwesomeArray.flat().map(arr => arr * 10) //-------> Output : [10, 20, 30, 40, 50]