于2016年10月16日编辑

如果浏览器不支持 JavaScript 标准函数, 请按标准 JavaScript 函数执行, 如果您的浏览器不支持这些函数 - 使用多填

在此代码示例中, 我使用数组. filter (...) 函数从数组中删除不想要的项目 。 此函数不会改变原始数组, 创建一个新的数组 。 如果您的浏览器不支持此函数( 例如, 版本 9 之前的 Internet Explorer 或版本 1. 5 之前的 Firefox) , 请考虑以 Core- js 组合填充 。

删除项目( ECMA-262 版5 代码 AKA 旧风格 JavaScript)

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 ]

IMPORTANT ECMAScript 6 () 箭头函数语法在互联网探索器、 45 版本前的Chrome、 22 版本前的Firefox 和 10 版本前的Safari 中完全不支持。 要在旧浏览器中使用 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 ]

IMPORANT 矩阵。 包含(...) 函数在 Internet Explorer 中根本不支持, Chrome 版本47, Firefox 版本43, Safari 版本9, 版本14 之前的边缘中根本不支持, 但是您可以使用核心js 进行多种填充 。

删除多个项目( 未来, 也许)

如果这个“ 丁字语法” 提案被接受, 你就可以做到:

// 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 :)

参考参考参考参考参考文献

包括职能构成

如果元素存在多个实例,您可以进行后回循环,以确保不破坏索引。

var myElement = "chocolate"; var my Array = [“cocolate ”、“potart”、“potart”、“potart”、“potart”、“cocolate”、“potart”、“potart”、“cococolate ”]; / * 重要代码 * / 用于 (var i = my Array. lary - 1; i & 0; i-) {如果 (my Array [i] = my Element) my Array.spolice (i, 1);}控制台.log (my Array); {如果 (my Array [i] = my Element) my Array.splice (i, 1);} 控制台(my Array);

我也碰到了这样的情况:我不得不从阵列中移除一个元素。 indexof没有在互联网探索器中工作, 因此我分享我的工作 jQuery.inArray () 解决方案 :

var index = jQuery.inArray(val, arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}

我不知道你如何期待阵列.remove( int) 的行为。 我可以想到三种可能性, 你可能会想要。

要删除索引 i 中的数组元素:

array.splice(i, 1);

如果您想要从数组中删除带有数值数的每个元素 :

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

如果您只想在索引 I 中使元素不再存在, 但是您不想让其它元素的索引改变 :

delete array[i];

根据所有主要正确的答复并考虑到建议的最佳做法(特别是不直接使用Array.prototype),我提出了以下代码:

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

在审查上述功能时,尽管运作良好,但我意识到业绩可能有所改进。 使用ES6而不是ES5是一种更好的方法。

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)

我目前正在写博客文章, 我已将数个阵列解决方案设定为基准, 没有问题, 并比较运行时间 。 一旦我完成该文章, 我将更新此答案, 并使用链接 。 只需告知您, 我将以上内容与没有浏览器支持地图的 Lodash 比较, 以防浏览器支持地图, 它比 Lodash 还要快! 注意我没有使用 Array. prototype. indexof 或 Array. prototype 。 包含在地图或天体中将ExcludeValue 包装成快的查询 !

对于任何想要复制一种方法的人,如果想复制一种方法,返回一个重复删除数字或字符串的新阵列,则从现有答案中归纳如下:

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.push(element);
  }

  return dupFree;
}