Xóa tất cả các thành phần có trong một mảng khác

Tôi đang tìm kiếm một cách hiệu quả để loại bỏ tất cả các yếu tố khỏi một mảng javascript nếu chúng có mặt trong một mảng khác.

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

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

Tôi muốn hoạt động trên myArray để nó ở trạng thái này: ['a', 'd', 'e', 'f']

Với jQuery, tôi đang sử dụng grep()và inArray()hoạt động tốt:

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

Có một cách javascript thuần túy để làm điều này mà không cần lặp và nối?

Sử dụng Array.filter()phương pháp:

myArray = myArray.filter( function( el ) {
  return toRemove.indexOf( el ) < 0;
} );

Cải thiện nhỏ, khi hỗ trợ trình duyệt Array.includes()đã tăng:

myArray = myArray.filter( function( el ) {
  return !toRemove.includes( el );
} );

Thích ứng tiếp theo bằng cách sử dụng các chức năng mũi tên :

myArray = myArray.filter( ( el ) => !toRemove.includes( el ) );

Các filterphương pháp nên làm các trick:

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

Nếu toRemovemảng của bạn lớn, kiểu mẫu tra cứu này có thể không hiệu quả. Nó sẽ được thực hiện nhiều hơn để tạo ra một bản đồ để tìm kiếm O(1)hơn là O(n).

const toRemoveMap = toRemove.reduce(
  function(memo, item) {
    memo[item] = memo[item] || true;
    return memo;
  },
  {} // initialize an empty object
);

const filteredArray = myArray.filter(function (x) {
  return toRemoveMap[x];
});

// or, if you want to use ES6-style arrow syntax:
const toRemoveMap = toRemove.reduce((memo, item) => ({
  ...memo,
  [item]: true
}), {});

const filteredArray = myArray.filter(x => toRemoveMap[x]);

Nếu bạn đang sử dụng một mảng các đối tượng. Sau đó, mã dưới đây sẽ làm điều kỳ diệu, trong đó một thuộc tính đối tượng sẽ là tiêu chí để loại bỏ các mục trùng lặp.

Trong ví dụ dưới đây, các bản sao đã bị xóa so sánh tên của từng mục.

Hãy thử ví dụ này. http://jsfiddle.net/deepak7641/zLj133rh/

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

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

alert(JSON.stringify(myArray));

Lodash cũng có chức năng tiện ích cho việc này: https://lodash.com/docs#difference

Bộ ECMAScript 6 có thể được sử dụng để tính toán các yếu tố khác nhau của hai mảng:

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

const difference = new Set([...myArray].filter((x) => !toRemove.has(x)));

console.log(Array.from(difference)); // ["a", "d", "e", "f"]

Tôi chỉ thực hiện như:

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

Sử dụng như là:

myArray.exclude(toRemove);

Nếu bạn không thể sử dụng công cụ ES5 mới, filtertôi nghĩ bạn bị mắc kẹt với hai vòng:

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

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

Bây giờ trong hương vị một lớp lót:

console.log(['a', 'b', 'c', 'd', 'e', 'f', 'g'].filter(x => !~['b', 'c', 'g'].indexOf(x)))

Có thể không hoạt động trên các trình duyệt cũ.

Bạn có thể sử dụng _.differenceBy từ 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');

Mã ví dụ ở đây: CodePen

Làm thế nào về đơn giản nhất có thể:

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

var myArray = myArray.filter((item) => !toRemove.includes(item));
console.log(myArray)

Cách thích hợp để loại bỏ tất cả các phần tử có trong một mảng khác là tạo cho mảng nguồn cùng một đối tượng bằng cách chỉ xóa các phần tử:

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

Hoặc tương đương với CoffeeScript:

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

Kiểm tra bên trong các công cụ phát triển chrome:

19: 33: 04.447 a = 1
19: 33: 06.354 b = 2
19: 33: 07.615 c = 3
19: 33: 09.981 mảng = [a, b, c]
19: 33:

19: 33: 20.317 mảng1 === mảng
19: 33: 20.331 đúng

19: 33: 43.592 mảng.removeContained ([a, c])
19: 33: 52.433 mảng === mảng1
19: 33: 52.438 đúng

Sử dụng khung Angular là cách tốt nhất để giữ con trỏ tới đối tượng nguồn khi bạn cập nhật các bộ sưu tập mà không cần số lượng lớn người theo dõi và tải lại.

Tôi xây dựng logic mà không sử dụng bất kỳ phương thức tích hợp nào, vui lòng cho tôi biết bất kỳ tối ưu hóa hoặc sửa đổi nào. Tôi đã thử nghiệm trong trình soạn thảo JS, nó hoạt động tốt.

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