8279

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

किसी सरणी से एक विशिष्ट तत्व को निकालने का एक सरल तरीका है?

मैं कुछ के बराबर की तलाश में हूँ:

array.remove(number);

मुझे कोर जावास्क्रिप्ट का उपयोग करना होगा। फ्रेमवर्क की अनुमति नहीं है।

javascript arrays

— वॉकर
स्रोत

11867

indexउस सरणी तत्व का पता लगाएं जिसका आप उपयोग करना चाहते हैं indexOf, और उसके बाद उस सूचकांक को हटा दें splice।

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

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array);

स्निपेट का विस्तार करें

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

पूर्णता के कारण के लिए, यहां कार्य हैं। पहला फ़ंक्शन केवल एकल घटना को हटाता है (अर्थात से पहला मैच निकाल रहा 5है [2,5,9,1,5,8,5]), जबकि दूसरा फ़ंक्शन सभी घटनाओं को हटा देता है:

function removeItemOnce(arr, value) { 
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}

function removeItemAll(arr, value) {
    var i = 0;
    while (i < arr.length) {
        if(arr[i] === value) {
            arr.splice(i, 1);
        } else {
            ++i;
        }
    }
    return arr;
}

— टॉम वडले
स्रोत

15

@Peter, हाँ आप सही हो सकते हैं। यह लेख अधिक व्याख्या करता है और असंगत ब्राउज़रों के लिए वर्कअराउंड है: developer.mozilla.org/en/JavaScript/Reference/Global_Objects/…

— टॉम वडले

33

@AlexandreWiechersVaz बेशक यह आदेश को संरक्षित करता है, अगर यह नहीं था तो यह बिल्कुल बेकार होगा

— TheZ

15

आप यहाँ दिए गए

15

@AdrianP। array.indexOf(testValue)खाली सरणी -1 होगी, और यदि आप उसके लिए परीक्षण कर रहे हैं तो कोई ब्याह नहीं। शायद जवाब बदल गया है।

— उपराष्ट्रपति

13

IE 7, IE8, IE9, IE10 Microsoft द्वारा स्वयं असमर्थित हैं, वेब डेवलपर्स को उन पुराने ब्राउज़रों का समर्थन क्यों करना चाहिए? बस ब्राउज़र को अपग्रेड करने के बारे में सूचना दिखाएं! support.microsoft.com/en-us/lifecycle/…

— Lukas Liesis

1262

मुझे नहीं पता कि आप कैसे array.remove(int)व्यवहार करने की उम्मीद कर रहे हैं। मुझे लगता है कि आप चाहते हो सकता है कि तीन संभावनाएं हैं।

किसी इंडेक्स पर किसी ऐरे के तत्व को हटाने के लिए i:

array.splice(i, 1);

यदि आप numberसरणी से मान के साथ प्रत्येक तत्व को निकालना चाहते हैं :

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
        array.splice(i, 1);
    }
}

यदि आप अभी तत्व को इंडेक्स पर बनाना चाहते iहैं, तो वह मौजूद नहीं है, लेकिन आप अन्य तत्वों के इंडेक्स को बदलना नहीं चाहते हैं:

delete array[i];

— पीटर ओल्सन
स्रोत

333

deleteकिसी सरणी से किसी तत्व को निकालने का सही तरीका नहीं है!

— फेलिक्स क्लिंग

71

@FelixKling यह निर्भर करता है, यह काम करता है यदि आप इसे बनाना चाहते हैं ताकि array.hasOwnProperty(i)रिटर्न आए falseऔर उस स्थिति में तत्व वापस आ जाए undefined। लेकिन मैं मानता हूं कि यह बहुत सामान्य बात नहीं है कि मैं क्या करना चाहता हूं।

— पीटर ओल्सन

88

deleteसरणी की लंबाई को अद्यतन नहीं करेगा और न ही वास्तव में तत्व को मिटाता है, केवल इसे विशेष मूल्य से बदल देता है undefined।

— डायोसनी

34

@diosney मुझे नहीं पता कि आपका क्या मतलब है जब आप कहते हैं कि यह वास्तव में तत्व को मिटाता नहीं है। इसके अलावा, यह उस सूचकांक पर मूल्य को बदलने की तुलना में अधिक करता है undefined: यह सूचकांक और मान दोनों को सरणी से हटा देता है, यानी बाद में delete array[0], "0" in arrayगलत वापस आ जाएगा।

— पीटर ओल्सन

17

@GrantGryczan क्षमा करें, मैं असहमत हूं। मुझे इसे हटाने की आवश्यकता नहीं दिख रही है। ऊपर दिया गया पाठ स्पष्ट रूप से बताता है कि यह क्या करता है, और यह उन लोगों की मदद करता है जो यह नहीं जानते deleteहैं कि यह समझने की क्या ज़रूरत है कि यह काम क्यों नहीं करता है जैसा कि वे उम्मीद करते हैं।

— पीटर ओल्सन

1202

2016 अक्टूबर को संपादित

इसे सरल, सहज और स्पष्ट ( ओकाम का उस्तरा) करें )
इसे अपरिवर्तनीय करें (मूल सरणी अपरिवर्तित रहें)
यह मानक जावास्क्रिप्ट कार्यों के साथ करें, यदि आपका ब्राउज़र उनका समर्थन नहीं करता है - पॉलीफिल का उपयोग करें

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

आइटम को निकालना (ECMA-262 संस्करण 5 कोड उर्फ ओल्डस्टाइल जावास्क्रिप्ट)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) {
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

आइटम निकालना (ECMAScript 6 कोड)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

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

एकाधिक आइटम निकालना (ECMAScript 7 कोड)

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

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

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

कई वस्तुओं को हटाना (भविष्य में, शायद)

यदि "यह-बाइंडिंग सिंटैक्स" प्रस्ताव कभी स्वीकार किया जाता है, तो आप ऐसा कर पाएंगे:

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

अपने आप को BabelJS में आज़माएं :)

संदर्भ

— ujeenator
स्रोत

6

लेकिन, कभी-कभी हम मूल सरणी (गैर अपरिवर्तनीय) से तत्व को हटाना चाहते हैं, उदाहरण के लिए कोणीय 2 में इस्तेमाल किया गया सरणी * एनजीयर निर्देश

— रविन्दर पायल

43

स्वीकार किए गए समाधान से बेहतर है क्योंकि यह एक मैच की केवल एक घटना नहीं मानता है और अपरिवर्तनीयता बेहतर है

— ग्रेग

13

filterहालांकि एक बड़े सरणी के लिए बहुत धीमा होना चाहिए?

— नाथन

3

यदि आपने अपने उदाहरणों में उसी चर के असाइनमेंट का उपयोग किया है तो अपरिवर्तनीयता का क्या उल्लेख है? :)

— मेन्च

12

यह एक बेहतरीन जवाब है। स्प्लिट फ़िल्टरिंग नहीं करने के लिए उत्परिवर्तन के लिए एक विशेष कार्य है। filterधीमा प्रदर्शन हो सकता है लेकिन यह अधिक सुरक्षित और बेहतर कोड है। इसके अलावा, आप लैम्ब्डा में एक दूसरे तर्क को निर्दिष्ट करके सूचकांक द्वारा फ़िल्टर कर सकते हैं:arr.filter((x,i)=>i!==2)

— मैथ्यू

449

यह इस बात पर निर्भर करता है कि आप खाली जगह रखना चाहते हैं या नहीं।

यदि आप एक खाली स्लॉट चाहते हैं, तो डिलीट ठीक है:

delete array[index];

यदि आप नहीं करते हैं, तो आपको ब्याह विधि का उपयोग करना चाहिए :

array.splice(index, 1);

और अगर आपको उस वस्तु के मूल्य की आवश्यकता है, तो आप केवल दिए गए सरणी के तत्व को स्टोर कर सकते हैं:

var value = array.splice(index, 1)[0];

यदि आप इसे किसी क्रम में करना चाहते हैं, तो आप array.pop()पिछले एक के लिए उपयोग कर सकते हैंarray.shift() पहले एक के लिए (और दोनों आइटम का मूल्य भी लौटाते हैं)।

और यदि आप आइटम के सूचकांक को नहीं जानते हैं, तो आप array.indexOf(item)इसे प्राप्त करने के लिए ( if()एक आइटम प्राप्त करने के लिए या इन while()सभी को प्राप्त करने के लिए) का उपयोग कर सकते हैं । array.indexOf(item)इंडेक्स या -1 मिलता है अगर नहीं मिला।

— xavierm02
स्रोत

25

deleteकिसी तत्व को सरणी से निकालने का सही तरीका नहीं है !!

— प्रोगो जूल

16

यदि आप "एक स्लॉट खाली करना चाहते हैं" का उपयोग करें array[index] = undefined;। उपयोग deleteसे अनुकूलन नष्ट हो जाएगा।

— बेर्गी

4

@ याकूब ने बहुत अच्छी टिप्पणी दी क्योंकि यह समझने के लिए कि मैंने बहुत समय गंवा दिया और सोचा कि मेरा आवेदन कोड किसी तरह टूट गया है ...

— पास्कल

इंडेक्सऑफ से आपको जो मिलता है, उसके स्पष्टीकरण के साथ अंतिम पैराग्राफ वास्तव में मददगार था

— A. D'Alfonso

277

Internet Explorer 8 में एक मित्र समस्या कर रहा था और उसने मुझे दिखाया कि उसने क्या किया। मैंने उससे कहा कि यह गलत है, और उसने मुझे बताया कि उसे यहां जवाब मिल गया है। वर्तमान शीर्ष उत्तर सभी ब्राउज़रों में काम नहीं करेगा (उदाहरण के लिए इंटरनेट एक्सप्लोरर 8), और यह केवल आइटम की पहली घटना को हटा देगा।

किसी सरणी से सभी आवृत्तियाँ निकालें

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

यह सरणी के माध्यम से पीछे की तरफ लूप करता है (चूंकि सूचक हटाए जाते हैं और लंबाई बदल जाएगी क्योंकि आइटम हटा दिए जाते हैं) और आइटम को हटा देता है यदि यह पाया जाता है। यह सभी ब्राउज़रों में काम करता है।

— बेन लेश
स्रोत

11

@sroes यह नहीं होना चाहिए क्योंकि लूप शुरू होता है i = arr.length -1या i--इसे अधिकतम सूचकांक के समान बनाता है। arr.lengthके लिए सिर्फ एक प्रारंभिक मूल्य है i। i--हमेशा सत्य होगा (और प्रत्येक लूप से कम से कम 1 पर) जब तक यह बराबर 0(एक मिथ्या मूल्य) और लूप तब बंद हो जाएगा।

— गमाजीवु

1

दूसरा कार्य अक्षम है। प्रत्येक पुनरावृत्ति पर "indexOf" सरणी की शुरुआत से खोज शुरू करेगा।

— ujeenator

3

@AmberdeBlack, आइटम के 1 से अधिक होने के साथ एक संग्रह पर, फ़िल्टर विधि को कॉल करने के लिए बेहतर है इसके बजाय arr.filter(function (el) { return el !== item }), कई बार सरणी को म्यूट करने की आवश्यकता से बचें। यह थोड़ा अधिक मेमोरी का उपभोग करता है, लेकिन बहुत अधिक कुशलता से काम करता है, क्योंकि कम काम करना पड़ता है।

— यूजीन कुजमेनको

1

@AlJey, यह केवल IE9 + से उपलब्ध है। अभी भी एक मौका है कि यह काम नहीं करेगा।

— ujeenator

1

इस जवाब ने मेरे लिए काम किया क्योंकि मुझे कई वस्तुओं को हटाने की जरूरत थी लेकिन किसी विशेष क्रम में नहीं। यहाँ पाश के लिए पीछे की ओर प्रगति सरणी से आइटम को पूरी तरह से हटाने का काम करती है।

— mintedsky

172

दो प्रमुख दृष्टिकोण हैं:

ब्याह () :anArray.splice(index, 1);
हटाएं :delete anArray[index];

जब आप किसी ऐरे के लिए डिलीट का उपयोग करें तो सावधान रहें यह वस्तुओं की विशेषताओं को हटाने के लिए अच्छा है, लेकिन सरणियों के लिए इतना अच्छा नहीं है। spliceसरणियों के लिए उपयोग करना बेहतर है ।

ध्यान रखें कि जब आप deleteकिसी ऐरे के लिए उपयोग करते हैं तो आपको गलत परिणाम मिल सकते हैंanArray.length । दूसरे शब्दों में,delete तत्व को हटा देगा, लेकिन यह लंबाई की संपत्ति के मूल्य को अपडेट नहीं करेगा।

डिलीट का उपयोग करने के बाद आप इंडेक्स नंबरों में छेद होने की भी उम्मीद कर सकते हैं, जैसे कि आप इंडेक्स 1, 3, 4, 8, 9, और 11 और लंबाई के साथ समाप्त हो सकते हैं क्योंकि यह डिलीट का उपयोग करने से पहले था। उस मामले में, सभी अनुक्रमितfor लूप क्रैश हो जाएंगे, क्योंकि अनुक्रमित अब अनुक्रमिक नहीं हैं।

यदि आपको deleteकिसी कारण से उपयोग करने के लिए मजबूर किया जाता है , तो आपको for eachऐरो के माध्यम से लूप की आवश्यकता होने पर लूप का उपयोग करना चाहिए । तथ्य की बात के रूप में for, यदि संभव हो तो अनुक्रमित छोरों का उपयोग करने से हमेशा बचें । इस तरह से कोड अधिक मजबूत और कम अनुक्रमित समस्याओं के साथ प्रवण होगा।

— ससा
स्रोत

144

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)

स्निपेट का विस्तार करें

— Zirak
स्रोत

14

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

— चार्ली कियान

10

बुरा विचार, इस पोस्ट को देखें: stackoverflow.com/questions/948358/array-prototype-problem

— MMeah

10

यदि आप for inएक सरणी पर कर रहे हैं , तो आपको पहले से ही एक समस्या है।

— ज़ीरक

2

यदि आप for inसरणियों पर करते हैं, तो आपके पास पहले से ही बड़ी समस्याएं हैं।

— रेनब

Object.defineProperty stackoverflow.com/a/35518127/3779853 का उपयोग करें और आप जाने के लिए अच्छे हैं।

— 1929 में phil294

105

उपयोग करने की आवश्यकता नहीं है indexOfया splice। हालांकि, यह बेहतर प्रदर्शन करता है यदि आप केवल एक तत्व की घटना को दूर करना चाहते हैं।

खोजें और ले जाएँ (ले जाएँ):

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

का प्रयोग करें indexOfऔर splice(indexOf):

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

केवल splice(ब्याह) का उपयोग करें :

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

1000 तत्वों के साथ सरणी के लिए नोडज पर रन-टाइम (औसत 10000 से अधिक रन):

इंडेक्सोफ़ चाल से लगभग 10x धीमा है । भले ही ब्याहindexOf में कॉल को हटाकर सुधार किया जाता है , यह चाल से बहुत खराब प्रदर्शन करता है ।

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms

— slosd
स्रोत

5

ऐसा लगता है कि यहां प्रस्तुत 'चाल' विधि सभी ब्राउज़रों में काम करना चाहिए, और एक अतिरिक्त सरणी बनाने से भी बचती है; यहां अधिकांश अन्य समाधानों में इन समस्याओं में से एक या दोनों हैं। मुझे लगता है कि यह एक बहुत अधिक वोटों का हकदार है, भले ही यह "सुंदर" के रूप में नहीं दिखता है।

— जुकाम

73

यह एक मूल्य के बजाय एक विधेय प्रदान करता है।

नोट: यह दिए गए ऐरे को अपडेट करेगा, और प्रभावित पंक्तियों को लौटाएगा।

प्रयोग

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

परिभाषा

var helper = {

    // Remove and return the first occurrence

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.push(array.splice(i, 1));
                continue;
            }
            i++;
        }
        return removed;
    }
};

— एएमडी
स्रोत

मुझे नहीं पता कि आपको -1 चेक (i> -1) की आवश्यकता है। इसके अलावा, मुझे लगता है कि ये कार्य निष्कासन से अधिक फिल्टर की तरह काम करते हैं। यदि आप row.id === 5 पास करते हैं, तो इसका परिणाम केवल id 5 के साथ होगा, इसलिए यह निष्कासन के विपरीत कार्य कर रहा है। ES2015 में यह अच्छा लगेगा: var result = ArrayHelper.remove (myArray, row => row.id === 5);

— कूल

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

— amd

68

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

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log(remove([1, 2, 1, 0, 3, 1, 4], 1));

इस सरणी से सभी तत्वों को दूर करता है और यह भी का एक संयोजन की तुलना में तेजी से काम करता है sliceऔर indexOf।

— साल्वाडोर डाली
स्रोत

3

क्या आपके पास इस पर एक स्रोत है कि यह तेज है?

— user3711421

2

अच्छा समाधान है। लेकिन जैसा कि आप बताते हैं, लेकिन गंजा बनाने के लिए महत्वपूर्ण है, यह स्लाइस और

— इंडेक्सऑफ

1

@ user3711421 इसका कारण यह है कि सिर्फ स्लाइस और इंडेक्सऑफ वह नहीं करता है जो वह चाहता है कि "एक विशिष्ट तत्व को हटा दें"। यह केवल एक बार तत्व को हटाता है, यह एक विशिष्ट तत्व को हटाता है, चाहे आप उनमें से कितने भी हों

— सल्वाडोर डाली

66

जॉन रेजिग ने एक अच्छा कार्यान्वयन पोस्ट किया :

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

यदि आप एक वैश्विक वस्तु का विस्तार नहीं करना चाहते हैं, तो आप इसके बजाय निम्नलिखित की तरह कुछ कर सकते हैं:

// Array Remove - By John Resig (MIT Licensed)
Array.remove = function(array, from, to) {
    var rest = array.slice((to || from) + 1 || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.push.apply(array, rest);
};

लेकिन मुख्य कारण जो मैं यह पोस्ट कर रहा हूं वह उपयोगकर्ताओं को उस पृष्ठ पर टिप्पणियों में सुझाए गए वैकल्पिक कार्यान्वयन के खिलाफ चेतावनी देने के लिए है (14 दिसंबर, 2007):

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

यह पहली बार में अच्छी तरह से काम करने लगता है, लेकिन एक दर्दनाक प्रक्रिया के माध्यम से मुझे पता चला कि यह एक सरणी में दूसरे से अंतिम तत्व को हटाने की कोशिश करते समय विफल हो जाता है। उदाहरण के लिए, यदि आपके पास 10-तत्व सरणी है और आप इसके साथ 9 वें तत्व को निकालने का प्रयास करते हैं:

myArray.remove(8);

आप एक 8-तत्व सरणी के साथ समाप्त होते हैं। पता नहीं क्यों, लेकिन मैंने पुष्टि की कि जॉन के मूल कार्यान्वयन में यह समस्या नहीं है।

— आरे
स्रोत

बस मुश्किल तरीके से सीखा कारण है कि यह उपयोग करने के लिए एक अच्छा विचार है Object.prototype.hasOwnPropertyहमेशा ¬¬

— Davi Fiamenghi

64

Underscore.js का उपयोग कई ब्राउज़रों के साथ समस्याओं को हल करने के लिए किया जा सकता है। यदि मौजूद है तो यह इन-बिल्ट ब्राउज़र विधियों का उपयोग करता है। यदि वे पुराने Internet Explorer संस्करणों के मामले में अनुपस्थित हैं, तो यह अपने स्वयं के कस्टम तरीकों का उपयोग करता है।

एरे (वेबसाइट से) तत्वों को हटाने के लिए एक सरल उदाहरण:

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]

— वत्सल
स्रोत

हालांकि सुरुचिपूर्ण और संक्षिप्त, ओपी ने स्पष्ट रूप से केवल कोर जेएस का उल्लेख किया

— EigenFool

64

आप ES6 का उपयोग कर सकते हैं। इस मामले में '3' मान को हटाने के लिए उदाहरण के लिए:

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');
console.log(newArray);

आउटपुट:

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

— rajat44
स्रोत

4

यह उत्तर अच्छा है क्योंकि यह सीधे मूल को संशोधित करने के बजाय मूल सरणी की एक प्रति बनाता है।

— क्लाउडियो होलांडा

नोट: Array.prototype.filter ECMAScript 5.1 (कोई IE8) नहीं है। अधिक विशिष्ट समाधान के लिए: stackoverflow.com/a/54390552/8958729

— चांग

54

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

var my_array = [1, 2, 3, 4, 5, 6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

इसे प्रदर्शित करना चाहिए [1, 2, 3, 4, 6]।

— Loupax
स्रोत

45

इस कोड को देखें। यह हर प्रमुख ब्राउज़र में काम करता है ।

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

इस फ़ंक्शन को कॉल करें

remove_item(array,value);

— एकरामुल होक
स्रोत

4

@ रोलैंड इलिग एक for inलूप के उपयोग को छोड़कर और तथ्य यह है कि लूप से परिणाम वापस करके, स्क्रिप्ट को पहले रोका जा सकता था।

— Upvotes

1

यह छोटे सरणियों के लिए एक उत्कृष्ट दृष्टिकोण है। यह हर ब्राउज़र में काम करता है, न्यूनतम और सहज कोड का उपयोग करता है, और बिना किसी अतिरिक्त जटिल ढांचे के, शिम या पॉलीफ़िल।

— Beejor

मुझे यकार्ट की टिप्पणी को भी दोहराना चाहिए जो for( i = 0; i < arr.length; i++ )एक बेहतर दृष्टिकोण होगा क्योंकि यह सटीक सूचकांकों को संरक्षित करता है जो कुछ भी ब्राउज़र आइटमों को संग्रहीत करने का निर्णय लेता है for in। ऐसा करने से आपको जरूरत पड़ने पर एक वैल्यू का एरे इंडेक्स मिल सकता है।

— Beejor

41

आप लॉश _.पुल ( म्यूट सरणी), _.pullAt ( म्यूट ऐरे) या _.without ( म्यूट ऐरे नहीं) का उपयोग कर सकते हैं ,

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

— चुन यांग
स्रोत

2

जैसा कि ओपी ने निवेदन किया, क्या यह कोर जेएस नहीं है?

— कुछ गैर-गैर-विवरणी-उपयोगकर्ता

12

@ कुछ-गैर-विवरण-उपयोगकर्ता आप सही हैं। लेकिन मेरे जैसे बहुत से उपयोगकर्ता केवल ओपी के लिए नहीं बल्कि एक सामान्य उत्तर की तलाश में यहां आते हैं।

— चुन यांग

@CunYang आप बिल्कुल सही हैं। मैं पहले से ही लॉश का उपयोग कर रहा हूं, अगर समय बचता है तो क्यों नहीं इसका उपयोग किया जाए।

— int-i

38

ES6 और बिना म्यूटेशन: (अक्टूबर 2016)

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)

स्निपेट का विस्तार करें

— अब्देनूर TOUMI
स्रोत

क्यों नहीं बस का उपयोग करें filter? array.filter((_, index) => index !== removedIndex);।

— user4642212 18

@ user4642212 आप सही हैं! इसके अलावा, मुझे गोलंग शैली का अण्डरकोर पसंद आया

— अब्देनौर टुमी

36

किसी विशेष तत्व / स्ट्रिंग को सरणी से हटाना एक-लाइनर में किया जा सकता है:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

कहाँ पे:

TheArray : वह सरणी जिसे आप कुछ विशेष से हटाना चाहते हैं

stringToRemoveFromArray : वह स्ट्रिंग जिसे आप निकालना चाहते हैं और 1 वह तत्व है जिसे आप हटाना चाहते हैं।

ध्यान दें : यदि "stringToRemoveFromArray" आपके सरणी में स्थित नहीं है, तो यह सरणी के अंतिम तत्व को हटा देगा।

यह जांचने के लिए हमेशा अच्छा अभ्यास है कि तत्व आपके सरणी में मौजूद है, इसे हटाने से पहले।

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

यदि आपके पास अपने क्लाइंट के कंप्यूटरों पर नए एक्मास्मार्क संस्करणों तक पहुंच है (चेतावनी, पुराने स्टेशनों पर काम नहीं कर सकते हैं):

var array=['1','2','3','4','5','6']
var newArray = array.filter((value)=>value!='3');

जहाँ '3' वह मान है जिसे आप ऐरे से हटा सकते हैं। तब सरणी बन जाएगी:['1','2','4','5','6']

— मैक्स अलेक्जेंडर हैना
स्रोत

यह वह उत्तर है जो रेडियो बटन टॉगलिंग के आधार पर एक सरणी को अपडेट करने की कोशिश करते समय मेरे लिए काम करता है।

— jdavid05

4

सावधान रहें, यदि "stringToRemoveFromArray"आप सरणी में स्थित नहीं हैं , तो यह सरणी के अंतिम तत्व को हटा देगा।

— फ्यूजन

35

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

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

यदि आप किसी वस्तु का सूचकांक जानते हैं

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

एक विधि का उपयोग करना है slice():

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

स्निपेट का विस्तार करें

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

यदि आप मूल्य जानते हैं

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

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

स्निपेट का विस्तार करें

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

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

स्निपेट का विस्तार करें

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

कई आइटम निकाल रहा है

क्या होगा अगर एक आइटम के बजाय, आप कई आइटम निकालना चाहते हैं?

आइए सरलतम उपाय खोजें।

सूचकांक द्वारा

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

const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

स्निपेट का विस्तार करें

मूल्य से

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

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

स्निपेट का विस्तार करें

मूल सरणी को बदलने से बचें

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

(मूल रूप से https://flaviocopes.com/how-to-remove-item-from-array/ पर पोस्ट किया गया )

— फ्लेवियो कॉप्स
स्रोत

34

ठीक है, उदाहरण के लिए आपके पास नीचे का सरणी है:

var num = [1, 2, 3, 4, 5];

और हम नंबर 4 को हटाना चाहते हैं। आप बस नीचे दिए गए कोड का उपयोग कर सकते हैं:

num.splice(num.indexOf(4), 1); // num will be [1, 2, 3, 5];

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

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1)
      return;
  this.splice(i, 1); // num.remove(5) === [1, 2, 3];
}

लेकिन कैसे के बारे में अगर आप सरणी में कुछ [5] के बजाय नीचे सरणी है?

var num = [5, 6, 5, 4, 5, 1, 5];

हमें उन सभी की जांच करने के लिए एक लूप की आवश्यकता है, लेकिन एक आसान और अधिक कुशल तरीका बिल्ट-इन जावास्क्रिप्ट फ़ंक्शन का उपयोग कर रहा है, इसलिए हम एक फ़ंक्शन लिखते हैं जो इसके बजाय नीचे एक फिल्टर का उपयोग करते हैं:

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]

इसके अलावा तीसरे पक्ष के पुस्तकालय भी हैं जो आपको ऐसा करने में मदद करते हैं, जैसे कि लोदाश या अंडरस्कोर। अधिक जानकारी के लिए, दर्ज करें _.pull, _.pullAt या _.without देखें।

— एलिरेज़ा
स्रोत

एक छोटा टाइपो है। कृपया सही करें। this.splice(num.indexOf(x), 1);=>this.splice(this.indexOf(x), 1);

— TheGwa

कृपया जावास्क्रिप्ट में बिल्ट-इन (Array.prototype के लिए फ़ंक्शंस संलग्न करें) को बढ़ाएँ नहीं। यह व्यापक रूप से बुरा अभ्यास माना जाता है।

— अनिकेरू

मैं मानता हूं कि यह दुनिया में सबसे अच्छी बात नहीं है, लेकिन इस मामले में आप इसे कैसे पूरा कर सकते हैं?

— एलिरेज़ा

आपको सूचकांक की जांच करनी चाहिए। यदि इंडेक्स = -1, स्प्लिस (-1,1) अंतिम तत्व को हटा देगा

— रिचर्ड चान

29

मैं जावास्क्रिप्ट के लिए बहुत नया हूं और इस कार्यक्षमता की आवश्यकता है। मैंने केवल यह लिखा है:

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

फिर जब मैं इसका उपयोग करना चाहता हूं:

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

आउटपुट - अपेक्षा के अनुरूप। ["आइटम 1", "आइटम 1"]

आपके पास मेरी तुलना में अलग-अलग आवश्यकताएं हो सकती हैं, इसलिए आप उन्हें सूट करने के लिए आसानी से संशोधित कर सकते हैं। मुझे उम्मीद है इससे किसी को सहायता मिलेगी।

— sofiax
स्रोत

1

यह भयानक व्यवहार करने वाला है यदि आपका सरणी वास्तव में लंबा है और इसमें तत्व के कई उदाहरण हैं। सरणी की अनुक्रमणिका विधि हर बार शुरुआत में शुरू होगी, इसलिए आपकी लागत O (n ^ 2) होगी।

— ज़ैग

@ ज़ैग: इसका एक नाम है: शमील द पेंटर के एल्गोरिथ्म

— पीटर मोर्टेंसन

27

यदि आपके पास सरणी में जटिल ऑब्जेक्ट हैं तो आप फ़िल्टर का उपयोग कर सकते हैं? उन स्थितियों में जहाँ $ .inArray या array.splice का उपयोग करना उतना आसान नहीं है। खासतौर पर तब, जब ऑब्जेक्ट सरणी में उथले हों।

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

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

— flurdy
स्रोत

यह मुझे ऐसा करना पसंद है। एरो फंक्शन का उपयोग करके यह वन-लाइनर हो सकता है। मैं प्रदर्शन को लेकर उत्सुक हूं। इसके अलावा कुछ भी नहीं है कि यह सरणी को प्रतिस्थापित करता है। पुराने सरणी के संदर्भ में कोई भी कोड परिवर्तन को नोटिस नहीं करेगा।

— joeytwiddle

27

मैं ECMAScript 6 के आधार पर उत्तर देना चाहता हूं । मान लें, आपके पास नीचे की तरह एक सरणी है:

let arr = [1,2,3,4];

यदि आप एक विशेष सूचकांक में हटाना चाहते हैं 2, तो नीचे दिए गए कोड को लिखें:

arr.splice(2, 1); //=> arr became [1,2,4]

लेकिन अगर आप एक विशेष वस्तु को हटाना चाहते हैं 3और आप इसके सूचकांक को नहीं जानते हैं, तो नीचे की तरह काम करें:

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

संकेत : कृपया फ़िल्टर कॉलबैक के लिए एक तीर फ़ंक्शन का उपयोग करें जब तक कि आपको खाली सरणी नहीं मिलेगी।

— AmerllicA
स्रोत

25

अद्यतन: यह विधि केवल तभी अनुशंसित की जाती है जब आप ECMAScript 2015 (जिसे पहले ES6 के रूप में जाना जाता है) का उपयोग नहीं कर सकते हैं। यदि आप इसका उपयोग कर सकते हैं, तो अन्य उत्तर यहां बहुत अधिक भोग कार्यान्वयन प्रदान करते हैं।

यहां यह जिस्ट आपकी समस्या को हल करेगा, और केवल 1 (या एक निर्दिष्ट मान) के बजाय तर्क की सभी घटनाओं को हटा देगा।

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

उपयोग:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]

— zykadelic
स्रोत

25

प्रदर्शन

आज (2019-12-09) मैं चुने हुए समाधानों के लिए macOS v10.13.6 (हाई सिएरा) पर प्रदर्शन परीक्षण करता हूं। मैं दिखाता हूं delete(ए), लेकिन मैं अन्य तरीकों की तुलना में इसका उपयोग नहीं करता हूं, क्योंकि यह सरणी में खाली जगह छोड़ देता है।

निष्कर्ष

सबसे तेज़ समाधान है array.splice(C) (छोटी सरणियों के लिए सफ़ारी को छोड़कर जहां यह दूसरी बार है)
बड़े सरणियों के लिए, array.slice+splice(एच) फ़ायरफ़ॉक्स और सफारी के लिए सबसे तेज़ अपरिवर्तनीय समाधान है; Array.from(B) क्रोम में सबसे तेज है
उत्परिवर्ती समाधान आमतौर पर अपरिवर्तनीय की तुलना में 1.5x-6x तेज होते हैं
सफारी पर छोटे तालिकाओं के लिए, आश्चर्यजनक रूप से उत्परिवर्तनीय समाधान (C) अपरिवर्तनीय समाधान (G) की तुलना में धीमा है

विवरण

परीक्षणों में मैं विभिन्न तरीकों से सरणी से मध्य तत्व निकालता हूं। ए, सी समाधान में जगह नहीं है। बी, डी, ई, एफ, जी, एच समाधान अपरिवर्तनीय हैं।

10 तत्वों के साथ सरणी के लिए परिणाम

Chrome में array.splice(C) सबसे तेज़ इन-प्लेस समाधान है। array.filter(डी) सबसे तेजी से अपरिवर्तनीय समाधान है। सबसे धीमा array.slice(एफ) है। आप यहां अपनी मशीन पर परीक्षण कर सकते हैं ।

1.000.000 तत्वों के साथ सरणी के लिए परिणाम

Chrome में array.splice(C) सबसे तेज़ इन-प्लेस समाधान है ( delete(C) समान तेज़ है - लेकिन यह सरणी में एक खाली स्लॉट छोड़ गया है (इसलिए यह 'पूर्ण निष्कासन नहीं करता है')। array.slice-splice(एच) सबसे तेजी से अपरिवर्तनीय समाधान है। सबसे धीमा array.filter(डी और ई) है। आप यहां अपनी मशीन पर परीक्षण कर सकते हैं ।

कोड स्निपेट दिखाएं

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);

This snippet only presents code used in performance tests - it does not perform tests itself.

स्निपेट का विस्तार करें

ब्राउज़रों के लिए तुलना: क्रोम v78.0.0, सफारी v13.0.4, और फ़ायरफ़ॉक्स v71.0.0

— कामिल कियॉलेजवस्की
स्रोत

24

आपको अपने सरणी को कभी भी म्यूट नहीं करना चाहिए। जैसा कि यह कार्यात्मक प्रोग्रामिंग पैटर्न के खिलाफ है। आप ECMAScript 6 विधि का उपयोग करके डेटा को बदलना चाहते हैं, उस सरणी को संदर्भित किए बिना एक नई सरणी बना सकते हैं filter;

var myArray = [1, 2, 3, 4, 5, 6];

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

myArray = myArray.filter(value => value !== 5);

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

 [1, 2, 3, 4, 6]; // 5 has been removed from this array

आगे की समझ के लिए आप Array.filter पर MDN प्रलेखन पढ़ सकते हैं ।

— अदील इमरान
स्रोत

21

एक अधिक आधुनिक, ईसीएमएस्क्रिप्ट 2015 (जिसे पहले हार्मनी या ईएस 6 के रूप में जाना जाता है) दृष्टिकोण। दिया हुआ:

const items = [1, 2, 3, 4];
const index = 2;

फिर:

items.filter((x, i) => i !== index);

उपज:

[1, 2, 4]

यह सुनिश्चित करने के लिए कि आप ब्राउज़रों में अच्छी तरह से समर्थित हैं, आप बैबेल और एक पॉलीफिल सेवा का उपयोग कर सकते हैं ।

— bjfletcher
स्रोत

4

ध्यान दें कि .filterएक नया सरणी देता है, जो समान सरणी से तत्व को हटाने के समान नहीं है। इस दृष्टिकोण का लाभ यह है कि आप सरणी विधियों को एक साथ जोड़ सकते हैं। जैसे:[1,2,3].filter(n => n%2).map(n => n*n) === [ 1, 9 ]

— कोडऑलॉट

महान, अगर मेरे पास सरणी में 600k तत्व हैं और पहले 50k को निकालना चाहते हैं, तो क्या आप उस धीमेपन की कल्पना कर सकते हैं? यह समाधान नहीं है, ऐसे फ़ंक्शन की आवश्यकता है जो केवल तत्वों को निकालते हैं और कुछ भी नहीं लौटाते हैं।

— dev1223

@ इसके लिए, आप शायद उपयोग करना चाहते हैं spliceया slice।

— bjfletcher

@bjfletcher थैट्स को हटाने की प्रक्रिया में और भी बेहतर, बस 50K तत्वों को आवंटित करें और उन्हें कहीं फेंक दें। (टुकड़ा 550K तत्वों के साथ, लेकिन उन्हें खिड़की से फेंकने के बिना)।

— dev1223

मैं bjfletcher का जवाब पसंद करूंगा, जो जितना छोटा हो सकता है items= items.filter(x=>x!=3)। इसके अलावा, ओपी ने बड़े डेटा सेट के लिए कोई आवश्यकता नहीं बताई।

— रन

21

आपके पास सरणी में 1 से 9 है, और आप निकालना चाहते हैं 5. नीचे दिए गए कोड का उपयोग करें:

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

स्निपेट का विस्तार करें

यदि आप कई मान चाहते हैं। उदाहरण: - 1,7,8

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 1,7 and 8 removed", newNumberArray);

स्निपेट का विस्तार करें

यदि आप किसी array में array value हटाना चाहते हैं। उदाहरण: [३,४,५]

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

स्निपेट का विस्तार करें

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

— थिलिना संपत
स्रोत

19

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

स्टैंड-अलोन फंक्शन

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

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

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}

— wharding28
स्रोत

बस एक नोट, इस विधि के साथ 1 कैविटी स्टैक ओवरफ्लो की क्षमता है। जब तक आप बड़े पैमाने पर सरणियों के साथ काम कर रहे हैं, तब तक आपको कोई समस्या नहीं होनी चाहिए।

— wharding28 5

लेकिन बीच में वापसी क्यों? यह प्रभावी रूप से एक गोटो बयान है।

— पीटर मोर्टेंसन

18

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

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

लाइव डेमो

— जेफ नोएल
स्रोत

मैं किसी सरणी से एक विशिष्ट आइटम कैसे निकाल सकता हूं?

2016 अक्टूबर को संपादित

आइटम को निकालना (ECMA-262 संस्करण 5 कोड उर्फ ​​ओल्डस्टाइल जावास्क्रिप्ट)

आइटम निकालना (ECMAScript 6 कोड)

एकाधिक आइटम निकालना (ECMAScript 7 कोड)

कई वस्तुओं को हटाना (भविष्य में, शायद)

किसी सरणी से सभी आवृत्तियाँ निकालें

प्रयोग

परिभाषा

यदि आप किसी वस्तु का सूचकांक जानते हैं

यदि आप मूल्य जानते हैं

कई आइटम निकाल रहा है

सूचकांक द्वारा

मूल्य से

मूल सरणी को बदलने से बचें

प्रदर्शन

विवरण

लाइव डेमो

आइटम को निकालना (ECMA-262 संस्करण 5 कोड उर्फ ओल्डस्टाइल जावास्क्रिप्ट)