it-gundan.com

JavaScript의 배열에서 특정 요소를 제거하려면 어떻게합니까?

Numbers 배열을 가지고 있는데, 요소를 추가하기 위해 .Push() 메서드를 사용하고 있습니다.

배열에서 특정 요소를 제거하는 간단한 방법이 있습니까? array.remove(number);과 같은 것입니다.

core JavaScript - no frameworks를 사용할 수 있습니다.

7085
Walker

제거 할 배열 요소의 index을 찾은 다음 splice 를 사용하여 해당 인덱스를 제거합니다.

Splice () 메서드는 기존 요소를 제거하고 새 요소를 추가하여 배열의 내용을 변경합니다.

var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

splice의 두 번째 매개 변수는 제거 할 요소의 수입니다. splice은 배열의 위치를 ​​수정하고 제거 된 요소가 들어있는 새로운 배열을 반환합니다.

9908
Tom Wadley

array.remove(int)이 (가) 어떻게 행동 할 것으로 기대하는지 모르겠습니다. 내가 생각할 수있는 세 가지 가능성이 있습니다.

인덱스 i에서 배열 요소를 제거하려면 :

array.splice(i, 1);

배열에서 number 값을 가진 모든 요소를 ​​제거하려면 다음을 수행하십시오.

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

i의 요소를 더 이상 존재시키지 않고 다른 요소의 인덱스를 변경하지 않으려는 경우 :

delete array[i];
1011
Peter Olson

10 월 2016 일에 편집 됨

  • 간단하고 직관적이며 명시 적으로 수행하십시오 ( https://en.wikipedia.org/wiki/Occam%27s_razor )
  • 변경 불가능 (원래 배열은 변경되지 않음)
  • 브라우저가 표준 JS 함수를 지원하지 않는 경우 표준 JS 함수로 수행 - polyfill 사용

이 코드 예제에서는 필자가 "array.filter (...)" 함수를 사용하여 배열에서 원하지 않는 항목을 제거하면이 함수는 원래 배열을 변경하지 않고 새 배열을 만듭니다. 브라우저가이 기능 (예 : 버전 9 이전의 IE 또는 버전 1.5 이전의 Firefox)을 지원하지 않는 경우 Mozilla의 polyfill 필터 사용을 고려하십시오.

항목 삭제 (ECMA-262 Edition 5 코드, 일명 oldstyle JS)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) { 
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

항목 제거 (ES2015 코드)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

중요 ES2015 "() => {}"화살표 기능 구문은 IE에서 전혀 지원되지 않습니다. 크롬 45 이전 버전, Firefox 22 이전 버전, Safari 10 이전 버전. 오래된 브라우저에서 ES2015 구문을 사용하려면 BabelJS


여러 항목 제거 (ES2016 코드)

이 방법의 또 다른 이점은 여러 항목을 제거 할 수 있다는 것입니다

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

중요 "array.includes (...)"함수는 IE에서 전혀 지원되지 않습니다. 크롬 47 이전 버전, 파이어 폭스 43 이전 버전, 사파리 9 이전 버전 및 에지 14 이전 버전 여기는 Mozilla의 polyfill입니다

여러 항목 제거 (최첨단 실험용 JavaScript ES2018?)

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

BabelJS에서 직접 해보기) :

참고

831
Ujeenator

빈 자리를 유지할 것인지의 여부에 달려 있습니다.

빈 슬롯을 원할 경우 삭제가 좋습니다.

delete array[ index ];

그렇지 않다면 splice method를 사용해야합니다 :

array.splice( index, 1 );

그리고 그 아이템의 가치가 필요하다면 반환 된 배열의 요소를 저장할 수 있습니다 :

var value = array.splice( index, 1 )[0];

어떤 순서로 처리하기를 원한다면 마지막 array.pop()을 사용하거나 첫 번째 array.shift()을 사용할 수 있습니다 (둘 다 항목의 값도 반환합니다).

아이템의 인덱스를 모를 경우 array.indexOf( item )을 사용하여 if()을 사용하여 하나의 아이템을 얻거나 while()을 사용하여 아이템을 얻을 수 있습니다. array.indexOf( item )은 인덱스를 반환하거나 발견되지 않으면 -1을 반환합니다.

383
xavierm02

친구가 Internet Explorer 8 에 문제가있어서 그가 한 일을 보여주었습니다. 나는 그에게 그것이 틀렸다고 말했고, 그는 그가 여기에 답을 얻었다고 나에게 말했다. 현재 최상위 답변은 모든 브라우저 (예 : Internet Explorer 8)에서 작동하지 않으며 항목의 첫 번째 항목 만 제거합니다.

배열에서 모든 인스턴스 제거

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

배열을 거꾸로 반복하며 (항목이 제거되면 색인과 길이가 변경되므로) 항목이 발견되면 제거합니다. 모든 브라우저에서 작동합니다.

251
Ben Lesh

두 가지 주요 접근법이 있습니다.

  1. splice () : anArray.splice(index, 1);

  2. 삭제 : delete anArray[index];

배열에 대해 delete를 사용할 때는주의하십시오. 객체의 속성을 삭제하는 데는 좋지만 배열에는 적합하지 않습니다. 배열에 splice을 사용하는 것이 좋습니다.

배열에 대해 delete을 사용하면 anArray.length에 대한 잘못된 결과가 발생할 수 있습니다. 즉, delete은 요소를 제거하지만 length 속성의 값은 업데이트하지 않습니다.

삭제를 사용하면 색인 번호에 구멍이 생길 수도 있습니다 (예 : 삭제를 사용하기 전에 인덱스 1,3,4,8,9,11 및 길이를 갖는 것으로 끝낼 수 있습니다. 이 경우 색인은 더 이상 순차적이지 않으므로 모든 색인 된 for 루프가 중단됩니다.

어떤 이유로 delete을 사용해야하는 경우 배열을 반복해야하는 경우 for each loops를 사용해야합니다. 사실상 가능한 경우 색인 된 for 루프를 사용하지 마십시오. 그렇게하면 코드가보다 강력 해지고 인덱스 문제가 발생하지 않게됩니다.

142
Sasa
Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)

118
Zirak

indexOf 또는 splice을 사용할 필요가 없습니다. 그러나 요소의 한 항목 만 제거하려는 경우 더 효과적입니다. 

찾기 및 이동 (이동) :

function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

indexOfsplice (indexof) 사용 :

function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

splice (스플 라이스) 만 사용하십시오.

function splice(arr, val) {
  for (var i = arr.length; i--;) {
    if (arr[i] === val) {
      arr.splice(i, 1);
    }
  }
}

1000 요소 (평균 10000 실행 이상)가있는 배열의 nodejs에서의 실행 시간 :

indexof move 보다 약 10 배 느립니다. splice 에서 indexOf에 대한 호출을 제거하여 개선 된 경우에도 move 보다 훨씬 성능이 떨어집니다. 

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms
87
slosd

응답하기에는 너무 오래되었지만 값 대신 술어를 제공하여 누군가를 도울 수 있습니다.

참고 : 지정된 배열을 업데이트하고 영향을받는 행을 반환합니다.

용법

var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

정의

var helper = {

    // Remove and return the first occurrence     

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences  

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.Push(array.splice(i, 1));
                continue;
            }

            i++;                
        }

        return removed;
    }
};
59
amd

존 Resig 좋은 구현을 게시 :

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.Push.apply(this, rest);
};

전역 객체를 확장하지 않으려면 대신 다음과 같이 할 수 있습니다.

// Array Remove - By John Resig (MIT Licensed)
Array.remove = function(array, from, to) {
    var rest = array.slice((to || from) + 1 || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.Push.apply(array, rest);
};

하지만 내가 게시하는 주된 이유는 해당 페이지 (2007 년 12 월 14 일)에 대한 의견에서 제안 된 대안 구현에 대해 사용자에게 경고하는 것입니다.

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

그것은 처음에 잘 작동하는 것 같지만, 고통스러운 과정을 통해 배열의 두 번째 요소부터 마지막 ​​요소를 제거하려고 할 때 오류가 있다는 것을 발견했습니다. 예를 들어, 10 요소 배열이 있고이 요소를 사용하여 9 번째 요소를 제거하려고하면 :

myArray.remove(8);

결국 8 요소 배열로 끝납니다. 이유는 모르지만 John의 원래 구현에는이 문제가 없다고 확인했습니다.

56
Roger

Underscore.js 는 여러 브라우저의 문제를 해결하는 데 사용할 수 있습니다. 존재하는 경우 브라우저 내장 메소드를 사용합니다. 구형 Internet Explorer 버전과 같이 부재중이라면 자체 사용자 지정 메서드를 사용합니다.

배열에서 요소를 제거하는 간단한 예제 (웹 사이트에서) :

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
54
vatsal

filter method를 사용하면 쉽게 할 수 있습니다.

function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );

이렇게하면 배열에서 모든 요소가 제거되고 슬라이스와 indexOf의 조합이 더 빨리 작동합니다.

53
Salvador Dali

삭제 된 위치가 제거 된 새 배열을 원할 경우 언제든지 특정 요소를 삭제하고 배열을 필터링 할 수 있습니다. 필터 메소드를 구현하지 않는 브라우저에서는 배열 객체 의 확장이 필요할 수 있지만 장기적으로는이 작업 만하기 때문에 쉽습니다.

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

[1, 2, 3, 4, 6]를 표시해야합니다.

42
Loupax

ES6을 사용할 수 있습니다. 

var array=['1','2','3','4','5','6']
var index = array.filter((value)=>value!='3');

출력 : 

["1", "2", "4", "5", "6"]
38
rajat44

이 코드를 확인하십시오. 모든 주요 브라우저 에서 작동합니다.

remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

이 함수를 호출하십시오. 

remove_item(array,value);
35
Ekramul Hoque

Lodash _.pull (mutate array), _.pullAt (mutate array) 또는 _without (mutate array)를 사용할 수 있습니다. 

var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']
33
Chun Yang

OK, 예를 들어 아래 배열을 가지고 있습니다 :

var num = [1, 2, 3, 4, 5];

그리고 우리는 숫자 4를 삭제하고 싶습니다. 아래의 코드를 간단히 할 수 있습니다 :

num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];

이 함수를 재사용하는 경우 재사용 가능한 함수를 작성하여 아래와 같이 네이티브 배열 함수에 첨부합니다.

Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1) return;
  this.splice(i, 1); //num.remove(5) === [1, 2, 3];
}

그러나 배열에서 소수의 [5] 대신에 아래의 배열을 사용하면 어떨까요?

var num = [5, 6, 5, 4, 5, 1, 5];

루프를 모두 검사해야하지만보다 쉽고 효율적인 방법은 내장 된 JavaScript 함수를 사용하는 것이므로 대신 다음과 같은 필터를 사용하는 함수를 작성합니다.

const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //return [1, 2, 3, 4, 6]

또한 Lodash 또는 Underscore와 같이이를 수행하는 데 도움이되는 타사 라이브러리가 있습니다. 자세한 내용은 lodash _.pull, _.pullAt 또는 _.outout을 참조하십시오.

32
Alireza

JavaScript를 사용하여 배열에서 항목을 제거에 몇 가지 방법이 있습니다.

원래 배열을 변경하지 않음에 설명 된 모든 방법을 사용하고 대신 새 방법을 만듭니다.

아이템의 인덱스를 알고 있다면

배열이 있고 i 위치에서 항목을 제거하려고한다고 가정하십시오.

한 가지 방법은 slice()을 사용하는 것입니다.

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

slice()은 수신 한 인덱스를 사용하여 새 배열을 만듭니다. 우리는 단순히 시작에서 제거하고자하는 인덱스에 이르기까지 새로운 배열을 만들고, 우리가 제거한 배열 다음에 오는 첫 번째 위치에서 다른 배열을 연결합니다.

가치를 알고 있다면

이 경우 한 가지 좋은 옵션은 filter()을 사용하는 것입니다. 이는 선언적 접근 방식을 제공합니다.

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

ES6 화살표 기능을 사용합니다. 기존 기능을 사용하여 이전 브라우저를 지원할 수 있습니다.

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

또는 Babel을 사용하여 ES6 코드를 ES5로 다시 변환하여 이전 브라우저에서보다 소화하기 쉽게 만들 수 있지만 코드에서 최신 JavaScript를 작성할 수 있습니다.

여러 항목 제거

단일 항목 대신 많은 항목을 제거하려면 어떻게합니까?

가장 간단한 해결책을 찾으십시오.

색인 별

함수를 만들고 항목을 연속으로 제거 할 수 있습니다.

const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

가치

콜백 함수 내에 포함을 검색 할 수 있습니다.

const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

원래 배열을 변경하지 마십시오

splice() (slice()과 혼동하지 말 것)은 원래 배열을 변경하므로 피해야합니다.

(원래 https://flaviocopes.com/how-to-remove-item-from-array/ 에 게시)

29
Flavio Copes

JavaScript에 익숙하지 않아이 기능이 필요했습니다. 나는 이것을 단지 썼다.

function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

그런 다음 그것을 사용하고 싶을 때 :

//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

출력 - 예상대로. [ "item1", "item1"]

당신은 내가 필요로하는 것보다 다른 필요성을 가지고있을 수 있으므로 그것을 쉽게 수정할 수 있습니다. 나는 이것이 누군가를 돕기를 바랍니다.

27
sofiax

돌연변이가없는 ES6 & : (2016 년 10 월)

const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

다음 : 

removeByIndex([33,22,11,44],1) //=> [33,11,44]
24
Abdennour TOUMI

업데이트 : 이 방법은 ECMAScript 2015 (이전에는 ES6이라고 함)를 사용할 수없는 경우에만 권장됩니다. 그것을 사용할 수 있다면, 여기에있는 다른 대답은 훨씬 더 깔끔한 구현을 제공합니다.


이 Gist here 는 문제를 해결하고, 단지 1 (또는 지정된 값) 대신 모든 인수를 삭제합니다.

Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

용법:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]
22
zykadelic

배열에 복잡한 객체가 있다면 필터를 사용할 수 있습니까? $ .inArray 또는 array.splice가 사용하기 쉽지 않은 상황에서. 특히 객체가 배열에서 얕은 경우.

예 : Id 필드가있는 객체가 있고 객체를 배열에서 제거하려면 다음을 수행하십시오.

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
21
flurdy

배열에 배열을 변경해서는 안됩니다. 이것은 기능적 프로그래밍 패턴에 위배됩니다. 할 수있는 일은 es6 메서드 filter을 사용하여 데이터를 변경하려는 배열을 참조하지 않고 새 배열을 만드는 것입니다.

var myArray = [1,2,3,4,5,6];

배열에서 5를 제거하기를 원한다면 간단히 이렇게 할 수 있습니다.

myArray = myArray.filter(value => value !== 5);

이렇게하면 제거하려는 값이없는 새 배열이 제공됩니다. 결과는

 [1,2,3,4,6]; // 5 has been removed from this array

자세한 내용은 Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter 페이지의 MDN 설명서를 참조하십시오.

19
Adeel Imran

보다 현대적인 ECMAScript 2015 이전의 하모니 또는 ES 6) 접근 방법 : 주어진 :

const items = [1, 2, 3, 4];
const index = 2;

그때:

items.filter((x, i) => i !== index);

굽힐 수 있는: 

[1, 2, 4]

Babelpolyfill service )를 사용하여 여러 브라우저에서 잘 지원되도록 할 수 있습니다.

18
bjfletcher

이미 많은 답변이 있다는 것을 알고 있지만 많은 사람들이 문제를 복잡하게 보입니다. 다음은 키의 모든 인스턴스를 제거하는 간단하고 재귀적인 방법입니다. 인덱스가 발견되지 않을 때까지 self를 호출합니다. 예, indexOf을 사용하는 브라우저에서만 작동하지만 간단하고 쉽게 polyfilled 할 수 있습니다.

독립형 기능

function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}

프로토 타입 방법

Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}
16
wharding28

배열에서 제거하는 또 다른 좋은 해결책이 있습니다.

var words = ['spray', 'limit', 'Elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(Word => Word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

15
Aram Grigoryan

요소의 인스턴스가 여러 개인 경우 역순으로 루프를 실행하여 인덱스가 엉망이되지 않도록 할 수 있습니다.

var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

라이브 데모

15
Jeff Noel

주로 올바른 답변을 바탕으로 제안 된 모범 사례 (특히 Array.prototype을 직접 사용하지 않음)를 고려하여 아래 코드를 작성했습니다.

function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

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

  return arrCopy;
}

위의 기능을 검토해 보면 실제로 작동하더라도 성능이 약간 향상 될 수 있음을 알았습니다. 또한 ES5 대신 ES6을 사용하는 것이 훨씬 더 나은 방법입니다. 이를 위해 개선 된 코드가 있습니다.

const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.Push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

사용하는 방법:

const arr = [1,2,3,4,5,"name", false];

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)

현재 문제없이 배열에 대한 여러 가지 솔루션을 벤치마킹 한 블로그 게시물을 작성 중이며 실행하는 데 걸리는 시간을 비교했습니다. 나는 그 게시물을 끝내면이 답변을 링크로 업데이트 할 것입니다. 그냥 알려주려면, 나는 위의 lodash에 비해 위의 비교하고 브라우저가 Map을 지원하는 경우, 그것은 lodash를 이겼어! Map 또는 Object에서 exlcudeValues를 래핑하면 더 빨리 쿼리를 수행하므로 Array.prototype.indexOf 또는 Array.prototype.includes를 사용하지 않습니다.

15
Ardi

1에서 9까지의 배열이 있고 코드 아래에서 5 개의 사용을 제거하고 싶습니다.

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);


Ex : -1,7,8 값을 여러 개 입력하려는 경우

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 5 removed", newNumberArray);


배열 ex : - [3,4,5]에서 배열 값을 제거하려면,

var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

지원되는 브라우저 포함 link

14
Thilina Sampath
  Array.prototype.removeItem = function(a) {
            for (i = 0; i < this.length; i++) {
                if (this[i] == a) {
                    for (i2 = i; i2 < this.length - 1; i2++) {
                        this[i2] = this[i2 + 1];
                    }
                    this.length = this.length - 1
                    return;
                }
            }
        }

    var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
    recentMovies.removeItem('Superman');
13

색인으로 제거

요소가없는 배열의 복사본을 인덱스에 반환하는 함수입니다.

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
    return array.filter(function(elem, _index){
        return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

값으로 제거

값없이 배열 복사본을 반환하는 함수입니다.

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
    return array.filter(function(elem, _index){
        return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]
13
nsantana

나는ES6에 근거하여 대답하고 싶다. 다음과 같은 배열이 있다고 가정 해보십시오.

let arr = [1,2,3,4];

2와 같은 특수 색인을 삭제하려면 다음 코드를 작성하십시오.

arr.splice(2, 1); //=> arr became [1,2,4]

그러나 3와 같은 특수 항목을 삭제하고 해당 색인을 모른다면 다음과 같이하십시오.

arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

힌트 : 빈 배열을 얻지 않는 한 필터 콜백에 화살표 함수를 사용하십시오.

11
AmerllicA

새 배열 만들기 :

var my_array = new Array();

이 배열에 요소 추가 :

my_array.Push("element1");

함수 indexOf (인덱스를 반환하거나 찾을 수없는 경우 -1) :

var indexOf = function(needle) 
{
    if(typeof Array.prototype.indexOf === 'function') // newer browsers
    {
        indexOf = Array.prototype.indexOf;
    } 
    else // older browsers
    {
        indexOf = function(needle) 
        {
            var index = -1;

            for(var i = 0; i < this.length; i++) 
            {
                if(this[i] === needle) 
                {
                    index = i;
                    break;
                }
            }
            return index;
        };
    }

    return indexOf.call(this, needle);
};

이 요소의 색인을 검사합니다 (Firefox 및 IE8 +에서 테스트 됨) :

var index = indexOf.call(my_array, "element1");

배열에서 인덱스에있는 1 개의 원소 제거

my_array.splice(index, 1);
11
Enrico

또한 Array에서 요소를 제거해야하는 상황에서도 실행되었습니다. .indexOfIE*에서 작동하지 않아서 작동하는 jQuery.inArray() 솔루션을 공유했습니다.

var index = jQuery.inArray(val,arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}
10
NullPointer

2017-05-08

주어진 답변의 대부분은 엄격한 비교를 위해 작동합니다. 즉, 두 객체가 메모리에서 동일한 객체를 참조하거나 원시 유형 인 경우가 있지만 특정 값을 가진 배열에서 비 프리미티브 객체를 제거하려는 경우가 있습니다. 예를 들어, 서버를 호출하고 검색된 객체를 로컬 객체와 비교하여 검사하려고 할 때.

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

ValuesAreEqual에 대한 대체/더 빠른 구현이 있지만 작업을 수행합니다. 검사 할 특정 필드가있는 경우 사용자 지정 비교기를 사용할 수도 있습니다 (예 : 검색된 UUID와 로컬 UUID).

또한 이것은 원래의 배열을 돌연변이시키지 않는다는 것을 의미하는 기능적 연산 임에 유의하십시오.

9
Aidan Hoolachan

자바 스크립트 명령어 중 상당수는 함수형 프로그래밍에 대해 잘 생각하지 않는다고 생각합니다. Splice는 감소 된 배열이 필요한 대부분의 시간에 삭제 된 요소를 반환합니다. 이것은 나쁘다.

재귀 호출을 수행하고 있다고 가정하고 현재 인덱싱 된 항목이없는 하나의 항목이 적은 배열을 전달해야합니다. 또는 다른 재귀 호출을 수행 중이며 푸시 된 요소가있는 배열을 전달해야한다고 가정합니다.

이 두 가지 경우 모두 myRecursiveFunction(myArr.Push(c)) 또는 myRecursiveFunction(myArr.splice(i,1))을 수행 할 수 없습니다. 첫 번째 바보는 실제로 배열의 길이를 전달하고 두 번째 바보는 삭제 된 요소를 매개 변수로 전달합니다.

그래서 내가 실제로하는 일은 ... 배열 요소를 삭제하고 그 결과를 매개 변수로 함수에 전달하는 것과 동시에 다음과 같이합니다.

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

그것이 푸시에 관해서는 더 어리 석다 ... 나는 좋아한다.

myRecursiveFunction((myArr.Push(c),myArr))

나는 적절한 함수 언어를 믿는다. 그것은 호출 된 객체를 돌연변이시키는 메소드는 결과로서 바로 객체에 대한 참조를 반환해야한다.

9
Redu

있음 CoffeeScript :

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
8

JQuery의 InArray를 사용하십시오.

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

참고 : inArray는 요소가 없으면 -1을 반환합니다.

7
Do Hoa Vinh

바닐라 자바 ​​스크립트 (ES5.1) - in place edition

브라우저 지원 : Internet Explorer 9 이상 ( 상세 브라우저 지원 ) _

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

바닐라 자바 ​​스크립트 (ES5.1) - immutable

브라우저 지원 : 바닐라 자바 ​​스크립트와 동일한 버전 _

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

바닐라 ES6 - 불변

브라우저 지원 : Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( 상세 브라우저 지원 ) _

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}

원래 배열을 변경하지 않고 인덱스 i의 요소를 제거합니다.

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}
6
alejandro

이 버전의 스플 라이스는 $.inArray를 사용하여 값으로 요소를 제거합니다.

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});
6
mboeckle

array- 항목과 splicearray에 있으면 각 항목을 반복 할 수 있습니다.

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}
6
yckart

방금 Array.prototype를 통해 Object.defineProperty를 통해 polyfill을 만들었습니다. for .. in ..를 통해 나중에 반복 할 때 오류가 발생하지 않고 배열에서 원하는 요소를 제거 할 수 있습니다.

if (!Array.prototype.remove) {
  // Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
  // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
  Object.defineProperty(Array.prototype, 'remove', {
    value: function () {
      if (this == null) {
        throw new TypeError('Array.prototype.remove called on null or undefined')
      }

      for (var i = 0; i < arguments.length; i++) {
        if (typeof arguments[i] === 'object') {
          if (Object.keys(arguments[i]).length > 1) {
            throw new Error('This method does not support more than one key:value pair per object on the arguments')
          }
          var keyToCompare = Object.keys(arguments[i])[0]

          for (var j = 0; j < this.length; j++) {
            if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
              this.splice(j, 1)
              break
            }
          }
        } else {
          var index = this.indexOf(arguments[i])
          if (index !== -1) {
            this.splice(index, 1)
          }
        }
      }
      return this
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when remove() is executed.'
  console.log(errorMessage)
}

정수 값 제거

var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]

문자열 값 제거

var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']

부울 값 제거

var a = [true, false, true]
a.remove(false)
a // Output => [true, true]

Array.prototype.remove 메소드를 통해 배열 내부의 객체를 제거 할 수도 있습니다. 제거하려는 Objectkey => value를 지정하면됩니다.

객체 값 제거

var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]
5
Victor

필자는 기본 JavaScript 배열을 상당히 효율적으로 확장했습니다.

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};
5
Shawn Deprey

내 솔루션으로 순수 JavaScript 덕분에 배열에서 하나 이상의 항목을 제거 할 수 있습니다. 다른 JavaScript 라이브러리는 필요 없습니다.

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]
5
Kamuran Sönecek

느슨한 비교를 사용하여 원래 배열 ES6을 변경하지 않고 하나의 값 제거

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 * 
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}
4
mpen

그러나 또 다른 대답은 나에게 더 간단합니다. 2018 년 (2019 년 근처)에 저는 원래의 질문에 답하기 위해 (가까운) 하나의 라이너를드립니다.

Array.prototype.remove = function (value) { 
    return this.filter(f => f != value) 
}

유용한 것은 다음과 같은 카레 식에서 사용할 수 있다는 것입니다.

[1,2,3].remove(2).sort()

4
Sebastien H.

위의 답변 대부분이 질문에 답하는 동안 slice() 메서드가 사용되지 않은 이유는 분명하지 않습니다. 예, filter()은 불변의 기준을 충족하지만, 다음과 같은보다 짧은 동등한 작업을 수행하는 방법은 무엇입니까?

const myArray = [1,2,3,4];

이제 배열에서 두 번째 요소를 제거해야한다고 말하면됩니다. const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

배열에서 요소를 삭제하는이 방법은 오늘날 간단하고 불변 인 특성 때문에 커뮤니티에서 강력하게 권장됩니다. 일반적으로 돌연변이를 유발하는 방법은 피해야한다. 예를 들어, Push()concat()로 대체하고 splice()slice()로 대체하는 것이 좋습니다 

4
Stelios Voskos

jQuery.grep () :을 사용하십시오.

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

4
Mahendra Kulkarni

배열에서 특정 요소/문자열을 제거하는 것은 하나의 라이너에서 수행 할 수 있습니다. 이 유형의 문제에 대해 얻을 수있는 가장 우아한 라이너라고 생각합니다. 

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

여기서 'theArray'는 특정 항목을 제거하려는 배열입니다.

4

배열 요소를 제거하는 코드를 게시하고 배열 길이를 줄입니다.

function removeElement(idx, arr) {
    // check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // remove the first element in array
    arr.shift();
}
3
hailong

여기에는 많은 환상적인 해답이 있지만 나에게있어서 가장 효과가 있었던 것은 배열에서 요소를 완전히 제거하지 않고 단순히 값을 null로 설정하는 것이 었습니다. 이것은 내가 가지고있는 대부분의 경우에 적용되며, 나중에 변수를 사용할 것이므로 사라지지 않기 때문에 좋은 해결책입니다. 지금은 그냥 비워 두십시오. 또한이 방법은 브라우저와 완벽하게 호환됩니다.

array.key = null;
3
rncrtr

마지막 발생 또는 모든 발생 또는 첫 번째 발생을 제거 하시겠습니까? 

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

또는

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}
3
MEC

중복 된 숫자 또는 문자열이 제거 된 새 배열을 반환하는 메서드를 복제하려는 경우 기존의 답변과 함께 정리했습니다.

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.Push(element);
  }

  return dupFree;
}
3
cjjenkinson

나는 기능을 만들었다. 

function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}

그리고 이렇게 사용했습니다.

pop(valuetoremove,myarray);

건배!

3
Ali Akram

매우 순진한 구현은 다음과 같습니다.

Array.prototype.remove = function(data) {
    const dataIdx = this.indexOf(data)
    if(dataIdx >= 0) {
        this.splice(dataIdx ,1);
    }
    return this.length;
}

let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);

함수의 배열 길이를 Array.prototype.Push() 같은 다른 메서드를 따르기 위해 반환합니다.

3
Gaurang Patel

나는이 문제를 직접 (array를 대체 할 수있는 상황에서) 간단히 해결했다 :

var filteredItems = this.items.filter(function (i) {
    return i !== item;
});

위의 스 니펫에 약간의 컨텍스트를 제공하려면 다음을 수행하십시오.

self.thingWithItems = {
        items: [],
        removeItem: function (item) {
            var filteredItems = this.items.filter(function (i) {
                return i !== item;
            });

            this.items = filteredItems;
        }
    };

이 솔루션은 참조 및 값 항목 모두에서 작동해야합니다. 이 솔루션이 적용 가능한지 여부는 원래 배열에 대한 참조를 유지해야하는지 여부에 따라 다릅니다. 

2
Phil
var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);

Array.findindex를 사용하여 코드 줄 수를 줄일 수 있습니다.

developer.mozilla.org

2
sujithklr93
var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.Push(result); 
        }
    }
}
input = integers;

이 솔루션은 입력 배열을 취하여 제거 할 값을 입력을 통해 검색합니다. 이것은 전체 입력 배열을 통해 반복되며 결과는 특정 인덱스가 제거 된 두 번째 배열 정수가됩니다. 그런 다음 정수 배열을 입력 배열에 다시 복사합니다. 

2
penguin

주문이나 고유 한 값이 필요한지 여부에 대한 질문은 표시되지 않았습니다.

주문에 신경 쓰지 않고 컨테이너에 같은 값이 두 번 이상 나오지 않으면 Set을 사용하십시오. 그것은 더 빠르고 더 간결 할 것입니다. 

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);
2
Steven Spungin
[2,3,5].filter(i => ![5].includes(i))

인덱스와 스플 라이스로 값을 제거하십시오!

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}
2
Nejc Lepen

마지막에서 요소를 삭제하십시오. 

arrName.pop();

처음부터 요소 삭제 

arrName.shift();

중간에서 삭제

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

마지막으로 한 요소를 삭제한다.

arrName.splice(-1);

배열 인덱스 번호를 사용하여 삭제

 delete arrName[1];
2
Srikrushna Pal

열쇠가 정수와 같은 문자열 인 객체가 아니라 정수 배열을 갖는 것이 부끄러운 일입니다.

나는이 대답들을 많이 보았고, 나는 그들이 볼 수있는 한 "brute force"를 사용하는 것처럼 보인다. 나는 모든 단일 한 것을 조사하지 않았다, 그렇지 않은 경우 사과한다. 소규모 배열의 경우에는 괜찮습니다. 그러나 정수가 000s 인 경우 어떻게됩니까?

내가 틀렸다면 나를 바로 잡을 수 있지만 key => value 맵에서 JS 객체가 무엇인지, 키 검색 메커니즘이 고도로 설계되고 최적화되어 있다고 가정 할 수는 없을까요? (어떤 슈퍼 전문가가 그렇지 않다고 말하면주의해야합니다. 대신 ES6의 지도 클래스 를 사용할 것을 제안 할 수 있습니다.

특정 상황에서 최상의 솔루션은 배열을 객체로 변환하는 것일 수 있습니다 ... 물론 정수 값을 반복 할 수 있다는 문제가 있습니다. 버킷에있는 것들을 key => value 항목의 "값"부분으로 두는 것이 좋습니다. (반복적 인 배열 요소가 없다고 확신하는 경우이 키는 훨씬 간단 할 수 있습니다 : 키와 동일한 값, 수정 된 배열을 얻기 위해 Object.values(...)로 이동).

그래서 당신은 할 수 있습니다 :

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =   function( acc, val, currIndex ){ 
    // not seen this val before: make bucket... NB although val's typeof is 'number'
    // there is seamless equivalence between the object key (always string)
    // and this variable val 
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // drop another array index in the bucket
    acc[ val ].Push( currIndex );
    return acc; 
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

산출:

Object [빈 슬롯 1 개], Array 1 , Array [2], Array 1 , Array 1 , <5 빈 슬롯> ...]

모든 숫자를 쉽게 삭제할 수 있습니다.

delete myIntsMapObj[ 55 ]; // again, although keys are strings this works

모두 삭제할 필요는 없습니다. 인덱스 값은 모양 순서대로 버킷에 푸시됩니다 (예 :).

myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop(); 

첫 번째 및 마지막 발생을 각각 삭제합니다. 발생 빈도를 쉽게 세고, 한 버킷의 내용을 다른 버킷으로 옮겨서 55를 모두 3로 바꿀 수 있습니다.

... 수정 된 int 배열을 가져 오는 작업은 약간 복잡하지만 각 버킷에는 (문자열) 키로 표시된 값의 인덱스 (원래 배열에 있음)가 포함됩니다. 각각의 버킷 값은 고유합니다. 따라서 "정수 문자열 키"의 (실제) 정수를 값으로 사용하여 새 객체의 키로 변환 한 다음 키를 정렬하고 Object.values( ... )으로 이동하십시오.

이것은 매우 복잡하고 시간 소모적 인 것처럼 들리지만 ... 분명히 모든 것은 상황과 원하는 사용법에 달려 있습니다. JS의 모든 버전과 컨텍스트는 하나의 스레드에서만 작동하며 스레드는 "놓아 두지"않기 때문에 "무차별 대항"메서드로 끔찍한 정체가 발생할 수 있습니다. indexOf 연산에 의해 그렇게 많이 발생하지는 않습니다 , 그러나 여러 반복 slice/splice ops.

부록
만약 당신이 확실하다 이것은 당신의 사용 사례를위한 너무 많은 엔지니어링이다. 확실히 가장 간단한 "무차별 대항"접근법은

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(예, 다른 답변이 Array.prototype.filter ...을 (를) 발견했습니다.)

2
mike rodent

다음의 방법은 새로운 배열을 생성하지 않고 superfast 를 반복하지 않고 배열에서 주어진 값의 모든 엔트리를 제거합니다. 그리고 고대 Internet Explorer 5.5 브라우저에서 작동합니다.

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]
<code id="code"></code>

2
Eugene Tiurin

특정 요소 나 후속 요소를 제거하려면 Array.splice () 메서드가 잘 작동합니다. splice () 메서드는 기존 요소를 제거하거나 바꾸거나 새 요소를 추가하여 배열 내용을 변경합니다. 제거 된 항목을 반환합니다.

구문 : array.splice (index, deleteCount, item1, ....., itemX)} _

여기서 index은 필수이며 나머지 인수는 선택 사항입니다.

예 :

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

참고 : Array.splice () 메서드는 삭제하려는 요소의 인덱스를 알고있는 경우 사용할 수 있습니다. 그러나 아래에서 언급 한 것처럼 몇 가지 사례가있을 수 있습니다.

  1. 마지막 요소 만 삭제하려는 경우 Array.pop () 을 사용할 수 있습니다.

  2. 첫 번째 요소 만 삭제하려는 경우 Array.shift () 를 사용하면됩니다.

  3. 요소 만 알지만 요소의 위치 (또는 색인)는 아니며 Array.filter () 메소드를 사용하여 일치하는 요소를 모두 삭제하려는 경우 :

    let arr = [1, 2, 1, 3, 4, 1, 5, 1];
    
    let newArr = arr.filter(function(val){
        return val !== 1;
     });
     //newArr => [2, 3, 4, 5]
    

또는 splice () 메서드를 as-

let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    for( let i = 0; i < arr.length-1; i++){
       if ( arr[i] === 11) {
         arr.splice(i, 1); 
       }
    }
    console.log(arr);
    // [1, 2, 3, 4, 5, 6]

OR array arr에서 del을 삭제하려고한다고 가정합니다.

let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}
  1. 요소가 있지만 요소의 위치 (또는 색인)가 아니라 요소를 알고 있고 splice () 메서드를 사용하여 매우 첫 번째로 일치하는 요소 만 삭제하려는 경우 :

    let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    
    for( let i = 0; i < arr.length-1; i++){
      if ( arr[i] === 11) {
        arr.splice(i, 1);
        break;
      }
    }
    console.log(arr);
    // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
    
1
Chang

이전 버전의 Internet Explorer를 지원해야하는 경우 다음 polyfill을 사용하는 것이 좋습니다 (참고 : this is not framework). Internet Explorer 6 이상, Firefox 1.5 이상, Chrome, Safari 및 Opera에서 작동하는 모든 최신 배열 방법 (JavaScript 1.8.5/ECMAScript 5 Array Extras)을 100 % 역 호환 할 수 있습니다.

https://github.com/plusdude/array-generics

1
Matt Brock

필터 함수를 사용하여 새 배열을 만드는 것이 더 나을 때가 많습니다.

const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

이것은 또한 가독성을 향상시킵니다. 나는 가끔은 당신이 그것을해야한다는 것을 알고 있지만, 슬라이스의 팬이 아니에요.

1
codepleb

JavaScript의 프로토 타입 기능을 사용하여 배열 객체에 remove ()라는 메서드를 정의합니다.

splice () 메서드를 사용하여 요구 사항을 충족시킵니다.

아래 코드를 살펴보십시오.

Array.prototype.remove = function(item) {
    // index will have -1 if item does not exist
    // else it will have the index of 1st item found in array
    var index = this.indexOf(item); 

    if (index > -1) {
        // splice() method is used to add/remove items(s) in array
        this.splice(index, 1); 
    }

    return index;
}


var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)

if (index > 0){
    console.log("Item 67 found at ", index)
} else {
    console.log("Item 67 does not exist in array")
}

// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at  2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

Note : 다음은 Push (), pop (), shift (), unshift () 및 splice ()의 사용을 설명하는 Node.js REPL () 메소드를 호출합니다.

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.Push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45);   // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22)    // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100);  // 100 doesn't exist, remove() will return -1
-1
>

감사.

1
hygull

배열에서 요소를 제거하기 위해 스플 라이스, 필터 및 삭제

모든 배열은 색인을 가지며 색인을 사용하여 특정 요소를 삭제하는 데 도움이됩니다.

splice () 메소드  

array.splice (index, 1 ); 첫 번째 매개 변수는 index이고 두 번째는 요소의 수입니다.

해당 인덱스에서 삭제하려고합니다.

따라서 단일 요소의 경우 1을 사용합니다. 

삭제 방법

배열 삭제 [색인]

filter () 메서드

배열에서 반복되는 요소를 삭제하려면 배열을 필터링하십시오.

removeAll = array.filter (e => e! = elem);

여기서 elem은 array에서 제거 할 요소이고 array는 배열 이름입니다.

1
ashish

splice () 메소드는 기존 요소를 제거하거나 대체하거나 새 요소를 추가하여 배열의 내용을 변경합니다.

array.splice (start [ deleteCount [ item1 [ item2 [ ...]]])

시작

배열 변경 시작 인덱스입니다 (Origin 0 포함). 배열 길이보다 길면 실제 시작 인덱스는 배열의 길이로 설정됩니다. 음수 인 경우 배열의 끝에서부터 (Origin -1을 사용하여) 많은 요소를 시작하고 절대 값이 배열의 길이보다 큰 경우 0으로 설정됩니다.

deleteCount 옵션

제거 할 낡은 배열 요소의 수를 나타내는 정수입니다. deleteCount가 생략되었을 경우, 또는 그 값이 array.length - start보다 큰 경우 (즉, 그 요소가 배열 시작에서 시작) 배열의 처음부터 끝까지의 모든 요소가 삭제됩니다. deleteCount가 0 또는 음수이면 요소가 제거되지 않습니다. 이 경우 하나 이상의 새 요소를 지정해야합니다 (아래 참조).

item1, item2, ... 선택 사항

시작 인덱스에서 시작하여 배열에 추가 할 요소입니다. 요소를 지정하지 않으면 splice ()는 배열에서 요소 만 제거합니다.

더 많은 referene을 위해 친절하게 지나간다 :

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

0
ashish

이미 많은 답변이 있지만, 아무도 아직 하나의 라이너로 끝내지 않았기 때문에, 나는 내 방법을 보여줄 것이라고 생각했습니다. 배열을 만들 때 string.split () 함수가 지정된 모든 문자를 제거한다는 점을 이용합니다. 다음은 그 예입니다. 

var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);

이 예에서는 모든 4가 배열에서 제거됩니다. 그러나 "-"문자가 포함 된 배열은이 예제에서 문제를 일으킬 것이라는 점에 유의해야합니다. 즉, 결합 ( "-") 함수가 문자열을 부적절하게 결합하게 만듭니다. 이러한 상황에서 위 snipet의 "-"문자열은 모두 원래 배열에서 사용되지 않는 문자열로 바꿀 수 있습니다. 다음은 또 다른 예입니다. 

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
console.log(out);

0
Partial Science

비 현장 솔루션

arr.slice(0,i).concat(arr.slice(i+1));
let arr = [10, 20, 30, 40, 50]

let i = 2 ; // position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));

console.log(r);
0
Kamil Kiełczewski

다음과 같이 배열 객체를 확장하여 사용자 정의 삭제 기능을 정의 할 수 있습니다

let numbers = [1,2,4,4,5,3,45,9];

numbers.delete = function(value){
    var indexOfTarget = this.indexOf(value)

    if(indexOfTarget !== -1)
    {
        console.log("array before delete " + this)
        this.splice(indexOfTarget, 1)
        console.log("array after delete " + this)
    }else{
        console.error("element " + value + " not found")
    }
}
numbers.delete(888)
//expected output:
//element 888 not found
numbers.delete(1)

//expected output;
//array before delete 1,2,4,4,5,3,45,9
//array after delete 2,4,4,5,3,45,9

나는 그것이 도움이되기를 바랍니다

0
mekbib.awoke

Reduce 방식의 이익 획득은 다음과 같습니다.

case a) 인덱스로 요소를 제거해야하는 경우 :

function remove(arr, index) {
  return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}

case b) 요소의 값으로 요소를 제거해야하는 경우 (int) :

function remove(arr, value) {
  return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}

따라서이 방법으로 요소를 제거한 상태에서 새로운 배열을 반환 할 수 있습니다 (멋지게 기능적인 방식으로 푸시 또는 스플 라이스를 사용하는 것보다 훨씬 낫습니다).

0
alejoko
Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
        z[z.length] = this[i];
    }

    for(i=0;i<y.length;i++){
        z[z.length]=y[i];
    }

    return z;
}
0
user4109793
var arr =[1,2,3,4,5];

arr.splice(0,1)

console.log(arr)

출력 [2, 3, 4, 5];

0
Shahriar Ahmad