javascript खोज - मैं जावास्क्रिप्ट में किसी सरणी से किसी विशेष तत्व को कैसे हटा सकता हूं?




की भाषा (25)

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

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

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


Answers

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 (splice) का प्रयोग करें:

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

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

सूचकांक चाल से लगभग 10x धीमी है। यहां तक ​​कि अगर indexOf में कॉल को हटाकर सुधार किया जाता है तो 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

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

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

delete array[ index ];

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

array.splice( index, 1 );

और यदि आपको उस आइटम के मान की आवश्यकता है, तो आप केवल लौटे सरणी के तत्व को स्टोर कर सकते हैं:

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

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

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


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

एक सरणी से सभी उदाहरण निकालें

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

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


यदि आपके पास सरणी में जटिल वस्तुएं हैं तो आप फ़िल्टर का उपयोग कर सकते हैं? ऐसी परिस्थितियों में जहां $ .inArray या array.splice उपयोग करने में आसान नहीं है। विशेष रूप से अगर वस्तुओं सरणी में उथले हैं।

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

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

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

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]

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


अद्यतन: इस विधि की केवल तभी अनुशंसा की जाती है जब आप 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]

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

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]


उन सभी उत्तरों के आधार पर जो मुख्य रूप से सही थे और ध्यान में रखते हुए सर्वोत्तम प्रथाओं को ध्यान में रखते हुए (विशेष रूप से सीधे ऐरे.प्रोटोटाइप का उपयोग नहीं करते), मैं नीचे दिए गए कोड के साथ आया:

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

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

  return arrCopy;
}

उपरोक्त फ़ंक्शन की समीक्षा करना, इस तथ्य के बावजूद कि यह ठीक काम करता है, मुझे एहसास हुआ कि कुछ प्रदर्शन सुधार हो सकते हैं। ES5 के बजाय ES6 का उपयोग करना भी एक बेहतर तरीका है। इसके लिए, यह बेहतर कोड है:

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

कैसे इस्तेमाल करे:

const arr = [1,2,3,4,5,"name", false];

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

मैं वर्तमान में एक ब्लॉग पोस्ट लिख रहा हूं जिसमें मैंने बिना किसी समस्या के ऐरे के कई समाधानों का खंडन किया है और इसे चलाने के समय की तुलना में। एक बार जब मैं उस पोस्ट को समाप्त कर दूंगा तो मैं इस जवाब को लिंक के साथ अपडेट कर दूंगा। बस आपको बताने के लिए, मैंने उपरोक्त की तुलना लॉनाश के बिना की है और यदि ब्राउज़र का समर्थन करता है Map, तो यह लॉशश हो जाता है! ध्यान दें कि मैं उपयोग नहीं कर रहा हूं Array.prototype.indexOfया Array.prototype.includesexlcudeValues ​​को लपेटकर Mapया Objectतेजी से पूछताछ करता हूं ! ( https://jsperf.com/array-without-benchmark-against-lodash )


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

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

आउटपुट:

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

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

// 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-तत्व सरणी के साथ समाप्त होते हैं। पता नहीं क्यों, लेकिन मैंने पुष्टि की कि जॉन के मूल कार्यान्वयन में यह समस्या नहीं है।


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

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

यदि आप किसी आइटम की अनुक्रमणिका जानते हैं

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

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

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i-1).concat(items.slice(i, 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)

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

कई वस्तुओं को हटा रहा है

क्या होगा यदि एक आइटम की बजाय, आप कई वस्तुओं को हटाना चाहते हैं?

आइए सबसे सरल समाधान ढूंढें।

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

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

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/ पर पोस्ट किया गया )


मुझे पता है कि पहले से ही बहुत सारे जवाब हैं, लेकिन उनमें से कई समस्या को जटिल बनाते हैं। यहां एक कुंजी के सभी उदाहरणों को हटाने का एक सरल, पुनरावर्ती तरीका है - इंडेक्स नहीं मिलने तक स्वयं को कॉल करें। हां, यह केवल ब्राउज़र में काम करता है 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);
}

मुझे नहीं पता कि आप 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];

ईएस 6 और उत्परिवर्तन के बिना: (अक्टूबर 2016)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

फिर :

removeByIndex([33,22,11,44],1) //=> [33,11,44]

जवाब देने के लिए बहुत पुराना है, लेकिन यह किसी मूल्य की बजाय भविष्यवाणी प्रदान करके किसी की सहायता कर सकता है।

नोट: यह दिए गए सरणी को अपडेट करेगा, और प्रभावित पंक्तियों को वापस करेगा

प्रयोग

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

आप इसे filter विधि के साथ आसानी से कर सकते हैं:

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

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


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

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");

आउटपुट - जैसा कि अपेक्षित था। ["item1", "item1"]

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


मेरे पास सरणी से हटाने के लिए एक और अच्छा समाधान है:

var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

filter


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

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

var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

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

नोट : indexOf के लिए ब्राउज़र समर्थन सीमित है; यह इंटरनेट एक्सप्लोरर 7 और 8 में समर्थित नहीं है।

यदि आपको असमर्थित ब्राउज़र में indexOf आवश्यकता है, तो निम्न polyfill आज़माएं। यहां इस polyfill बारे में अधिक जानकारी प्राप्त करें

Array.prototype.indexOf || (Array.prototype.indexOf = function(d, e) {
    var a;
    if (null == this) throw new TypeError('"this" is null or not defined');
    var c = Object(this),
        b = c.length >>> 0;
    if (0 === b) return -1;
    a = +e || 0;
    Infinity === Math.abs(a) && (a = 0);
    if (a >= b) return -1;
    for (a = Math.max(0 <= a ? a : b - Math.abs(a), 0); a < b;) {
        if (a in c && c[a] === d) return a;
        a++
    }
    return -1
});

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

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

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

आइटम को हटा रहा है (ईसीएमए -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 ]

आइटम को हटा रहा है (ES2015 कोड)

let value = 3

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

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

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

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

कई वस्तुओं को हटा रहा है (ES2016 कोड)

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

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 (...)" फ़ंक्शन को IE में समर्थित नहीं है, 47 संस्करण से पहले क्रोम, 43 संस्करण से पहले फ़ायरफ़ॉक्स, 9 संस्करण से पहले सफारी और 14 संस्करण से पहले एज, तो मोज़िला से पॉलीफिल यहां है

कई वस्तुओं को हटा रहा है (कटिंग-एज प्रयोगात्मक जावास्क्रिप्ट ES2018?)

// 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 में इसे स्वयं आज़माएं :)

संदर्भ


आपके पास 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, 5 removed", newNumberArray);

यदि आप सरणी में सरणी मान को निकालना चाहते हैं: - [3,4,5]

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);

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


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

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);

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

  1. splice () : anArray.splice(index, 1);

  2. हटाएं : delete anArray[index];

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

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

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

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


आप lodash _.pull (mutate array) का उपयोग कर सकते हैं, _.pullAt (mutate array) या _.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']

var x = [4, 5, 6];
for (i = 0, j = x[i]; i < x.length; j = x[++i]) {
    console.log(i,j);
}

बहुत साफ ...





javascript arrays