다른 어레이에 포함된 모든 요소 제거

다른 어레이에 포함된 모든 요소 제거

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

루프나 스플라이싱을 하지 않고 이것을 할 수 있는 순수한 javascript 방법이 있나요?

다음 방법을 사용합니다.

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

---

에 대한 브라우저 지원이 증가했기 때문에 약간의 개선:

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

---

화살표 기능을 사용한 다음 적응:

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

ECMAScript 6 세트를 사용하면 다른 어레이에 없는 요소를 보다 빠르게 계산할 수 있습니다.

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

const difference = myArray.filter( x => !toRemove.has(x) );

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

현재 V8 엔진브라우저가 사용하는 룩업의 복잡도는 O(1)이므로 알고리즘 전체의 시간 복잡도는 O(n)입니다.

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

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어레이가 크기 때문에 이런 종류의 룩업 패턴은 비효율적일 수 있습니다.이 더 입니다.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

가능한 한 간단한 방법은 무엇입니까?

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

원라이너 플레이버:

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

이전 브라우저에서는 작동하지 않을 수 있습니다.

lodash와 _.differenceBy를 사용할 수 있습니다.

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

은 꽤 늦었지만, 하겠습니다.@mojtaba roohi2]와각 다른 에 첫 .[[른른른른른른른른 （ df [ 0 ] ） 。= nfl[2])가 있기 때문에 첫 번째 코드 블록은 작동하지 않습니다.두 물체 모두 비슷해 보이지만 완전히 다른데, 숫자 같은 원시 유형을 사용할 때는 그렇지 않습니다.

let df = [ {'name': 'C' },{'name': 'D' }] 
let nfl = [ {'name': 'A' },{'name': 'B' },{'name': 'C' },{'name': 'D' }] 
let res = nfl.filter(x => df.indexOf(x)<0)
console.log(res)

작업 코드는 다음과 같습니다.

let df = [{'name': 'C' },{'name': 'D' }]
let nfl = [ {'name': 'A' },{'name': 'B' },{'name': 'C' },{'name': 'D' }];
let res = nfl.filter((o1) => !df.some((o2) => o1.name === o2.name));
console.log(res)

Typescript를 사용하여 단일 속성 값을 일치시키려면 위의 Craciun Ciprian의 답변을 기반으로 합니다.

또한 비개체 일치 및/또는 다중 속성 값 일치를 허용하여 이 값을 더 일반화할 수 있습니다.

/**
 *
 * @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])
  );
}

다른 어레이에 포함된 모든 요소를 삭제하는 적절한 방법은 요소만 삭제하여 소스 어레이를 동일한 개체로 만드는 것입니다.

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 개발 도구 내부 테스트:

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 True

19:33:43.592 arr.remove Contained([a,c])
19:33:52.433 arr === arr1
19:33:52.438 True

대량의 워치 및 새로고침 없이 컬렉션을 업데이트할 때 Angular 프레임워크를 사용하는 것이 소스 개체에 대한 포인터를 유지하는 가장 좋은 방법입니다.

임베디드 방식을 사용하지 않고 로직을 구축하기 때문에 최적화나 수정이 있으면 알려주세요.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;
        }

//Using the new ES6 Syntax

    console.log(["a", "b", "c", "d", "e", "f", "g"].filter(el => !["b", "c", "g"].includes(el)));

    // OR

    // Main array
    let myArray = ["a", "b", "c", "d", "e", "f", "g"];

    // Array to remove
    const toRemove = ["b", "c", "g"];

    const diff = () => (myArray = myArray.filter((el) => !toRemove.includes(el)));
  console.log(diff()); // [ 'a', 'd', 'e', 'f' ]

    // OR

    const diff2 = () => {
      return myArray = myArray.filter((el) => !toRemove.includes(el));
    };
    console.log(diff2()); // [ 'a', 'd', 'e', 'f' ]

고성능 불변의 솔루션

자바스크립트

const excludeFromArr = (arr, exclude) => {
  const excludeMap = exclude.reduce((all, item) => ({ ...all, [item]: true }), {});
  return arr.filter((item) => !excludeMap?.[item]);
};

타이프스크립트:

const excludeFromArr = (arr: string[], exclude: string[]): string[] => {
  const excludeMap = exclude.reduce<Record<string, boolean>>((all, item) => ({ ...all, [item]: true }), {});
  return arr.filter((item) => !excludeMap?.[item]);
};

const first = [
  { key: "Value #1", key1: "Value #11" },
  { key: "Value #2", key1: "Value #12" },
  { key: "Value #3", key1: "Value #13" },
];

const second = [{ key: "Value #1", key1: "Value #11" }];

const toRemove = second.map((x) => Object.values(x).join("."));

const remainingData = first.filter( (x) => !toRemove.includes(Object.values(x).join(".")) );

console.log(JSON.stringify(remainingData, null, 2));

언급URL : https://stackoverflow.com/questions/19957348/remove-all-elements-contained-in-another-array