Javascript 删除另一个数组中包含的所有元素

我正在寻找一种有效的方法来删除javascript数组中的所有元素（如果它们存在于另一个数组中）

// If I have this array:
var myArray = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];

// and this one:
var toRemove = ['b', 'c', 'g'];

我想对myArray进行操作，使其保持此状态：

['a'，'d'，'e'，'f']

对于jQuery，我使用的是

grep（）

和

inArray（）

，这两种方法都很有效：

myArray = $.grep(myArray, function(value) {
    return $.inArray(value, toRemove) < 0;
});

myArray=$.grep（myArray，函数（值）{
返回$.inArray（值，toRemove）<0；
});

有没有一种纯javascript方法可以在不进行循环和拼接的情况下实现这一点？

使用以下方法：

myArray=myArray.filter（函数（el）{ 返回到移动。索引of（el）<0； } );

---

小的改进，因为对的浏览器支持有所增加：

myArray=myArray.filter（函数（el）{ 返回！删除。包括（el）； } );

---

下一次自适应使用：

myArray=myArray.filter（（el）=>！toRemove.includes（el））；

过滤方法应能实现以下功能：

const myArray = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
const toRemove = ['b', 'c', 'g'];

// ES5 syntax
const filteredArray = myArray.filter(function(x) { 
  return toRemove.indexOf(x) < 0;
});

---

如果您不能使用新的ES5工具，例如

过滤器

，我认为您将陷入两个循环：

for( var i =myArray.length - 1; i>=0; i--){
  for( var j=0; j<toRemove.length; j++){
    if(myArray[i] === toRemove[j]){
      myArray.splice(i, 1);
    }
  }
}

for（var i=myArray.length-1；i>=0；i--）{
对于（var j=0；j，如果您使用的是对象数组。那么下面的代码应该会起到神奇的作用，其中对象属性将是删除重复项的标准

在下面的示例中，通过比较每个项目的名称，删除了重复项

试试这个例子


var myArray=[
{姓名：'deepak'，地点：'bangalore'}，
{姓名：'chirag'，地点：'bangalore'}，
{姓名：'alok'，地点：'berhampur'}，
{姓名：'chandan'，地点：'mumbai'}
];
var toRemove=[
{姓名：'deepak'，地点：'bangalore'}，
{姓名：'alok'，地点：'berhampur'}
];
对于（var i=myArray.length-1；i>=0；i--）{
对于（var j=0；jLodash，也有一个实用函数：
我刚刚实现为：

Array.prototype.exclude = function(list){
        return this.filter(function(el){return list.indexOf(el)<0;})
}

现在在一个班轮风味：


console.log（['a'，'b'，'c'，'d'，'e'，'f'，'g'].filter（x=>！~['b'，'c'，'g'].indexOf（x））
可以更快地计算一个数组中不在另一个数组中的元素：


constmyarray=['a'，'b'，'c'，'d'，'e'，'f'，'g']；
const toRemove=新集合（['b'，'c'，'g']）；
常量差=myArray.filter（x=>！toRemove.has（x））；
console.log（差异）；//[“a”、“d”、“e”、“f”]
您可以从lodash使用

const myArray = [
  {name: 'deepak', place: 'bangalore'}, 
  {name: 'chirag', place: 'bangalore'}, 
  {name: 'alok', place: 'berhampur'}, 
  {name: 'chandan', place: 'mumbai'}
];
const toRemove = [
  {name: 'deepak', place: 'bangalore'},
  {name: 'alok', place: 'berhampur'}
];
const sorted = _.differenceBy(myArray, toRemove, 'name');

此处的示例代码：
删除另一个数组中包含的所有元素的正确方法是通过仅删除元素使源数组成为相同的对象：

Array.prototype.removeContained = function(array) {
  var i, results;
  i = this.length;
  results = [];
  while (i--) {
    if (array.indexOf(this[i]) !== -1) {
      results.push(this.splice(i, 1));
    }
  }
  return results;
};

或同等咖啡脚本：

Array.prototype.removeContained = (array) ->
  i = @length
  @splice i, 1 while i-- when array.indexOf(@[i]) isnt -1

chrome开发工具内部测试：

19:33:04.447 a=1

19:33:06.354 b=2

19:33:07.615 c=3

19:33:09.981 arr=[a，b，c]

19:33:16.460 arr1=arr

19:33:20.317 arr1===arr

19:33:20.331正确

19:33:43.592arr.removeContained（[a，c]）

19:33:52.433arr===arr1

19:33:52.438正确

更新集合时，使用Angular framework是保持指针指向源对象的最佳方法，无需大量观察者和重新加载。
我构建逻辑时不使用任何内置方法，请告知我任何优化或修改。
我在JS编辑器中进行了测试，它运行良好

var myArray = [
            {name: 'deepak', place: 'bangalore'},
            {name: 'alok', place: 'berhampur'},
            {name: 'chirag', place: 'bangalore'},
            {name: 'chandan', place: 'mumbai'},

        ];
        var toRemove = [

            {name: 'chirag', place: 'bangalore'},
            {name: 'deepak', place: 'bangalore'},
            /*{name: 'chandan', place: 'mumbai'},*/
            /*{name: 'alok', place: 'berhampur'},*/


        ];
        var tempArr = [];
        for( var i=0 ; i < myArray.length; i++){
            for( var j=0; j<toRemove.length; j++){
                var toRemoveObj = toRemove[j];
                if(myArray[i] && (myArray[i].name === toRemove[j].name)) {
                    break;
                }else if(myArray[i] && (myArray[i].name !== toRemove[j].name)){
                        var fnd = isExists(tempArr,myArray[i]);
                        if(!fnd){
                            var idx = getIdex(toRemove,myArray[i])
                            if (idx === -1){
                                tempArr.push(myArray[i]);
                            }

                        }

                    }

                }
        }
        function isExists(source,item){
            var isFound = false;
            for( var i=0 ; i < source.length; i++){
                var obj = source[i];
                if(item && obj && obj.name === item.name){
                    isFound = true;
                    break;
                }
            }
            return isFound;
        }
        function getIdex(toRemove,item){
            var idex = -1;
            for( var i=0 ; i < toRemove.length; i++){
                var rObj =toRemove[i];
                if(rObj && item && rObj.name === item.name){
                    idex=i;
                    break;
                }
            }
            return idex;
        }

var myArray=[
{姓名：'deepak'，地点：'bangalore'}，
{姓名：'alok'，地点：'berhampur'}，
{姓名：'chirag'，地点：'bangalore'}，
{姓名：'chandan'，地点：'mumbai'}，
];
var toRemove=[
{姓名：'chirag'，地点：'bangalore'}，
{姓名：'deepak'，地点：'bangalore'}，
/*{姓名：'chandan'，地点：'mumbai'}*/
/*{姓名：'alok'，地点：'berhampur'}*/
];
var tempArr=[]；
对于（var i=0；i对于（var j=0；j最简单的方法是什么


var myArray=['a'，'b'，'c'，'d'，'e'，'f'，'g']；
var toRemove=['b'，'c'，'g']；
var myArray=myArray.filter（（项）=>！toRemove.includes（项））；
log（myArray）
如果您使用的是Typescript，并且希望在单个属性值上进行匹配，则应基于上述内容进行操作

您还可以通过允许非对象匹配和/或多属性值匹配使其更通用

/**
 *
 * @param arr1 The initial array
 * @param arr2 The array to remove
 * @param propertyName the key of the object to match on
 */
function differenceByPropVal<T>(arr1: T[], arr2: T[], propertyName: string): T[] {
  return arr1.filter(
    (a: T): boolean =>
      !arr2.find((b: T): boolean => b[propertyName] === a[propertyName])
  );
}

/**
*
*@param arr1初始数组
*@param arr2要删除的阵列
*@param propertyName要匹配的对象的键
*/
PropVal函数差异（arr1:T[]，arr2:T[]，propertyName:string）：T[]{
返回arr1.1滤波器(
（a:T）：布尔=>
！arr2.find（（b:T）：布尔=>b[propertyName]===a[propertyName]）
);
}
可能重复的可能重复的可能重复的-您不可能在编写问题时对提出的建议给予太多的关注，无论发生什么，它总是会在某种程度上涉及循环。如果您真正希望它“高效”，您不会使用像
.filter（）这样的函数类型方法
。相反，您将使用
进行
循环。如果不需要维护原始顺序，您可以避免使用
.splice（）
。或者有方法使
.splice（））
如果您认为将有许多项要删除，则效率更高。OP：如果您使用的是基本上可以做到这一点的元素。@alecurse将
toRemove（）
的所有元素转换为大写，并将回调从
el
更改为
el.toUpperCase（）
。或更短：
myArray=myArray.filter（el=>！toRemove.includes（el））；
这不是n^2的顺序吗？有没有办法按n的顺序实现这一点？过滤器不是“新的HTML5东西”我应该写“ES5东西”。ES3不提供。扩展本机对象的
原型
，例如
数组
，这不是一个好的做法。这可能会与语言的未来发展产生长期冲突（）你介意为这样一个广受欢迎的问题添加一些解释吗？我花了几个小时寻找这个问题的解决方案，刚刚找到了，真是太棒了
var myArray = [
            {name: 'deepak', place: 'bangalore'},
            {name: 'alok', place: 'berhampur'},
            {name: 'chirag', place: 'bangalore'},
            {name: 'chandan', place: 'mumbai'},

        ];
        var toRemove = [

            {name: 'chirag', place: 'bangalore'},
            {name: 'deepak', place: 'bangalore'},
            /*{name: 'chandan', place: 'mumbai'},*/
            /*{name: 'alok', place: 'berhampur'},*/


        ];
        var tempArr = [];
        for( var i=0 ; i < myArray.length; i++){
            for( var j=0; j<toRemove.length; j++){
                var toRemoveObj = toRemove[j];
                if(myArray[i] && (myArray[i].name === toRemove[j].name)) {
                    break;
                }else if(myArray[i] && (myArray[i].name !== toRemove[j].name)){
                        var fnd = isExists(tempArr,myArray[i]);
                        if(!fnd){
                            var idx = getIdex(toRemove,myArray[i])
                            if (idx === -1){
                                tempArr.push(myArray[i]);
                            }

                        }

                    }

                }
        }
        function isExists(source,item){
            var isFound = false;
            for( var i=0 ; i < source.length; i++){
                var obj = source[i];
                if(item && obj && obj.name === item.name){
                    isFound = true;
                    break;
                }
            }
            return isFound;
        }
        function getIdex(toRemove,item){
            var idex = -1;
            for( var i=0 ; i < toRemove.length; i++){
                var rObj =toRemove[i];
                if(rObj && item && rObj.name === item.name){
                    idex=i;
                    break;
                }
            }
            return idex;
        }

var myArray = [
  {name: 'deepak', place: 'bangalore'}, 
  {name: 'chirag', place: 'bangalore'}, 
  {name: 'alok', place: 'berhampur'}, 
  {name: 'chandan', place: 'mumbai'}
];
var toRemove = [
  {name: 'deepak', place: 'bangalore'},
  {name: 'alok', place: 'berhampur'}
];



myArray = myArray.filter(ar => !toRemove.find(rm => (rm.name === ar.name && ar.place === rm.place) ))

/**
 *
 * @param arr1 The initial array
 * @param arr2 The array to remove
 * @param propertyName the key of the object to match on
 */
function differenceByPropVal<T>(arr1: T[], arr2: T[], propertyName: string): T[] {
  return arr1.filter(
    (a: T): boolean =>
      !arr2.find((b: T): boolean => b[propertyName] === a[propertyName])
  );
}