जावास्क्रिप्ट - हटाएँ - जेएस सरणियाँ। किसी विशिष्ट जावास्क्रिप्ट सरणी तत्व को कैसे हटाएं? सरणी जावास्क्रिप्ट से तत्व निकालें

मैंने सरणियों के साथ काम करने की केवल कुछ विधियों का वर्णन किया है।

यहां हम ऐरे एलिमेंट्स को जोड़ने और हटाने के बारे में बात करेंगे। किसी सारणी को पलटने और क्रमबद्ध करने के साथ-साथ सारणियों को काटने, बदलने और संयोजित करने के बारे में।

आप सरणी में नए तत्व जोड़ने के लिए लंबाई संपत्ति का उपयोग कर सकते हैं:

Var myArray = ["Apple", "Microsoft", "Google", "Facebook"]; myArray = "याहू!"; कंसोल.लॉग(myArray); // ["ऐप्पल", "माइक्रोसॉफ्ट", "गूगल", "फेसबुक", "याहू!"]

यह काम करेगा क्योंकि... सरणी तत्वों को शून्य से शुरू करके क्रमांकित किया गया है, और लंबाई एक और है। लंबाई हमेशा सूचकांक + 1 के बराबर होती है, इसलिए सरणी के अंत में एक नया तत्व जोड़ना बहुत आसान है। अजीब बात है, आप किसी तत्व को उस स्थिति में जोड़ सकते हैं जो सरणी की लंबाई से कहीं अधिक बड़ा है:

वर मायअरे = ["जिमी हेंड्रिक्स", "एरिक क्लैप्टन", "जिमी पेज", "कीथ रिचर्ड्स"]; myArray = "लिंडसे बकिंघम"; कंसोल.लॉग(myArray); // ["जिमी हेंड्रिक्स", "एरिक क्लैप्टन", "जिमी पेज", "कीथ रिचर्ड्स", अपरिभाषित × 95, "लिंडसे बकिंघम"] कंसोल.लॉग(myArray.length); // 100

जैसा कि टिप्पणियों में दिखाया गया है, यह सरणी के अंत में 95 खाली स्लॉट और तत्व "लिंडसे बकिंघम" जोड़ देगा। इसके बाद हमें 100 की लंबाई मिलेगी। ऐरे में एक नया तत्व जोड़ने का दूसरा तरीका पुश() विधि का उपयोग करना है:

वर मायअरे = ["पॉल मेकार्टनी", "जॉन लेनन", "जॉर्ज हैरिसन"]; myArray.push('रिंगो स्टार', 'जॉर्ज मार्टिन'); कंसोल.लॉग(myArray); // ["पॉल मेकार्टनी", "जॉन लेनन", "जॉर्ज हैरिसन", "रिंगो स्टार", "जॉर्ज मार्टिन"]

पुश() विधि हमेशा नई सरणी लंबाई (हमारे मामले में 5) लौटाती है। आप ब्याह() का उपयोग करके एक तत्व जोड़ सकते हैं:

वर मायअरे = ["बलूत का फल", "बीच", "मोंगोंगो", "मैकाडामिया"]; myArray.splice(2, 0, "काजू"); // इंडेक्स 2 कंसोल.लॉग(myArray) में "काजू" जोड़ता है; // ["बलूत का फल", "बीच", "काजू", "मोंगोंगो", "मैकाडामिया"]

जब दूसरा तर्क 0 है, तो इसका मतलब है कि कोई भी तत्व हटाया नहीं जाएगा, और इसलिए किसी भी बाद के तर्क को पहले तर्क में निर्दिष्ट स्थान पर सरणी में जोड़ा जाएगा।

किसी तत्व को हटाना उसे जोड़ने से थोड़ा अधिक कठिन है। किसी सरणी के अंत से किसी तत्व को हटाने के लिए, आप पॉप() का उपयोग कर सकते हैं:

वर मायअरे = ["7-अप", "स्प्राइट", "जिंजर एले", "लेमोनेड"]; myArray.pop(); कंसोल.लॉग(myArray); // ["7-अप", "स्प्राइट", "जिंजर एले"]

पॉप() विधि हमेशा सरणी में अंतिम तत्व को हटा देती है और उसे वापस कर देती है।

आप ब्याह() विधि का भी उपयोग कर सकते हैं:

वर मायअरे = ["कसावा", "जायफल", "ल्यूपिन", "रूबर्ब"]; myArray.splice(2, 1); // इंडेक्स 2 कंसोल.लॉग (myArray) के साथ तत्व हटाएं; // ["कसावा", "जायफल", "रूबर्ब"]

स्प्लिस() विधि के विपरीत, जिसका उपयोग तत्वों को जोड़ने के लिए किया जाता है, यहां दूसरा तर्क 1 है, जो कहता है कि हम इंडेक्स 2 (या पंक्ति में तीसरे) वाले तत्व को हटाना चाहते हैं। इस मामले में, "ल्यूपिन" तत्व हटा दिया गया था।

आप डिलीट ऑपरेटर का उपयोग करके किसी ऐरे तत्व को हटा सकते हैं:

वर मायअरे = ["बाइट बैंडिट", "एलिज़ा", "जीफ़ो", "माइकलएंजेलो"]; कंसोल.लॉग(myArray.length); //4 myArray हटाएं; // एलिजा कंसोल.लॉग(myArray.length) हटाएं; //4 कंसोल.लॉग(myArray); // ["बाइट बैंडिट", अपरिभाषित × 1, "जीफो", "माइकलएंजेलो"]

पहला महत्वपूर्ण लेख: delete() किसी तत्व को हटाने के बाद सरणी की लंबाई नहीं बदलता है (भले ही वह सरणी में अंतिम तत्व हो)। दूसरा: delete() हटाए जाने वाले तत्व के मान को अपरिभाषित में बदल देता है, इसलिए जब myArray = अपरिभाषित कहा जाता है।

किसी सरणी से किसी तत्व को हटाने का एक अच्छा तरीका जॉन रेसिग के Array.remove का उपयोग करना है। नीचे उनके पृष्ठ से लिया गया एक उपयोग उदाहरण है:

// ऐरे रिमूव - जॉन रेसिग द्वारा (एमआईटी लाइसेंस प्राप्त) ऐरे.प्रोटोटाइप.रिमूव = फ़ंक्शन (से, तक) ( var बाकी = यह.स्लाइस ((से || से) + 1 || यह.लंबाई); यह.लंबाई =से< 0 ? this.length + from: from; return this.push.apply(this, rest); }; // Удаление 2 элемента из массива array.remove(1); // Удаление 2-ого элемента с конца массива array.remove(-2); // Удаление второго и третьего элемента array.remove(1,2); // Удаление последнего и предпоследнего элемента array.remove(-2,-1);

आप शायद विरल पटेल के समाधान, अंडरस्कोर.जेएस या jQuery के grep() में से एक फ़ंक्शन को देखना चाहेंगे।

इसके अतिरिक्त, जावास्क्रिप्ट में एक शिफ्ट() विधि है जो किसी सरणी में पहले तत्व को हटा देती है और उसका मान लौटा देती है। आइए कोड देखें:

वर मायअरे = ["मैट क्रेमर", "जेसन बीलर", "टॉम डिफाइल", "फिल वरोन"]; कंसोल.लॉग(myArray.length); // 4 संस्करण फर्स्टआइटम = myArray.shift(); कंसोल.लॉग(फर्स्टआइटम); // मैट क्रेमर कंसोल.लॉग(myArray.length); //3 कंसोल.लॉग(myArray); // ["जेसन बीलर", "टॉम डिफाइल", "फिल वरोन"]

शिफ्ट() विधि का उपयोग करके हमने तत्व को हटा दिया लेकिन उसके मूल्य को हमारे फर्स्टआइटम वेरिएबल में संग्रहीत किया। सरणी की लंबाई 4 से 3 में बदल गई।

यह विधि पुश() विधि के साथ संयोजन में उपयोगी हो सकती है। इनका एक साथ उपयोग करके हम किसी सरणी में तत्वों को कुशलतापूर्वक कतारबद्ध कर सकते हैं। हम शुरुआत से एक तत्व को हटाकर और अंत में एक नया जोड़कर सरणी की लंबाई बनाए रखते हैं।

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

वर मायअरे = ["एपिटो", "कैस्टनेट्स", "मारका"]; कंसोल.लॉग(myArray.length); // 3 myArray.unshift('चाइम बार', 'टैन-टैन'); कंसोल.लॉग(myArray.length); //5 कंसोल.लॉग(myArray); // ["चाइम बार", "टैन-टैन", "एपिटो", "कैस्टनेट्स", "माराका"]

पॉप() विधि के साथ अनशिफ्ट() विधि का उपयोग करके, आप कतारें बना सकते हैं विपरीत पक्ष, शुरुआत में तत्वों को जोड़ना और सरणी के अंत से हटाना।

किसी सरणी में तत्वों को उलटने के लिए, हम रिवर्स() का उपयोग कर सकते हैं:

वर मायअरे = ["उलटी गिनती", "अंतिम", "द"]; कंसोल.लॉग(myArray); // ["उलटी गिनती", "अंतिम", "द"] myArray = myArray.revers(); कंसोल.लॉग(myArray); // ["उलटी गिनती"]

सॉर्ट() विधि का उपयोग करके सरणी तत्वों को वर्णानुक्रम में क्रमबद्ध करना संभव है:

वर मायअरे = ["जाइलोफोन्स", "जेब्रा", "जग्गर्नॉट्स", "एवोकैडो"]; कंसोल.लॉग(myArray); // ["जाइलोफोन्स", "जेब्रा", "जुगर्नॉट्स", "एवोकैडो"] myArray = myArray.sort(); कंसोल.लॉग(myArray); // ["एवोकैडो", "जग्गर्नॉट्स", "जाइलोफोन्स", "जेब्रा"]

लेकिन यह संख्याओं के साथ काम नहीं करेगा.

वर मायअरे = ; कंसोल.लॉग(myArray); // myArray = myArray.sort(); कंसोल.लॉग(myArray); //

यदि आपको संख्याओं को क्रमबद्ध करने की आवश्यकता है, तो आप निम्नलिखित कोड का उपयोग कर सकते हैं:

फ़ंक्शन CompareNumbers(a, b) ( return a - b; ) var myArray = ; कंसोल.लॉग(myArray); // myArray = myArray.sort(compareNumbers); कंसोल.लॉग(myArray); //

जैसा कि ऊपर दिखाया गया है, सॉर्ट () में डाले गए एक साधारण फ़ंक्शन के साथ, संख्याओं वाली सरणी सही ढंग से सॉर्ट की जाएगी।

हम 2 या अधिक सरणियों को जोड़ सकते हैं और 1 सरणी प्राप्त कर सकते हैं जिसमें सम्मिलित सरणियों के तत्व शामिल हैं। ऐसा करने के लिए हम concat() विधि का उपयोग करते हैं:

वर मायअरे = ["जे फर्ग्यूसन", "एंड्रयू स्कॉट"]; var myArray2 = ["क्रिस मर्फी", "पैट्रिक पेंटलैंड"]; var myNewArray = myArray.concat(myArray2); कंसोल.लॉग(myNewArray); // ["जे फर्ग्यूसन", "एंड्रयू स्कॉट", "क्रिस मर्फी", "पैट्रिक पेंटलैंड"]

वर मायअरे = ["जे फर्ग्यूसन", "एंड्रयू स्कॉट"]; var myNewArray = myArray.concat('क्रिस मर्फी', 'पैट्रिक पेंटलैंड'); कंसोल.लॉग(myNewArray); // ["जे फर्ग्यूसन", "एंड्रयू स्कॉट", "क्रिस मर्फी", "पैट्रिक पेंटलैंड"]

हम स्लाइस() फ़ंक्शन का उपयोग करके मौजूदा सरणी से 1 या अधिक तत्वों वाली एक नई सरणी बना सकते हैं:

वर मायअरे = ["वोकल्स", "बास", "गिटार", "ड्रम", "सेब", "संतरे"]; var myNewArray = myArray.slice(4); कंसोल.लॉग(myNewArray); // ["सेब", "संतरे"]

स्लाइस() विधि में 1 या 2 तर्क लगते हैं। यदि 1 तर्क (सूचकांक) पारित किया जाता है, तो इस सूचकांक से शुरू करके पुराने के सभी तत्वों से एक नया सरणी बनाया जाता है। यदि 2 तर्क पारित किए जाते हैं, तो पहले तर्क से शुरू होने वाले तत्वों से दूसरे पैरामीटर में पारित सूचकांक वाले तत्व तक एक नई सरणी बनाई जाती है, जिसमें अंतिम शामिल नहीं होता है। इसे स्पष्ट करने के लिए, आइए नीचे दिए गए कोड को देखें:

वर मायअरे = ["वोकल्स", "बास", "गिटार", "ड्रम", "सेब", "संतरे"]; var myNewArray = myArray.slice(0, 4); कंसोल.लॉग(myNewArray); // ["वोकल्स", "बास", "गिटार", "ड्रम"]

हम किसी सरणी से तत्वों को हटाने के लिए splice() का उपयोग करते हैं, लेकिन हम सरणी में किसी तत्व को नए तत्वों से भी बदल सकते हैं:

वर मायअरे = ["नदियाँ कुओमो", "पैट्रिक विल्सन", "ब्रायन बेल", "मैट शार्प"]; myArray.splice(3, 1, "स्कॉट श्राइनर"); // 1 तत्व को इंडेक्स 3 कंसोल.लॉग (myArray) से बदलें; // ["नदियाँ कुओमो", "पैट्रिक विल्सन", "ब्रायन बेल", "स्कॉट श्राइनर"]

ब्याह () विधि हमेशा हटाए गए तत्वों वाली एक सरणी लौटाती है। पंक्ति 2 1 तत्व "ब्रायन बेल" लौटाएगा।

इन लेखों में जावास्क्रिप्ट में सरणियों के साथ काम करने के तरीकों का वर्णन किया गया है। कुछ अतिरिक्त आइटम हैं जिन्हें आप एमडीएन पर देख सकते हैं जिन्हें मैंने इस पोस्ट में शामिल नहीं किया है। वे केवल IE9+ में काम करते हैं, इसलिए वे उपयोगी नहीं हो सकते हैं।

कुछ जोड़ना है? या क्या आप कोई दिलचस्प लाइब्रेरी जानते हैं जो सरणियों को प्रबंधित करने में मदद करेगी? कृपया टिप्पणी करें!

जावास्क्रिप्ट में किसी ऐरे तत्व को हटाने की कई विधियाँ हैं। इनमें पॉप और शिफ्ट विधियां शामिल हैं। पॉप विधि पहले तत्व को हटा देती है इस सरणी का. शिफ्ट विधि दिए गए एरे से अंतिम तत्व को हटा देती है।

यदि आप दिए गए सरणी से सभी तत्वों को हटाना चाहते हैं तो आप सरणी की लंबाई 0 पर सेट कर सकते हैं। लेकिन क्या, क्या आपको किसी विशिष्ट तत्व को हटाने की आवश्यकता है?

उदाहरण के लिए:

Array_name.splice(सूचकांक);

Array_name.हटाएं

आप ब्याह विधि का उपयोग कर सकते हैं. यह हटाए गए तत्वों की एक नई श्रृंखला लौटाता है। और मूल सरणी में शेष तत्व शामिल हैं।

जावास्क्रिप्ट स्प्लिस विधि का उपयोग कैसे करें और विशिष्ट तत्वों को हटाने के अन्य तरीकों के बारे में जानने के लिए नीचे दिए गए डेमो को देखें।

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

संख्यात्मक सरणी तत्व उपयोग से पहले और बाद में प्रदर्शित किए जाते हैं जावास्क्रिप्ट विधिइस तरह बँटवारा:

ब्याह विधि के साथ जावास्क्रिप्ट कोड:

"; के लिए (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; Arrretrun = Arr_Numbers.splice(2,1); var the_arr_before_after = "स्प्लिस विधि के बाद तत्वों को व्यवस्थित करें:
"; के लिए (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "

आप देखेंगे कि मैंने एक सरणी तत्व को हटाने के लिए जावास्क्रिप्ट के लिए दो मापदंडों का उपयोग किया है। पहला हटाए जाने वाले तत्व का सूचकांक निर्दिष्ट करता है। दूसरा यह है कि निर्दिष्ट कुंजी के बाद कितने तत्वों को हटाने की आवश्यकता है।

निम्नलिखित डेमो एक ऐसा मामला दिखाता है जहां हम दूसरे पैरामीटर का उपयोग करते हैं।

समान कोड का उपयोग करना, लेकिन स्प्लिस विधि में दूसरे पैरामीटर के बिना:

Arr_Numbers.splice(2);

कोड और परिणाम:

ऑनलाइन डेमो और कोड देखें

जैसा कि आप देख सकते हैं, निर्दिष्ट सूचकांक संख्या से पहले के सभी तत्व भी हटा दिए गए हैं। इसके अलावा, ब्याह विधि हटाए गए तत्वों की एक सरणी लौटाती है।

जावास्क्रिप्ट कोड:

var Arr_Numbers = ; वर मैं; var the_arr_before_after = "मूल सरणी:
"; के लिए (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; Arrretrun = Arr_Numbers.splice(2); var the_arr_before_after = "स्प्लिस विधि के बाद तत्वों को व्यवस्थित करें:
"; के लिए (i=0; i< Arr_Numbers.length; i++){ the_arr_before_after += Arr_Numbers[i] + "
"; ) document.getElementById("p2").innerHTML = the_arr_before_after; // लौटाए गए सरणी में हटाए गए सरणी तत्व var the_arr_before_after = "हटाए गए सरणी तत्व:
"; के लिए (i=0; i< Arrretrun.length; i++){ the_arr_before_after += Arrretrun[i] + "
"; ) document.getElementById("p3").innerHTML = the_arr_before_after;

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

आइए एक डेमो देखें जो डिलीट फ़ंक्शन का उपयोग करता है:

ऑनलाइन डेमो और कोड देखें

जावास्क्रिप्ट कोड:

var Arr_Strings = ["द","जावास्क्रिप्ट","ऐरे","टोटोरियल"]; वर मैं; var the_arr_before_after = "मूल स्ट्रिंग सरणी तत्व:

"; के लिए (i=0; i< Arr_Strings.length; i++){ the_arr_before_after += Arr_Strings[i] + "
"; ) document.getElementById("p1").innerHTML = the_arr_before_after; //डिलीट फ़ंक्शन का उपयोग करके Arr_Strings हटाएं; var the_arr_before_after = "स्प्लिस विधि के बाद तत्वों को व्यवस्थित करें:

"; के लिए (i=0; i< Arr_Strings.length; i++){ the_arr_before_after += Arr_Strings[i] + "
"; ) document.getElementById("p2").innerHTML = the_arr_before_after;

आप देख सकते हैं कि डिलीट फ़ंक्शन का उपयोग करके हटाए जाने के बाद तीसरा तत्व अपरिभाषित दिखता है।

क्या जावास्क्रिप्ट सरणी से किसी तत्व को हटाने का कोई तरीका है?

एक सरणी दी गई:

वार एरी = ["तीन", "सात", "ग्यारह"];

मैं कुछ ऐसा करना चाहूँगा:

रिमूवआइटम('सात', आर्य);

मैंने ब्याह() पर ध्यान दिया लेकिन वह केवल स्थिति संख्या को हटाता है, जबकि मुझे तत्व को उसके मूल्य से हटाने के लिए कुछ चाहिए।

//संपादित, सलाह के लिए मार्कोसीआई को धन्यवाद

इसे अजमाएं:

फ़ंक्शन चाहता हैहटाएं(आइटम, एआर)( के लिए (var i=0;i !(comment.Id === commentId));

यहां एक संस्करण है जो jQuery के inArray फ़ंक्शन का उपयोग करता है:

वार इंडेक्स = $.inArray(आइटम, ऐरे); यदि (सूचकांक != -1) ( array.splice(सूचकांक, 1); )

आप Lodash _.remove फ़ंक्शन का उपयोग करके इसे प्राप्त कर सकते हैं।

वर सरणी = ["तीन", "सात", "ग्यारह"]; var ईवेंस = _.निकालें(सरणी, फ़ंक्शन(ई) (वापसी ई !== "सात"; )); कंसोल.लॉग(ईवेन्स);

स्थिरांक _ = आवश्यकता("lodash"); _.बिना(, 2); // ->

सचमुच, मुझे समझ नहीं आता कि इसका समाधान क्यों नहीं किया जा सकता

Arr = arr.filter(मान => मान !== "सात");

या शायद आप वेनिला जेएस का उपयोग करना चाहते हैं

Arr = arr.filter(फ़ंक्शन(मूल्य) (वापसी मूल्य !== "सात" ));

एक अन्य प्रकार:

यदि (!Array.prototype.removeArr) ( Array.prototype.removeArr = function(arr) ( if(!Array.isArray(arr)) arr=;//आइए उन लोगों के साथ अच्छा व्यवहार करें जो गैर-सरणी मान डालते हैं यहाँ.. वह मैं हो सकता हूँ! ) )

यह फिर से लूप के अंदर IndexOf() है, लेकिन इस धारणा के तहत कि हटाया जाने वाला सरणी साफ़ किए जाने वाले सरणी के सापेक्ष छोटा है; प्रत्येक विलोपन while लूप को छोटा करता है।

यह आपको निम्नलिखित कार्य करने की अनुमति देगा:

वार एरी = ["तीन", "सात", "ग्यारह"]; var aryWithoutSeven = ary.filter(function(value) ( ​​​​वापसी मान != "सात" )); कंसोल.लॉग(aryWithoutSeven); // रिटर्न ["तीन", "ग्यारह"]

इसे इस सूत्र में अन्यत्र भी नोट किया गया था: https://.com/a/20827100/293492

डिलीट विकल्प का उपयोग न करें - यह सरणी में एक छेद बनाता है, क्योंकि यह हटाए गए तत्व के बाद तत्वों को पुन: अनुक्रमित नहीं करता है।

> Array.prototype.remove=function(v)(...इसे हटाएं...); > var myarray=["3","24","55","2"]; अपरिभाषित > myarray.remove('55'); अपरिभाषित > मायरे [ "3", "24", "2" ]

एक लाइनर यह करेगा,

वार एरी = ["तीन", "सात", "ग्यारह"]; // सरणी से आइटम "सात" हटाएं var फ़िल्टर किया हुआ आर्य = ary.filter (फ़ंक्शन (ई) (वापसी ई! == "सात")) //=> ["तीन", "ग्यारह"] // ईसीएमए 6 में (तीर फ़ंक्शन सिंटैक्स): var फ़िल्टर्डएरी = ary.filter(e => e !== "सात")

यह JS में फ़िल्टर फ़ंक्शन का उपयोग करता है। यह IE9 और इसके बाद के संस्करण में समर्थित है।

फ़िल्टर() सरणी में प्रत्येक तत्व के लिए दिए गए कॉलबैक फ़ंक्शन को एक बार कॉल करता है और सभी मानों की एक नई सरणी बनाता है जिसके लिए कॉलबैक एक मान लौटाता है जो सत्य का मूल्यांकन करता है। कॉलबैक केवल उन सरणी सूचकांकों के लिए कॉल किया जाता है जिनमें मान निर्दिष्ट हैं; इसे उन अनुक्रमणिकाओं के लिए नहीं कहा जाता है जिन्हें हटा दिया गया है या जिन्हें कभी भी मान निर्दिष्ट नहीं किया गया है। कॉलबैक परीक्षण में विफल रहने वाले ऐरे तत्वों को आसानी से छोड़ दिया जाता है और नए ऐरे में शामिल नहीं किया जाता है।

तो मूल रूप से, यह अन्य सभी for (var key in ary) ( ... ) समाधानों के समान है, सिवाय इसके कि for in IE6 के रूप में समर्थित है।

मूल रूप से, फ़िल्टर एक सुविधाजनक विधि है जो फ़ॉर इन कंस्ट्रक्टर (AFAIK) के विपरीत अधिक अच्छी लगती है (और श्रृंखलाबद्ध है)।

यह जाँचें:

For(var i in array)( if(array[i]==seven")( array.splice(i,1); breaking; ) )

और समारोह में:

फ़ंक्शन रिमूवआइटम(सरणी, आइटम)( for(var i in array)( if(array[i]==item)( array.splice(i,1); breaking; ) ) ) deleteItem(array, "seven");

किसी सरणी से सभी मेल खाने वाले तत्वों को हटाना (सिर्फ पहला नहीं, जैसा कि यहां सबसे सामान्य उत्तर प्रतीत होता है):

जबकि ($.inArray(आइटम, ऐरे) > -1) ( array.splice($.inArray(आइटम, ऐरे), 1); )

मैंने भारी सामान उठाने के लिए jQuery का उपयोग किया, लेकिन यदि आप मूल रूप से जाना चाहते हैं तो आपको यह विचार मिल जाएगा।

तरकीब यह है कि सरणी को शुरू से शुरू तक देखा जाए ताकि तत्वों को हटाते समय आप सूचकांकों में गड़बड़ी न करें।

Var deleteMe = function(arr, me)( var i = arr.length; while(i--) if(arr[i] === me) arr.splice(i,1); ) var arr = ["नारंगी ","लाल","काला", "नारंगी", "सफ़ेद" , "नारंगी" ]; deleteMe(arr, "नारंगी");

एआरआर अब ["लाल", "काला", "सफ़ेद"] है

फ़ंक्शन CleanArrayOfSpecificTerms(array,unwantedTermsArray) ( $.each(unwantedTermsArray, function(index, value) ( ​​​​var Index = array.indexOf(value); if (index > -1) ( array.splice(index, 1); ) ) ); वापसी सारणी )

उपयोग करने के लिए, इन चरणों का पालन करें:

Var notInclude = ["नहीं", "नहीं", "पहला", "अंतिम", "पूर्व", "अगला", "कुत्ते", "बिल्लियाँ"]; var स्प्लिटटर्म्स = ["कॉल", "लॉग", "कुत्ते", "बिल्लियाँ", "विषय", "परिवर्तन", "मूल्य निर्धारण"]; क्लीनअरेऑफस्पेसिफिकटर्म्स(विभाजितशर्तें,शामिल नहीं)

मैंने उपरोक्त jbaron से फ़ंक्शन विधि का उपयोग करने का प्रयास किया, लेकिन पाया कि मुझे बाद में उपयोग के लिए मूल सरणी को अपरिवर्तित रखने और इस तरह एक नई सरणी बनाने की आवश्यकता है:

वार न्यूअरे = रेफरेंसअरे;

फ़ंक्शन newArrRemoveItem(सरणी, आइटम, newArray)(for(var i = 0; i< array.length; i++) { if(array[i]!=item){ newArray.push(array[i]); } } }

फिर मैं इसे इस तरह उपयोग करता हूं:

वर वेसलआईडी = रिकॉर्ड.गेट('वेसलआईडी'); var अन्य वेसल्स = नया ऐरे(); newArrRemoveItem(vessalArr,vesselID,otherVessels);

अब वेसलएआरआर बरकरार है और हर बार जब मैं उपरोक्त कोड निष्पादित करता हूं, तो अन्य वेसल्स सरणी में अंतिम सीएआईडी तत्व को छोड़कर सब कुछ शामिल होता है।

IndexOf एक विकल्प है, लेकिन इसका कार्यान्वयन मूल रूप से एक मान के लिए संपूर्ण सरणी की खोज करता है, इसलिए सरणी के आकार के साथ निष्पादन समय बढ़ता है। (तो यह हर ब्राउज़र में है, मुझे लगता है, मैंने केवल फ़ायरफ़ॉक्स की जाँच की है)।

मेरे पास परीक्षण करने के लिए IE6 नहीं है, लेकिन मैं इसे एक सुरक्षित शर्त कहूंगा कि आप लगभग किसी भी क्लाइंट मशीन पर प्रति सेकंड कम से कम दस लाख सरणी तत्वों का परीक्षण कर सकते हैं। यदि [सरणी आकार] * [ खोज क्वेरीप्रति सेकंड] एक मिलियन से अधिक तक बढ़ सकता है, आपको एक अलग कार्यान्वयन पर विचार करना चाहिए।

मूल रूप से आप अपने ऐरे पर एक इंडेक्स बनाने के लिए किसी ऑब्जेक्ट का उपयोग कर सकते हैं, जैसे:

वार इंडेक्स=('तीन':0, 'सात':1, 'ग्यारह':2);

कोई भी सामान्य जावास्क्रिप्ट ढांचा ऐसी वस्तुओं के लिए एक खोज सूचकांक बनाएगा ताकि आप किसी कुंजी को तुरंत मूल्य में अनुवाद कर सकें, भले ही वस्तु में कितने गुण हों।

यह सिर्फ एक बुनियादी विधि है, अपनी आवश्यकताओं के आधार पर आप एक ही डेटा को विभिन्न गुणों के लिए तुरंत खोजने योग्य बनाने के लिए कई ऑब्जेक्ट और/या सरणियों को जोड़ सकते हैं। यदि आप अपनी विशिष्ट आवश्यकताएं निर्दिष्ट करते हैं, तो मैं अधिक विशिष्ट डेटा संरचना का सुझाव दे सकता हूं।

//यह फ़ंक्शन आपको सरणी से सम सरणी को हटाने की अनुमति देता है var deleteFromArr = function(arr, elem) ( var i, len = arr.length, new_arr = , sort_fn = function (a, b) ( return a - b; ); (i = 0; i के लिए)< len; i += 1) { if (typeof elem === "object" && typeof arr[i] === "object") { if (arr[i].toString() === elem.toString()) { continue; } else { if (arr[i].sort(sort_fn).toString() === elem.sort(sort_fn).toString()) { continue; } } } if (arr[i] !== elem) { new_arr.push(arr[i]); } } return new_arr; }

उपयोग उदाहरण

वर एआर = , "एबीसी", 1, "1", 1]; हटाएँFromArr(arr, 1); //["2", , "एबीसी", "1"] वर एआरआर = [ , 2, "ए", , ]; हटाएंFromArr(arr, ); //]

चलो arr = ; कंसोल.लॉग(arr); //परिणाम लेट इंडेक्स = arr.indexOf(30); यदि (सूचकांक> -1) (arr.splice(सूचकांक, 1); ) कंसोल.लॉग(arr); //परिणाम

वार इंडेक्स = array.indexOf("आइटम"); यदि(सूचकांक!=-1)( array.splice(सूचकांक, 1); )

जावास्क्रिप्ट डिलीट ऑपरेटर किसी ऑब्जेक्ट से एक संपत्ति को हटा देता है; यदि उसी संपत्ति का कोई और संदर्भ नहीं रखा जाता है, तो यह अंततः स्वचालित रूप से जारी हो जाती है।

इस इंटरैक्टिव उदाहरण का स्रोत GitHub रिपॉजिटरी में संग्रहीत है। यदि आप इंटरैक्टिव उदाहरण प्रोजेक्ट में योगदान देना चाहते हैं, तो कृपया https://github.com/mdn/interactive-examples को क्लोन करें और हमें एक पुल अनुरोध भेजें।

var के साथ परिभाषित किसी भी वेरिएबल को गैर-कॉन्फ़िगर करने योग्य के रूप में चिह्नित किया गया है। निम्नलिखित उदाहरण में, वेतन गैर-कॉन्फ़िगर करने योग्य है और इसे हटाया नहीं जा सकता। गैर-सख्त मोड में, डिलीट ऑपरेशन गलत वापस आएगा।

फ़ंक्शन कर्मचारी() (वेतन हटाएं; var वेतन; ) कर्मचारी();

आइए देखें कि समान कोड सख्त मोड में कैसे व्यवहार करता है, false लौटाने के बजाय, कथन एक SyntaxError उठाता है।

"सख्त प्रयोग करें"; फ़ंक्शन कर्मचारी() (वेतन हटाएं; // सिंटैक्स त्रुटि संस्करण वेतन;) // इसी तरह, किसी फ़ंक्शन तक कोई भी सीधी पहुंच // डिलीट के साथ एक सिंटैक्स त्रुटि फ़ंक्शन डेमोफंक्शन() (//कुछ कोड) डिलीट डेमोफंक्शन बढ़ाएगा; // वक्य रचना त्रुटि

निम्नलिखित उदाहरण में, हम किसी ऑब्जेक्ट की अपनी संपत्ति हटाते हैं जबकि प्रोटोटाइप श्रृंखला पर समान नाम वाली संपत्ति उपलब्ध है:

फ़ंक्शन फू() (यह.बार = 10; ) फू.प्रोटोटाइप.बार = 42; var foo = new Foo(); //foo.bar //स्वयं की संपत्ति से संबद्ध है। कंसोल.लॉग(foo.bar); // 10 // // foo ऑब्जेक्ट के भीतर अपनी संपत्ति हटाएं। foo.bar हटाएं; // सत्य लौटाता है // foo.bar अभी भी // प्रोटोटाइप श्रृंखला में उपलब्ध है। कंसोल.लॉग(foo.bar); // 42 // प्रोटोटाइप पर संपत्ति हटाएं। Foo.prototype.bar हटाएं; // सत्य लौटाता है // "बार" संपत्ति अब // फू से विरासत में नहीं ली जा सकती क्योंकि इसे // हटा दिया गया है। कंसोल.लॉग(foo.bar); // अपरिभाषित

जब आप किसी सरणी तत्व को हटाते हैं, तो सरणी की लंबाई प्रभावित नहीं होती है। यदि आप सरणी के अंतिम तत्व को हटा देते हैं तो भी यह लागू रहता है।

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

वार पेड़ = ["रेडवुड", "बे", "देवदार", "ओक", "मेपल"]; पेड़ हटाओ; यदि (पेड़ों में 3) (//यह निष्पादित नहीं है)

यदि आप चाहते हैं कि कोई सरणी तत्व मौजूद रहे लेकिन उसका मान अपरिभाषित हो, तो डिलीट ऑपरेटर के बजाय अपरिभाषित मान का उपयोग करें। निम्नलिखित उदाहरण में, पेड़ों को अपरिभाषित मान दिया गया है, लेकिन सरणी तत्व अभी भी मौजूद है:

वार पेड़ = ["रेडवुड", "बे", "देवदार", "ओक", "मेपल"]; पेड़ = अपरिभाषित; यदि (पेड़ों में 3) (//यह निष्पादित है)

यदि इसके बजाय, आप सरणी की सामग्री को बदलकर किसी सरणी तत्व को हटाना चाहते हैं, तो स्प्लिस विधि का उपयोग करें। निम्नलिखित उदाहरण में, स्प्लिस का उपयोग करके पेड़ों को सरणी से पूरी तरह से हटा दिया जाता है:

वार पेड़ = ["रेडवुड", "बे", "देवदार", "ओक", "मेपल"]; पेड़.स्प्लिस(3,1); कंसोल.लॉग(पेड़); // ["रेडवुड", "बे", "देवदार", "मेपल"]

इस पृष्ठ पर संगतता तालिका संरचित डेटा से तैयार की गई है। यदि आप डेटा में योगदान देना चाहते हैं, तो कृपया https://github.com/mdn/browser-compat-data देखें और हमें एक पुल अनुरोध भेजें।

GitHub पर संगतता डेटा अपडेट करें

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

मेरे पास पूर्णांकों की एक सरणी है और मैं इसमें तत्व जोड़ने के लिए .push() विधि का उपयोग कर रहा हूं।

क्या किसी सरणी से किसी विशिष्ट तत्व को हटाने का कोई आसान तरीका है? array.remove(int); जैसी किसी चीज़ के समतुल्य; ,

मुझे उपयोग करना चाहिए आधारजावास्क्रिप्ट - कोई नहींफ़्रेम की अनुमति नहीं है.

रिमूवबायइंडेक्स(,1) //=>

• इसे सरल, सहज और स्पष्ट बनाएं (https://en.wikipedia.org/wiki/Occam%27s_razor)
• इसे अपरिवर्तनीय बनाएं (मूल सरणी अपरिवर्तित रहेगी)
• इसे मानक JS फ़ंक्शंस के साथ करें, यदि आपका ब्राउज़र उनका समर्थन नहीं करता है - पॉलीफ़िल का उपयोग करें

इस कोड उदाहरण में, मैं किसी सरणी से अनावश्यक तत्वों को हटाने के लिए "array.filter(...)" फ़ंक्शन का उपयोग कर रहा हूं, यह फ़ंक्शन मूल सरणी को नहीं बदलता है और एक नया बनाता है यदि आपका ब्राउज़र इस फ़ंक्शन का समर्थन नहीं करता है (उदाहरण के लिए, संस्करण 9 से पहले IE या संस्करण 1.5 से पहले फ़ायरफ़ॉक्स), मोज़िला से पॉलीफ़िल फ़िल्टर का उपयोग करने पर विचार करें।

महत्वपूर्ण ES2015 "() => ()" एरो फ़ंक्शन सिंटैक्स IE में बिल्कुल भी समर्थित नहीं है, संस्करण 45 से पहले क्रोम, संस्करण 22 से पहले फ़ायरफ़ॉक्स, संस्करण 10 से पहले सफारी। पुराने ब्राउज़र में ES2015 सिंटैक्स का उपयोग करने के लिए आप बेबेलजेएस का उपयोग कर सकते हैं

इस पद्धति का एक अतिरिक्त लाभ यह है कि आप कई तत्वों को हटा सकते हैं

चलो forDeletion = लेट arr = arr = arr.filter(item => !forDeletion.includes(item)) // !!! array.includes(...) समर्थन के बारे में नीचे पढ़ें!!! कंसोल.लॉग(arr) // [ 1, 4 ]

महत्वपूर्ण "array.includes(...)" IE में बिल्कुल भी समर्थित नहीं है, Chrome संस्करण 47 से पहले, फ़ायरफ़ॉक्स संस्करण 43 से पहले, Safari संस्करण 9 से पहले और Edge संस्करण 14 से पहले, इसलिए

किसी सरणी से किसी तत्व को हटाने के कुछ तरीके यहां दिए गए हैं जावास्क्रिप्ट का उपयोग करना.

वर्णित सभी विधियाँ मूल सरणी को नहीं बदलती हैं और इसके बजाय एक नई सरणी बनाती हैं।

मान लीजिए कि आपके पास एक सरणी है और आप स्थिति i पर तत्व को हटाना चाहते हैं।

एक तरीका है स्लाइस() का उपयोग करना:

स्थिरांक आइटम = ["ए", "बी", "सी", "डी", "ई", "एफ"] स्थिरांक i = 3 स्थिरांक फ़िल्टर किए गए आइटम = आइटम.स्लाइस(0, आई-1).कॉनकैट(आइटम। स्लाइस(i, आइटम्स.लंबाई)) कंसोल.लॉग(फ़िल्टर्डआइटम्स)

स्लाइस() प्राप्त सूचकांकों के साथ एक नई सरणी बनाता है। हम बस एक नया ऐरे बनाते हैं - शुरुआत से लेकर उस इंडेक्स तक जिसे हम हटाना चाहते हैं, और ऐरे के अंत तक हटाए गए ऐरे के बाद पहले स्थान से एक और ऐरे को जोड़ते हैं।

इस मामले में, फ़िल्टर() का उपयोग करना एक अच्छा विकल्प है जो अधिक प्रदान करता है कथात्मकएक दृष्टिकोण:

स्थिरांक आइटम = ["ए", "बी", "सी", "डी", "ई", "एफ"] स्थिरांक valueToRemove = "सी" स्थिरांक फ़िल्टर किए गए आइटम = आइटम.फ़िल्टर (आइटम => आइटम! == valueToRemove) कंसोल.लॉग (फ़िल्टर किए गए आइटम)

यह ES6 एरो फ़ंक्शंस का उपयोग करता है। आप पुराने ब्राउज़र का समर्थन करने के लिए पारंपरिक फ़ंक्शन का उपयोग कर सकते हैं:

स्थिरांक आइटम = ["ए", "बी", "सी", "डी", "ई", "एफ"] स्थिरांक valueToRemove = "सी" स्थिरांक फ़िल्टर किए गए आइटम = आइटम.फ़िल्टर (फ़ंक्शन (आइटम) (वापसी आइटम! = = valueToRemove )) कंसोल.लॉग (फ़िल्टर किए गए आइटम)

या आप बैबेल का उपयोग कर सकते हैं और पुराने ब्राउज़रों के लिए इसे अधिक पठनीय बनाने के लिए ES6 कोड को वापस ES5 में परिवर्तित कर सकते हैं, लेकिन अपने कोड में आधुनिक जावास्क्रिप्ट लिखें।

यदि आप एक तत्व के बजाय कई तत्वों को हटाना चाहें तो क्या होगा?

आइए सबसे सरल समाधान खोजें।

आप बस एक फ़ंक्शन बना सकते हैं और तत्वों को क्रमिक रूप से हटा सकते हैं:

कॉन्स्ट आइटम = ["ए", "बी", "सी", "डी", "ई", "एफ"] कॉन्स्ट रिमूवआइटम = (आइटम, आई) => आइटम.स्लाइस(0, आई-1).कॉनकैट (आइटम.स्लाइस(आई, आइटम्स.लेंथ)) फ़िल्टर किए गए आइटम = हटाएं आइटम (आइटम, 3) फ़िल्टर किए गए आइटम = हटाएं आइटम (फ़िल्टर किए गए आइटम, 5) //["ए", "बी", "सी", "डी"] कंसोल। लॉग (फ़िल्टर किए गए आइटम)

आप कॉलबैक फ़ंक्शन के अंदर शामिल किए जाने की तलाश कर सकते हैं:

स्थिरांक आइटम = ["ए", "बी", "सी", "डी", "ई", "एफ"] स्थिरांक मानToRemove = ["सी", "डी"] स्थिरांक फ़िल्टर किए गए आइटम = आइटम.फ़िल्टर (आइटम => !valuesToRemove.includes(item)) // ["a", "b", "e", "f"] console.log(filteredItems)

स्प्लिस() (स्लाइस() के साथ भ्रमित न हों) मूल सरणी को बदल देता है और इससे बचा जाना चाहिए।

आप ES6 का उपयोग कर सकते हैं.

वार ऐरे=["1","2","3","4","5","6"] वार इंडेक्स = एरे.फिल्टर((मान)=>वैल्यू!='3");

["1", "2", "4", "5", "6"]

आप इसे फ़िल्टर विधि से आसानी से कर सकते हैं:

फ़ंक्शन रिमूव(arrOriginal, elementToRemove)( return arrOriginal.filter(function(el)(return el !== elementToRemove)); ) console.log(remove(, 1));

यह सरणी से सभी तत्वों को हटा देता है और स्लाइस और इंडेक्सऑफ संयोजन की तुलना में तेजी से काम करता है

आपको कभी भी किसी ऐरे के ऐरे को म्यूटेट नहीं करना चाहिए। क्योंकि यह कार्यात्मक प्रोग्रामिंग पैटर्न के विरुद्ध है। आप es6 विधि फ़िल्टर का उपयोग करके जिस सरणी को संशोधित करना चाहते हैं उसके संदर्भ के बिना एक नई सरणी बना सकते हैं;

वर मायअरे = ;

मान लीजिए कि आप किसी सारणी से 5 हटाना चाहते हैं, तो आप इसे इस तरह से कर सकते हैं।

MyArray = myArray.filter(मान => मान !== 5);

यह आपको उस मान के बिना एक नई सरणी देगा जिसे आप हटाना चाहते हैं। तो परिणाम होगा

; //5 को इस सरणी से हटा दिया गया है

अधिक समझने के लिए आप Array.filter फ़िल्टर पर MDN दस्तावेज़ पढ़ सकते हैं

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

वर my_array = ; my_array हटाएं; कंसोल.लॉग(my_array.filter(function(a)(रिटर्न टाइपऑफ़ ए !== "अपरिभाषित";)));

प्रदर्शित किया जाना चाहिए

यदि आपके पास किसी सरणी में जटिल ऑब्जेक्ट हैं, तो क्या आप फ़िल्टर का उपयोग कर सकते हैं? ऐसी स्थितियों में जहां $.inArray या array.splice का उपयोग करना इतना आसान नहीं है। विशेष रूप से यदि ऑब्जेक्ट संभवतः सरणी में छोटे हैं।

उदाहरण के लिए, यदि आपके पास आईडी फ़ील्ड वाला कोई ऑब्जेक्ट है और आप चाहते हैं कि ऑब्जेक्ट को सरणी से हटा दिया जाए:

This.array = this.array.filter(function(element, i) ( return element.id !== idToRemove; ));

उस सरणी तत्व का सूचकांक ढूंढें जिसे आप हटाना चाहते हैं, फिर splice का उपयोग करके उस सूचकांक को हटा दें।

स्प्लिस () विधि मौजूदा तत्वों को हटाकर और/या नए तत्वों को जोड़कर किसी सरणी की सामग्री को संशोधित करती है।

वर सरणी = ; कंसोल.लॉग(सरणी) var सूचकांक = array.indexOf(5); यदि (सूचकांक > -1) ( array.splice(सूचकांक, 1); ) // सरणी = कंसोल.लॉग(सरणी);

ब्याह का दूसरा पैरामीटर हटाए जाने वाले तत्वों की संख्या है। ध्यान दें कि ब्याह सरणी को उसके स्थान पर संशोधित करता है और हटाए गए तत्वों वाली एक नई सरणी लौटाता है।

आपके पास 1 से 9 सारणियाँ हैं और आप नीचे दिए गए कोड का उपयोग करके 5 को हटाना चाहते हैं।

वर संख्याअरे = ; var newNumberArray = numberArray.filter(m => ( return m !== 5; )); कंसोल.लॉग ("नया ऐरे, 5 हटा दिया गया", newNumberArray);

यदि आप एकाधिक पूर्व मानों का उपयोग करना चाहते हैं: - 1,7,8

वर संख्याअरे = ; var newNumberArray = numberArray.filter(m => ( return (m !== 1) && (m !== 7) && (m !== 8); )); कंसोल.लॉग ("नया ऐरे, 5 हटा दिया गया", newNumberArray);

यदि आप पूर्व सरणी में सरणी मान हटाना चाहते हैं:-

वर संख्याअरे = ; वर रिमूवलएरे = ; var newNumberArray = numberArray.filter(m => ( return !removebleArray.includes(m); )); कंसोल.लॉग ("नया ऐरे, हटाया गया", newNumberArray);

समर्थित ब्राउज़र शामिल है - लिंक

मैं जानता हूं कि पहले से ही कई उत्तर हैं, लेकिन उनमें से कई समस्या को जटिल बनाते प्रतीत होते हैं। कुंजी के सभी उदाहरणों को हटाने का एक सरल, पुनरावर्ती तरीका यहां दिया गया है - इंडेक्स मिलने तक self को कॉल करें। हां, यह केवल ब्राउज़र इंडेक्सऑफ़ में काम करता है, लेकिन यह सरल है और इसे आसानी से भरा जा सकता है।

ऑफ़लाइन फ़ंक्शन

फ़ंक्शन रिमूवऑल (सरणी, कुंजी) (var इंडेक्स = array.indexOf (कुंजी); यदि (सूचकांक === -1) वापसी; array.splice (सूचकांक, 1); सभी को हटाएं (सरणी, कुंजी); )

प्रोटोटाइप विधि

Array.prototype.removeAll = function(key)( var Index = this.indexOf(key); if(index === -1) return; this.splice(index, 1); this.removeAll(key); )

Array.prototype.removeItem = function(a) ( for (i = 0; i< this.length; i++) { if (this[i] == a) { for (i2 = i; i2 < this.length - 1; i2++) { this = this; } this.length = this.length - 1 return; } } } var recentMovies = ["Iron Man", "Batman", "Superman", "Spiderman"]; recentMovies.removeItem("Superman");