Javascript/jQuery의 배열에서 여러 요소 제거

Javascript/jQuery의 배열에서 여러 요소 제거

저는 두 개의 배열을 가지고 있습니다.첫 번째 배열에는 일부 값이 포함되고 두 번째 배열에는 첫 번째 배열에서 제거해야 하는 값의 인덱스가 포함됩니다.예:

var valuesArr = new Array("v1","v2","v3","v4","v5");   
var removeValFromIndex = new Array(0,2,4);

인덱스 인스에있값제합니다고에 있는 값을 .0,2,4valuesArr는 원주민인 줄 요.splice방법이 도움이 될 수도 있기 때문에 저는 다음을 생각해냈습니다.

$.each(removeValFromIndex,function(index,value){
    valuesArr.splice(value,1);
});

하지만 효과가 없었어요 왜냐하면 각각의 뒤에splice의 valuesArr을 두배열에 하면 이 할 수 할 수 .임시 배열을 사용하고 모든 값을 두 번째 배열에 복사하면 이 문제를 해결할 수 있지만 배열에서 값을 제거하는 여러 인덱스를 전달할 수 있는 네이티브 방법이 있는지 궁금합니다.

저는 jQuery 솔루션을 선호합니다.(사용할 수 있을지 잘 모르겠습니다.grep

언제나 오래된 평원이 있습니다.for슬롯:슬라이드:

var valuesArr = ["v1","v2","v3","v4","v5"],
    removeValFromIndex = [0,2,4];    

for (var i = removeValFromIndex.length -1; i >= 0; i--)
   valuesArr.splice(removeValFromIndex[i],1);

를 하세요.removeValFromIndex역순으로 하면 됩니다..splice()아직 확인되지 않은 항목의 색인을 흐트러뜨리지 않고 사용할 수 있습니다.

위에서 나는 두 배열을 선언하기 위해 대괄호가 있는 배열-문자 구문을 사용했습니다.다음과 같은 이유로 권장되는 구문입니다.new Array()사용은 전달하는 매개 변수의 수에 따라 반응이 다르다는 점에서 잠재적으로 혼동을 일으킬 수 있습니다.

편집: 인덱스 배열이 특정 순서가 아닐 수도 있다는 다른 답변에 대한 귀하의 의견을 방금 보았습니다.이 경우 시작하기 전에 내림차순으로 정렬합니다.

removeValFromIndex.sort(function(a,b){ return b - a; });

해서 / 그고무든반따서라요세하해복엇이리▁/ /$.each()당신이 좋아하는 방법 등.

Array.prototype을 사용하는 것이 좋습니다.여과기

var valuesArr = ["v1","v2","v3","v4","v5"];
var removeValFrom = [0, 2, 4];
valuesArr = valuesArr.filter(function(value, index) {
     return removeValFrom.indexOf(index) == -1;
})

다음은 lodash/언더스코어를 사용하지 않을 때 사용하는 것입니다.

while(IndexesToBeRemoved.length) {
    elements.splice(IndexesToBeRemoved.pop(), 1);
}

것은 아니다.in-place하지만 다음을 사용하여 수행할 수 있습니다.grep그리고.inArray의 jQuery.

var arr = $.grep(valuesArr, function(n, i) {
    return $.inArray(i, removeValFromIndex) ==-1;
});

alert(arr);//arr contains V2, V4

이 바이올린을 확인합니다.

필터 및 세트를 사용한 간단하고 효율적인(선형 복잡성) 솔루션:

const valuesArr = ['v1', 'v2', 'v3', 'v4', 'v5'];   
const removeValFromIndex = [0, 2, 4];

const indexSet = new Set(removeValFromIndex);

const arrayWithValuesRemoved = valuesArr.filter((value, i) => !indexSet.has(i));

console.log(arrayWithValuesRemoved);

큰 작업검색 설정 작업)입니다.has예를 들어, nevace의 답변보다 빠른 일정한 시간이 소요됩니다.

이 기능은 개체 배열에서 삭제할 때도 사용할 수 있습니다.

var array = [ 
    { id: 1, name: 'bob', faveColor: 'blue' }, 
    { id: 2, name: 'jane', faveColor: 'red' }, 
    { id: 3, name: 'sam', faveColor: 'blue' }
];

// remove people that like blue

array.filter(x => x.faveColor === 'blue').forEach(x => array.splice(array.indexOf(x), 1));

이것을 쓰는 더 짧고 효율적인 방법이 있을 수 있지만 이것은 효과가 있습니다.

로 답변을 올리는 것이 필요하다고 느낍니다.O(n)시간 :).스플라이스 솔루션의 문제는 기본적인 어레이 구현이 문자 그대로 어레이이기 때문에 각각splice 시간은 통필니다합입니다.O(n)시간. 이 동작을 이용하기 위한 예제를 설정할 때 가장 두드러집니다.

var n = 100
var xs = []
for(var i=0; i<n;i++)
  xs.push(i)
var is = []
for(var i=n/2-1; i>=0;i--)
  is.push(i)

됩니다.n/2요소, 우리는 가지고 있습니다.(n/2)^22차 복사 작업의 합계입니다.

용액:is과 같이 됩니다.

for(var i=0; i<is.length; i++)
  xs.splice(is[i], 1)

솔루션을 않습니다.O(n)log(n)). 그것이 ).mask는 속도에 대해 부울값으로 반전됨):

var mask = new Array(xs.length)
for(var i=is.length - 1; i>=0; i--)
  mask[is[i]] = true
var offset = 0
for(var i=0; i<xs.length; i++){
  if(mask[i] === undefined){
    xs[offset] = xs[i]
    offset++
  }
}
xs.length = offset

저는 이것을 jsperf.com 에서 실행했고 심지어는n=100스플라이스 방법은 완전히 90% 느립니다. 큰 규모의경의 n이 차이는 훨씬 더 클 것입니다.

저는 이것이 가장 우아한 해결책이라고 생각합니다.

const oldArray = [1, 2, 3, 4, 5]
const removeItems = [1, 3, 5]

const newArray = oldArray.filter((value) => {
    return !removeItems.includes(value)
})

console.log(newArray)

출력:

[2, 4]

또는 더 짧습니다.

const newArray = oldArray.filter(v => !removeItems.includes(v))

function filtermethod(element, index, array) {  
    return removeValFromIndex.find(index)
}  
var result = valuesArr.filter(filtermethod);

MDN 참조는 여기에 있습니다.

뒤로 할 수 에 순수JS서는뒤수루있로으므할프로,splice()루프에서 다음 요소의 인덱스를 엉망으로 만들지 않습니다.

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

ES5를 사용한 간단한 솔루션.많은 사람들이 더 이상 jQuery 등에 의존하기를 원하지 않기 때문에 요즘 대부분의 애플리케이션에 더 적합한 것으로 보입니다.

제거할 인덱스가 오름차순으로 정렬되는 경우:

var valuesArr = ["v1", "v2", "v3", "v4", "v5"];   
var removeValFromIndex = [0, 2, 4]; // ascending

removeValFromIndex.reverse().forEach(function(index) {
  valuesArr.splice(index, 1);
});

제거할 인덱스가 정렬되지 않은 경우:

var valuesArr = ["v1", "v2", "v3", "v4", "v5"];   
var removeValFromIndex = [2, 4, 0];  // unsorted

removeValFromIndex.sort(function(a, b) { return b - a; }).forEach(function(index) {
  valuesArr.splice(index, 1);
});

Quick ES6 하나 라이너:

const valuesArr = new Array("v1","v2","v3","v4","v5");   
const removeValFromIndex = new Array(0,2,4);

const arrayWithValuesRemoved = valuesArr.filter((value, i) => removeValFromIndex.includes(i))

언더스코어.js를 사용하는 경우 다음을 사용할 수 있습니다._.filter()당신의 문제를 해결하기 위해.

var valuesArr = new Array("v1","v2","v3","v4","v5");
var removeValFromIndex = new Array(0,2,4);
var filteredArr = _.filter(valuesArr, function(item, index){
                  return !_.contains(removeValFromIndex, index);
                });

또인덱스대항신목사항제여용목거는다경수있사니습다용할음을우한려하을하록을목▁use▁addition▁simply▁using다▁you있니습▁can수▁if▁items,▁instead또한▁you▁of▁a▁list,ally▁remove▁to사용▁trying를 사용하면 됩니다._.without() 예:

var valuesArr = new Array("v1","v2","v3","v4","v5");
var filteredArr = _.without(valuesArr, "V1", "V3");

지금이다filteredArr야 .["V2", "V4", "V5"]

코드를 변경하여 수정할 수 있습니다.removeValFromIndex와 함께removeValFromIndex.reverse()이 오름차순을하도록 보장되지 대신 해배열오름순사보대않경신우는지를 할 수 .removeValFromIndex.sort(function(a, b) { return b - a }).

한 가지 가능성이 있습니다.

valuesArr = removeValFromIndex.reduceRight(function (arr, it) {
    arr.splice(it, 1);
    return arr;
}, valuesArr.sort(function (a, b) { return b - a }));

jsFiddle 예제

MDN on Array.prototype.reduceRight

필터 + 인덱스 Of(IE9+):

function removeMany(array, indexes) {
  return array.filter(function(_, idx) {
    return indexes.indexOf(idx) === -1;
  });
}); 

또는 ES6 필터 + 찾기(Edge+):

function removeMany(array, indexes = []) {
  return array.filter((_, idx) => indexes.indexOf(idx) === -1)
}

여기에 간단한 것이 있습니다.

function removeFromArray(arr, toRemove){
    return arr.filter(item => toRemove.indexOf(item) === -1)
}

const arr1 = [1, 2, 3, 4, 5, 6, 7]
const arr2 = removeFromArray(arr1, [2, 4, 6]) // [1,3,5,7]

사용해 보세요.

var valuesArr = new Array("v1", "v2", "v3", "v4", "v5");
console.info("Before valuesArr = " + valuesArr);
var removeValFromIndex = new Array(0, 2, 4);
valuesArr = valuesArr.filter((val, index) => {
  return !removeValFromIndex.includes(index);
})
console.info("After valuesArr = " + valuesArr);

Apply가 당신이 찾고 있는 것일 수 있습니다.
어쩌면 이런 것이 효과가 있을까요?

Array.prototype.splice.apply(valuesArray, removeValFromIndexes );

var valuesArr = new Array("v1","v2","v3","v4","v5");   
var removeValFromIndex = new Array(0,2,4);

console.log(valuesArr)
let arr2 = [];

for (let i = 0; i < valuesArr.length; i++){
  if (    //could also just imput this below instead of index value
    valuesArr[i] !== valuesArr[0] && // "v1" <--
    valuesArr[i] !== valuesArr[2] && // "v3" <--
    valuesArr[i] !== valuesArr[4]    // "v5" <--
  ){
    arr2.push(valuesArr[i]);
  }
}

console.log(arr2);

효과가 있습니다.그러나 이 과정에서 새 배열을 만듭니다.이것이 당신이 원하는 것인지 아닌지는 확실하지 않지만, 기술적으로 그것은 당신이 원하는 값만 포함하는 배열이 될 것입니다.

기능 js 라이리사볼있수습니다해용을능브러기▁(lod▁functions▁you▁lod다)을 사용해 볼 수 있습니다._.forEach(),_.remove() 행을 이 테이블에서 여러 행을 제거하기 위해 이 기술을 사용했습니다.

let valuesArr = [
    {id: 1, name: "dog"}, 
    {id: 2, name: "cat"}, 
    {id: 3, name: "rat"}, 
    {id: 4, name: "bat"},
    {id: 5, name: "pig"},
]; 
let removeValFromIndex = [
    {id: 2, name: "cat"}, 
    {id: 5, name: "pig"},
]; 
_.forEach(removeValFromIndex, (indi) => {
    _.remove(valuesArr, (item) => {
        return item.id === indi.id;
    });
})
console.log(valuesArr)
/*[
    {id: 1, name: "dog"},  
    {id: 3, name: "rat"}, 
    {id: 4, name: "bat"},
];*/ 

복제하는 것을 잊지 마십시오._.clone(valuesArr)또는[...valuesArr]하기 전에 다음과 같이 하십시오.

이는 @nnnnnnn의 답변을 수정하는 것에 가깝지만, 그렇지 않으면 추가 행이 삭제되기 때문에 잠재적인 중복 인덱스도 제거할 것입니다.

function arrayUnique(arr) {
    return arr.filter((value, index, array) => array.indexOf(value) === index);
}

function arrayDeleteMulti(arr, idxSet) {

    idxSet = arrayUnique(idxSet).sort(function(a,b){ return a-b; });
    
    for (var i = idxSet.length -1; i >= 0; i--)
        arr.splice(idxSet[i],1);

    return arr
}

그래서 이 시험에서

var arr = [`v0`, `v1`, `v2`, `v3`, `v4`, `v5`];
console.log(arrayDeleteMulti(arr, [4,4,4,0,2]))

우리는 이해합니다

[ "v1", "v3", "v5" ]

또 다른 방법은 감속기를 생성하여 선택하지 않은 값을 반환하는 인덱스로 유효성을 검사한 다음 순서를 지정하는 것입니다.

 var valuesArr = new Array("v1", "v2", "v3", "v4", "v5");
  var r = new Array(0, 2, 4);

  const data = valuesArr
    .reduce((p, c, i) => (!r.includes(i) ? [...p, c] : p), [])
    .sort((a, b) => b - a);

  console.log(data);

▁and▁try를 사용해 볼 수도 .delete array[index]되는 것이 이 이게하면요소완전제히거않지되값설다다정니로 설정됩니다.undefined.

removeValFromIndex.forEach(function(toRemoveIndex){
    valuesArr.splice(toRemoveIndex,1);
});

다중 항목 또는 고유 항목의 경우:

Array.prototype을 사용하는 것이 좋습니다.여과기

인덱스를 이미 알고 있는 경우 indexOf를 사용하지 마십시오!:

var valuesArr = ["v1","v2","v3","v4","v5"];
var removeValFrom = [0, 2, 4];

valuesArr = valuesArr.filter(function(value, index) {
     return removeValFrom.indexOf(index) == -1;
}); // BIG O(N*m) where N is length of valuesArr and m is length removeValFrom

수행:

해쉬와 함께...Array.prototype.map 사용

  var valuesArr = ["v1","v2","v3","v4","v5"];
  var removeValFrom = {};
  ([0, 2, 4]).map(x=>removeValFrom[x]=1); //bild the hash.
  valuesArr = valuesArr.filter(function(value, index) {
      return removeValFrom[index] == 1;
  }); // BIG O(N) where N is valuesArr;

▁a▁를 구성할 수 있습니다.Set배열에서 배열을 만든 다음 집합에서 배열을 생성합니다.

const array = [1, 1, 2, 3, 5, 5, 1];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // Result: [1, 2, 3, 5]

언급URL : https://stackoverflow.com/questions/9425009/remove-multiple-elements-from-array-in-javascript-jquery