删除某一要素或随后的元素,Array.spolice ()方法运作良好。

组合法通过删除或替换现有元素和(或)添加新元素来改变数组的内容,并返回被删除的项目。

语法: 数组. spice( index, deleteCount, items 1,...,..., itemsX)

给index休息辩论是强制性的,休息辩论是任择的。

例如:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

注: Array.spolice ()如果您知道要删除的元素的索引, 可以使用该方法。 但我们可能还会有以下几个例子:

1. 如果您想要删除仅最后一个元素, 您可以使用Array.pop ()

2. 如果您想要删除仅第一个元素, 您可以使用矩阵. trip ()

3. 如果您只知道元素, 而不知道元素的位置(或索引), 并且想要删除所有匹配元素Array. filter ()方法 :

   let arr = [1, 2, 1, 3, 4, 1, 5, 1];
   
   let newArr = arr.filter(function(val){
       return val !== 1;
   });
   //newArr => [2, 3, 4, 5]
   

   或者通过使用复数()方法作为:

   let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
       for (let i = 0; i < arr.length-1; i++) {
          if ( arr[i] === 11) {
            arr.splice(i, 1);
          }
       }
       console.log(arr);
       // [1, 2, 3, 4, 5, 6]
   

   或者假设我们想要删除del从数组arr:

   let arr = [1, 2, 3, 4, 5, 6];
   let del = 4;
   if (arr.indexOf(4) >= 0) {
       arr.splice(arr.indexOf(4), 1)
   }
   

   或

   let del = 4;
   for(var i = arr.length - 1; i >= 0; i--) {
       if(arr[i] === del) {
          arr.splice(i, 1);
       }
   }
   

4. 如果您只知道元素, 而不知道元素的位置( 或索引) , 并且想要使用 复数 () 方法删除第一个匹配元素 :

   let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
   
   for (let i = 0; i < arr.length-1; i++) {
     if ( arr[i] === 11) {
       arr.splice(i, 1);
       break;
     }
   }
   console.log(arr);
   // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
   

这取决于你是否想保持一个空位。

如果你(如果)do do do 做想要一个空位 :

array[index] = undefined;

如果你(如果)不要想要一个空位 :

//To keep the original:
//oldArray = [...array];

//This modifies the array.
array.splice(index, 1);

如果您需要该项的值, 您可以保存返回的数组元素 :

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

如果您要在数组两端的两端删除,可以使用array.pop()最后一个或最后一个array.shift()对第一个项目(两者都返回项目的价值) 。

如果你不知道项目的索引,你可以使用array.indexOf(item)以获得(在if()获得一个或一个while()以获得全部)))。array.indexOf(item)返回索引或-1尚未找到 。

Vanilla JavaScript(ES5.1) - (ES5.1) -已经到位版本版本

浏览器支持 :因特网探索者 9或以后(或以后(详细浏览器支持)

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

Vanilla JavaScript(ES5.1) - (ES5.1) -不可变版本版本

浏览器支持: 与原版的香草 JavaScript 相同

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

香草ES6 -不可变版本版本

浏览器支持: Chrome 46, 边缘 12, Firefox 16, Opera 37, Safari 8 ()详细浏览器支持)

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}

检查一下这个代码 每个代码都有效主浏览器.

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

var array = [1,3,5,6,5,9,5,3,55]
var res = remove_item(array,5);
console.log(res)

通过我的解决方案, 您可以在纯 JavaScript 的阵列中删除一个或多个项。 不需要另外的 JavaScript 库 。

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]

我喜欢这个单行道:

arr.includes(val) && arr.splice(arr.indexOf(val), 1)

• 欧 6(无 (没有) (没有) (没有) (没有)Internet 探索器支助))
• 在原地清除。
• 快速: 不重复重复重复或重复 。
• 支持删除这些值null或undefined

作为原型

// remove by value. return true if value found and removed, false otherwise
Array.prototype.remove = function(val)
{
    return this.includes(val) && !!this.splice(this.indexOf(val), 1);
}

(是的,我读了所有其他的答案 却找不到一个结合的答案)includes和splice在同一行中。 )