ลบองค์ประกอบทั้งหมดที่มีอยู่ในอาร์เรย์อื่น

ฉันกำลังมองหาวิธีที่มีประสิทธิภาพในการลบองค์ประกอบทั้งหมดออกจากอาร์เรย์ 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;
});

มีวิธีจาวาสคริปต์ที่บริสุทธิ์ในการทำเช่นนี้โดยไม่ต้องวนและต่อ?

ใช้Array.filter()วิธีการ:

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

การปรับปรุงเล็กน้อยเนื่องจากการสนับสนุนเบราว์เซอร์สำหรับArray.includes()เพิ่มขึ้น:

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

การปรับตัวครั้งต่อไปโดยใช้ฟังก์ชั่นลูกศร :

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

filterวิธีควรทำเคล็ดลับ:

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

หากtoRemoveอาร์เรย์ของคุณมีขนาดใหญ่รูปแบบการค้นหาเช่นนี้อาจไม่มีประสิทธิภาพ มันจะ performant มากขึ้นเพื่อสร้างแผนที่เพื่อการค้นหาที่มีมากกว่าO(1)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]);

หากคุณกำลังใช้อาร์เรย์ของวัตถุ จากนั้นโค้ดด้านล่างควรใช้เวทมนตร์ซึ่งคุณสมบัติของวัตถุจะเป็นเกณฑ์ในการลบรายการที่ซ้ำกัน

ในตัวอย่างด้านล่างรายการที่ซ้ำกันจะถูกลบออกเปรียบเทียบชื่อของแต่ละรายการ

ลองตัวอย่างนี้ 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 มีฟังก์ชันยูทิลิตี้สำหรับสิ่งนี้เช่นกัน: https://lodash.com/docs#difference

ECMAScript 6 ชุดสามารถใช้สำหรับการคำนวณองค์ประกอบต่าง ๆ ของสองอาร์เรย์:

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

ฉันเพิ่งใช้งานเป็น:

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

ใช้เป็น:

myArray.exclude(toRemove);

หากคุณไม่สามารถใช้สิ่ง ES5 ใหม่เช่นfilterฉันคิดว่าคุณติดอยู่กับสองลูป:

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

ตอนนี้มีรสชาติแบบหนึ่งซับ:

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

อาจไม่ทำงานกับเบราว์เซอร์รุ่นเก่า

คุณสามารถใช้_.differenceByจาก 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');

โค้ดตัวอย่างที่นี่: CodePen

วิธีที่ง่ายที่สุดที่เป็นไปได้:

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)

วิธีที่เหมาะสมในการลบองค์ประกอบทั้งหมดที่มีอยู่ในอาเรย์อื่นคือการทำให้ออบเจ็กต์อาร์เรย์เหมือนกันโดยการลบองค์ประกอบเท่านั้น:

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

หรือเทียบเท่า CoffeeScript:

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

การทดสอบเครื่องมือ Chrome dev:

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.592 arr.removeContained ([a, c])
19: 33: 52.433 arr === 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;
        }