~Onlooker
2011-04-23 22:17
采纳率: 0%
浏览 977
已采纳

如何在 JavaScript 中从数组中移除特定的元素?

I have an array of integers, and I'm using the .push() method to add elements to it.

Is there a simple way to remove a specific element from an array? The equivalent of something like array.remove(int);.

I have to use core JavaScript - no frameworks are allowed.

转载于:https://stackoverflow.com/questions/5767325/how-do-i-remove-a-particular-element-from-an-array-in-javascript

  • 写回答
  • 好问题 提建议
  • 关注问题
  • 收藏
  • 邀请回答

30条回答 默认 最新

  • larry*wei 2011-04-23 22:23
    已采纳

    Find the index of the array element you want to remove, then remove that index with splice.

    The splice() method changes the contents of an array by removing existing elements and/or adding new elements.

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

    The second parameter of splice is the number of elements to remove. Note that splice modifies the array in place and returns a new array containing the elements that have been removed.


    Note: browser support for indexOf is limited; it is not supported in Internet Explorer 7 and 8.

    If you need indexOf in an unsupported browser, try the following polyfill. Find more info about this polyfill here.

    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
    });
    
    </div>
    
    已采纳该答案
    评论
    解决 无用
    打赏 举报
  • Lotus@ 2011-04-23 22:20
    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)

    </div>
    
    评论
    解决 无用
    打赏 举报
  • 胖鸭 2011-04-23 22:20

    I don't know how you are expecting array.remove(int) to behave. There are three possibilities I can think of that you might be wanting.

    To remove an element of an array at an index i:

    array.splice(i, 1);
    

    If you want to remove every element with value number from the array:

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

    If you just want to make the element at index i no longer exist, but you don't want the indexes of the other elements to change:

    delete array[i];
    
    评论
    解决 无用
    打赏 举报
  • 七度&光 2011-04-23 22:32

    Depends on whether you want to keep an empty spot or not.

    If you do want an empty slot, delete is fine:

    delete array[ index ];
    

    If you don't, you should use the splice method:

    array.splice( index, 1 );
    

    And if you need the value of that item, you can just store the returned array's element:

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

    In case you want to do it in some order, you can use array.pop() for the last one or array.shift() for the first one (and both return the value of the item too).

    And if you don't know the index of the item, you can use array.indexOf( item ) to get it (in a if() to get one item or in a while() to get all of them). array.indexOf( item ) returns either the index or -1 if not found. 

    评论
    解决 无用
    打赏 举报
  • 7*4 2012-10-18 10:13

    If you want a new array with the deleted positions removed, you can always delete the specific element and filter out the array. It might need an extension of the array object for browsers that don't implement the filter method but in the long term its easier since all you do is this:

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

    Should display [1, 2, 3, 4, 6]

    评论
    解决 无用
    打赏 举报
  • Memor.の 2012-12-21 11:32

    There are two major approaches:

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

    2. delete: delete anArray[index];

    Be careful when you use delete for an array. It is good for deleting attributes of objects but not so good for arrays. It is better to use splice for arrays.

    Keep in mind that when you use delete for an array you could get wrong results for anArray.length. In other words, delete would remove the element but wouldn't update the value of length property.

    You can also expect to have holes in index numbers after using delete, e.g. you could end up with having indexes 1,3,4,8,9,11 and length as it was before using delete. In that case, all indexed for loops would crash, since indexes are no longer sequential.

    If you are forced to use delete for some reason, then you should use for each loops when you need to loop through arrays. As the matter of fact, always avoid using indexed for loops, if possible. That way the code would be more robust and less prone to problems with indexes.

    评论
    解决 无用
    打赏 举报
  • python小菜 2013-03-13 09:28

    Update: This method is recommended only if you cannot use ECMAScript 2015 (formerly known as ES6). If you can use it, other answers here provide much neater implementations.


    This gist here will solve your problem, and also deletes all occurrences of the argument instead of just 1 (or a specified value).

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

    Usage:

    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]
    
    评论
    解决 无用
    打赏 举报
  • ~Onlooker 2013-04-02 10:56

    Check out this code. It works in every major browser.

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

    Call this function

    remove_item(array,value);
    
    评论
    解决 无用
    打赏 举报
  • bug^君 2013-08-10 19:21

    A friend was having issues in Internet Explorer 8, and showed me what he did. I told him it was wrong, and he told me he got the answer here. The current top answer will not work in all browsers (Internet Explorer 8 for example), and it will only remove the first occurrence of the item.

    Remove ALL instances from an array

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

    It loops through the array backwards (since indices and length will change as items are removed) and removes the item if it's found. It works in all browsers.

    评论
    解决 无用
    打赏 举报
  • 妄徒之命 2013-08-12 17:56

    You can do a backward loop to make sure not to screw up the indexes, if there are multiple instances of the element.

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

    Live Demo

    评论
    解决 无用
    打赏 举报
  • ~Onlooker 2013-08-30 19:07

    John Resig posted a good implementation:

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

    If you don’t want to extend a global object, you can do something like the following, instead:

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

    But the main reason I am posting this is to warn users against the alternative implementation suggested in the comments on that page (Dec 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;
    };
    

    It seems to work well at first, but through a painful process I discovered it fails when trying to remove the second to last element in an array. For example, if you have a 10-element array and you try to remove the 9th element with this:

    myArray.remove(8);
    

    You end up with an 8-element array. Don't know why but I confirmed John's original implementation doesn't have this problem.

    评论
    解决 无用
    打赏 举报
  • ~Onlooker 2013-09-19 01:53

    There is no need to use indexOf or splice. However, it performs better if you only want to remove one occurrence of an element.

    Find and move (move):

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

    Use indexOf and splice (indexof):

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

    Use only splice (splice):

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

    Run-times on nodejs for array with 1000 elements (average over 10000 runs):

    indexof is approximately 10x slower than move. Even if improved by removing the call to indexOf in splice it performs much worse than move.

    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
    
    评论
    解决 无用
    打赏 举报
  • 10.24 2013-09-26 00:12
      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[i2] = this[i2 + 1];
                        }
                        this.length = this.length - 1
                        return;
                    }
                }
            }
    
        var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
        recentMovies.removeItem('Superman');
    
    评论
    解决 无用
    打赏 举报
  • lrony* 2013-12-19 19:54

    Edited on 2016 october

    In this code example I use "array.filter(...)" function to remove unwanted items from array, this function doesn't change the original array and creates a new one. If your browser don't support this function (e.g. IE before version 9, or Firefox before version 1.5), consider using the filter polyfill from Mozilla.

    Removing item (ECMA-262 Edition 5 code aka oldstyle JS)

    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 ]
    

    Removing item (ES2015 code)

    let value = 3
    
    let arr = [1, 2, 3, 4, 5, 3]
    
    arr = arr.filter(item => item !== value)
    
    console.log(arr)
    // [ 1, 2, 4, 5 ]
    

    IMPORTANT ES2015 "() => {}" arrow function syntax is not supported in IE at all, Chrome before 45 version, Firefox before 22 version, Safari before 10 version. To use ES2015 syntax in old browsers you can use BabelJS


    Removing multiple items (ES2016 code)

    An additional advantage of this method is that you can remove multiple items

    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 ]
    

    IMPORTANT "array.includes(...)" function is not supported in IE at all, Chrome before 47 version, Firefox before 43 version, Safari before 9 version and Edge before 14 version so here is polyfill from Mozilla

    Removing multiple items (Cutting-edge experimental JavaScript 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 ]
    

    Try it yourself in BabelJS :)

    Reference

    评论
    解决 无用
    打赏 举报
  • 北城已荒凉 2014-01-16 11:27

    I'm pretty new to JavaScript and needed this functionality. I merely wrote this:

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

    Then when I want to use it:

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

    Output - As expected. ["item1", "item1"]

    You may have different needs than I, so you can easily modify it to suit them. I hope this helps someone.

    评论
    解决 无用
    打赏 举报
  • python小菜 2014-01-28 14:44

    Based on all the answers which were mainly correct and taking into account the best practices suggested (especially not using Array.prototype directly), I came up with the below code:

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

    Reviewing the above function, despite the fact that it works fine, I realised there could be some performance improvement. Also using ES6 instead of ES5 is a much better approach. To that end, this is the improved code:

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

    How to use:

    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)
    

    I am currently writing a blog post in which I have benchmarked several solutions for Array without problem and compared the time it takes to run. I will update this answer with the link once I finish that post. Just to let you know, I have compared the above against lodash's without and in case the browser supports Map, it beats lodash! Notice that I am not using Array.prototype.indexOf or Array.prototype.includes as wrapping the exlcudeValues in a Map or Object makes querying faster! (https://jsperf.com/array-without-benchmark-against-lodash)

    评论
    解决 无用
    打赏 举报
  • larry*wei 2014-02-03 15:41

    I know there are a lot of answers already, but many of them seem to over complicate the problem. Here is a simple, recursive way of removing all instances of a key - calls self until index isn't found. Yes, it only works in browsers with indexOf, but it's simple and can be easily polyfilled.

    Stand-alone function

    function removeAll(array, key){
        var index = array.indexOf(key);
    
        if(index === -1) return;
    
        array.splice(index, 1);
        removeAll(array,key);
    }
    

    Prototype method

    Array.prototype.removeAll = function(key){
        var index = this.indexOf(key);
    
        if(index === -1) return;
    
        this.splice(index, 1);
        this.removeAll(key);
    }
    
    评论
    解决 无用
    打赏 举报
  • perhaps? 2014-02-10 22:06

    You can do it easily with filter method:

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

    This removes all elements from the array and also works faster then combination of slice and indexOf

    评论
    解决 无用
    打赏 举报
  • 10.24 2014-05-02 12:00

    Too old to reply, but may it help someone, by providing a predicate instead of a value.

    NOTE: it will update the given array, and return affected rows

    Usage

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

    Definition

    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;
        }
    };
    
    评论
    解决 无用
    打赏 举报
  • MAO-EYE 2014-05-30 09:57

    Underscore.js can be used to solve issues with multiple browsers. It uses in-build browser methods if present. If they are absent like in the case of older Internet Explorer versions it uses its own custom methods.

    A simple example to remove elements from array (from the website):

    _.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
    
    评论
    解决 无用
    打赏 举报
  • ~Onlooker 2015-04-09 10:00

    If you have complex objects in the array you can use filters? In situations where $.inArray or array.splice is not as easy to use. Especially if the objects are perhaps shallow in the array.

    E.g. if you have an object with an Id field and you want the object removed from an array:

    this.array = this.array.filter(function(element, i) {
        return element.id !== idToRemove;
    });
    
    评论
    解决 无用
    打赏 举报
  • 狐狸.fox 2015-08-25 19:34

    You can use lodash _.pull (mutate array), _.pullAt (mutate array) or _.without (does't mutate array),

    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']
    
    评论
    解决 无用
    打赏 举报
  • ?yb? 2016-04-25 10:21

    A more modern, ECMAScript 2015 (formerly known as Harmony or ES 6) approach. Given:

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

    Then:

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

    Yielding:

    [1, 2, 4]
    

    You can use Babel and a polyfill service to ensure this is well supported across browsers.

    评论
    解决 无用
    打赏 举报
  • You can use ES6.

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

    Output :

    ["1", "2", "4", "5", "6"]
    
    评论
    解决 无用
    打赏 举报
  • ~Onlooker 2016-10-07 19:42

    ES6 & without mutation: (October 2016)

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

    Then :

    removeByIndex([33,22,11,44],1) //=> [33,11,44]
    
    评论
    解决 无用
    打赏 举报
  • csdnceshi62 2017-05-10 09:39

    OK, for example you are having the array below:

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

    And we want to delete number 4, you can simply do the below code:

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

    If you reusing this function, you write a reusable function which will be attached to Native array function like below:

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

    But how about if you are having the below array instead with few [5]s in the Array?

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

    We need a loop to check them all, but easier and more efficient way is using built-in JavaScript functions, so we write a function which use filter like below instead:

    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]
    

    Also there are third parties libraries which do help you to do this, like Lodash or Underscore, for more info look at lodash _.pull, _.pullAt or _.without.

    评论
    解决 无用
    打赏 举报
  • 撒拉嘿哟木头 2017-12-26 19:32

    You should never mutate your array your array. As this is against functional programming pattern. What you can do is create a new array without referencing the array you want to change data of using es6 method filter;

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

    Suppose you want to remove 5 from the array you can simply do it like this.

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

    This will give you a new array without the value you wanted to remove. So the result will be

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

    For further understanding you can read the MDN documentation on Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

    评论
    解决 无用
    打赏 举报
  • bug^君 2018-05-04 05:17

    Here are a few ways to remove an item from an array using JavaScript.

    All the method described do not mutate the original array, and instead create a new one.

    If you know the index of an item

    Suppose you have an array, and you want to remove an item in position i.

    One method is to use 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() creates a new array with the indexes it receives. We simply create a new array, from start to the index we want to remove, and concatenate another array from the first position following the one we removed to the end of the array.

    If you know the value

    In this case, one good option is to use filter(), which offers a more declarative approach:

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

    This uses the ES6 arrow functions. You can use the traditional functions to support older browsers:

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

    or you can use Babel and transpile the ES6 code back to ES5 to make it more digestible to old browsers, yet write modern JavaScript in your code.

    Removing multiple items

    What if instead of a single item, you want to remove many items?

    Let's find the simplest solution.

    By index

    You can just create a function and remove items in series:

    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)

    By value

    You can search for inclusion inside the callback function:

    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)

    Avoid mutating the original array

    splice() (not to be confused with slice()) mutates the original array, and should be avoided.

    (originally posted at https://flaviocopes.com/how-to-remove-item-from-array/)

    </div>
    
    评论
    解决 无用
    打赏 举报
  • ?yb? 2018-06-05 14:47

    I have another good solution for removing from an array:

    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"]
    

    https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

    评论
    解决 无用
    打赏 举报
  • 撒拉嘿哟木头 2018-08-07 09:37

    You have 1 to 9 array and you want remove 5 use below code.

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


    If you want to multiple value ex :- 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);

    If you want to remove array value in array ex :- [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);

    includes supported browser is link

    </div>
    
    评论
    解决 无用
    打赏 举报

相关推荐 更多相似问题