값으로 배열에서 항목을 제거하는 방법은 무엇입니까?

값으로 배열에서 항목을 제거하는 방법은 무엇입니까?

---

JavaScript 배열에서 항목을 제거하는 방법이 있습니까?

주어진 배열 :

var ary = ['three', 'seven', 'eleven'];

다음과 같은 작업을하고 싶습니다.

removeItem('seven', ary);

나는 조사 splice()했지만 위치 번호로만 제거되는 반면 값으로 항목을 제거하려면 무언가가 필요합니다.

---

네이티브 프로토 타입에 추가 할 수없는 경우 전역 함수 또는 사용자 지정 개체의 메서드 일 수 있습니다. 인수 중 하나와 일치하는 배열에서 모든 항목을 제거합니다.

Array.prototype.remove = function() {
    var what, a = arguments, L = a.length, ax;
    while (L && this.length) {
        what = a[--L];
        while ((ax = this.indexOf(what)) !== -1) {
            this.splice(ax, 1);
        }
    }
    return this;
};

var ary = ['three', 'seven', 'eleven'];

ary.remove('seven');

/*  returned value: (Array)
three,eleven
*/

글로벌화를 위해

function removeA(arr) {
    var what, a = arguments, L = a.length, ax;
    while (L > 1 && arr.length) {
        what = a[--L];
        while ((ax= arr.indexOf(what)) !== -1) {
            arr.splice(ax, 1);
        }
    }
    return arr;
}
var ary = ['three', 'seven', 'eleven'];
removeA(ary, 'seven');


/*  returned value: (Array)
three,eleven
*/

그리고 IE8 이하를 처리하려면

if(!Array.prototype.indexOf) {
    Array.prototype.indexOf = function(what, i) {
        i = i || 0;
        var L = this.length;
        while (i < L) {
            if(this[i] === what) return i;
            ++i;
        }
        return -1;
    };
}

---

다음 과 같은 indexOf방법을 사용할 수 있습니다 .

var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);

참고 : IE8 이하에서는 shim이 필요합니다.

var array = [1,2,3,4]
var item = 3

var index = array.indexOf(item);
if (index !== -1) array.splice(index, 1);

console.log(array)

---

한 줄짜리가 할 것입니다.

var ary = ['three', 'seven', 'eleven'];

// Remove item 'seven' from array
var filteredAry = ary.filter(function(e) { return e !== 'seven' })
//=> ["three", "eleven"]

// In ECMA6 (arrow function syntax):
var filteredAry = ary.filter(e => e !== 'seven')

이것은 JS 의 필터 기능을 사용합니다 . IE9 이상에서 지원됩니다.

그것이하는 일 (문서 링크에서)

filter ()는 배열의 각 요소에 대해 제공된 콜백 함수를 한 번씩 호출하고 콜백이 true로 강제 변환되는 값을 반환하는 모든 값의 새 배열을 생성합니다. 콜백은 값이 할당 된 배열의 인덱스에 대해서만 호출됩니다. 삭제되었거나 값이 할당되지 않은 인덱스에 대해서는 호출되지 않습니다. 콜백 테스트를 통과하지 못한 배열 요소는 단순히 건너 뛰고 새 배열에 포함되지 않습니다.

따라서 기본적으로 이것은 구성이 IE6에서 지원 for (var key in ary) { ... }된다는 점을 제외하고 는 다른 모든 솔루션과 동일합니다 for in.

기본적으로 필터는 for in구조 (AFAIK)에 비해 훨씬 멋지게 보이고 체인이 가능한 편리한 방법입니다 .

---

underscore.js 를 사용할 수 있습니다 . 정말 간단합니다.

예를 들면 다음과 같습니다.

var result = _.without(['three','seven','eleven'], 'seven');

그리고 result될 것 ['three','eleven']입니다.

귀하의 경우 작성해야 할 코드는 다음과 같습니다.

ary = _.without(ary, 'seven')

작성하는 코드를 줄입니다.

---

이 방법으로 확인하십시오.

for(var i in array){
    if(array[i]=='seven'){
        array.splice(i,1);
        break;
    }
}

그리고 함수에서 :

function removeItem(array, item){
    for(var i in array){
        if(array[i]==item){
            array.splice(i,1);
            break;
        }
    }
}

removeItem(array, 'seven');

---

다음은 jQuery의 inArray 함수 를 사용하는 버전입니다 .

var index = $.inArray(item, array);
if (index != -1) {
    array.splice(index, 1);
}

---

다음 두 가지 방법으로 수행 할 수 있습니다.

var arr = ["1","2","3","4"] // we wanna delete number "3"

먼저:

arr.indexOf('3') !== -1 && arr.splice(arr.indexOf('3'), 1)

두 번째 (ES6) :

arr = arr.filter(e => e !== '3')

---

var index = array.indexOf('item');

if(index!=-1){

   array.splice(index, 1);
}

---

당신이 추구하는 것은 필터

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

이렇게하면 다음을 수행 할 수 있습니다.

var ary = ['three', 'seven', 'eleven'];
var aryWithoutSeven = ary.filter(function(value) { return value != 'seven' });
console.log(aryWithoutSeven); // returns ['three', 'eleven']

이것은 다른 곳의 스레드에서도 언급되었습니다 : https://stackoverflow.com/a/20827100/293492

---

간단히

var ary = ['three', 'seven', 'eleven'];
var index = ary.indexOf('seven'); // get index if value found otherwise -1

 if (index > -1) { //if found
   ary.splice(index, 1);
 }

---

가장 간단한 해결책은 다음과 같습니다.

array-일부 요소를 제거하기위한 배열 valueForRemove; valueForRemove-제거 할 요소.

array.filter(arrayItem => !array.includes(valueForRemove));

더 단순하게:

array.filter(arrayItem => arrayItem !== valueForRemove);

예쁘지는 않지만 작동합니다.

array.filter(arrayItem => array.indexOf(arrayItem) != array.indexOf(valueForRemove))

예쁘지는 않지만 작동합니다.

while(array.indexOf(valueForRemove) !== -1) {
  array.splice(array.indexOf(valueForRemove), 1)
}

---

예쁜 것이 없기 때문에 간단하고 재사용 가능한 ES6 기능이 있습니다.

const removeArrayItem = (arr, itemToRemove) => {
  return arr.filter(item => item !== itemToRemove)
}

용법:

const items = ['orange', 'purple', 'orange', 'brown', 'red', 'orange']
removeArrayItem(items, 'orange')

---

ES6 방식.

const commentsWithoutDeletedArray = commentsArray.filter(comment => comment.Id !== commentId);

---

정말, 왜 이것이 해결되지 않는지 알 수 없습니다.

arr = arr.filter(value => value !== 'seven');

또는 바닐라 JS를 사용하고 싶을 수도 있습니다.

arr = arr.filter(function(value) { return value !== 'seven' });

---

배열에 고유 한 값이 있고 순서가 중요하지 않은 경우 Set 을 사용할 수 있으며 delete가 있습니다 .

var mySet = new Set(['foo']);
mySet.delete('foo'); // Returns true.  Successfully removed.
mySet.has('foo');    // Returns false. The "foo" element is no longer present.

---

배열에서 일치하는 모든 요소를 ​​제거합니다 (여기서 가장 일반적인 대답 인 것처럼 보이는 첫 번째 요소가 아님).

while ($.inArray(item, array) > -1) {
    array.splice( $.inArray(item, array), 1 );
}

무거운 작업을 위해 jQuery를 사용했지만 네이티브로 가고 싶다면 아이디어를 얻었습니다.

---

배열에 여러 번 존재하는 값을 제거해야하는 경우 (예 : [1,2,2,2, 4, 5,6]).

    function removeFrmArr(array, element) {
      return array.filter(e => e !== element);
    };
    var exampleArray = [1,2,3,4,5];
    removeFrmArr(exampleArray, 3);
    // return value like this
    //[1, 2, 4, 5]

스플 라이스를 사용하여 배열에서 단일 요소를 제거 할 수 있지만 스플 라이스는 배열에서 유사한 여러 요소를 제거 할 수 없습니다.

function singleArrayRemove(array, value){
  var index = array.indexOf(value);
  if (index > -1) array.splice(index, 1);
  return array;
}
var exampleArray = [1,2,3,4,5,5];
singleArrayRemove(exampleArray, 5);
// return value like this
//[1, 2, 3, 4, 5]

---

a very clean solution working in all browsers and without any framework is to asign a new Array and simply return it without the item you want to delete:

/**
 * @param {Array} array the original array with all items
 * @param {any} item the time you want to remove
 * @returns {Array} a new Array without the item
 */
var removeItemFromArray = function(array, item){
  /* assign a empty array */
  var tmp = [];
  /* loop over all array items */
  for(var index in array){
    if(array[index] !== item){
      /* push to temporary array if not like item */
      tmp.push(array[index]);
    }
  }
  /* return the temporary array */
  return tmp;
}

---

In all values unique, you can:

a = new Set([1,2,3,4,5]) // a = Set(5) {1, 2, 3, 4, 5}
a.delete(3) // a = Set(5) {1, 2, 4, 5} 
[...a] // [1, 2, 4, 5]

---

indexOf is an option, but it's implementation is basically searching the entire array for the value, so execution time grows with array size. (so it is in every browser I guess, I only checked Firefox).

I haven't got an IE6 around to check, but I'd call it a safe bet that you can check at least a million array items per second this way on almost any client machine. If [array size]*[searches per second] may grow bigger than a million you should consider a different implementation.

Basically you can use an object to make an index for your array, like so:

var index={'three':0, 'seven':1, 'eleven':2};

Any sane JavaScript environment will create a searchable index for such objects so that you can quickly translate a key into a value, no matter how many properties the object has.

This is just the basic method, depending on your need you may combine several objects and/or arrays to make the same data quickly searchable for different properties. If you specify your exact needs I can suggest a more specific data structure.

---

You can achieve this using Lodash _.remove function.

var array = ['three', 'seven', 'eleven'];
var evens = _.remove(array, function(e) {
  return e !== 'seven';
});

console.log(evens);

<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/lodash@4.17.10/lodash.min.js"></script>

---

The trick is to go through the array from end to beginning, so you don't mess up the indices while removing elements.

var deleteMe = function( arr, me ){
   var i = arr.length;
   while( i-- ) if(arr[i] === me ) arr.splice(i,1);
}

var arr = ["orange","red","black", "orange", "white" , "orange" ];

deleteMe( arr , "orange");

arr is now ["red", "black", "white"]

---

Non-destructive removal:

function removeArrayValue(array, value)
{
    var thisArray = array.slice(0); // copy the array so method is non-destructive

    var idx = thisArray.indexOf(value); // initialise idx

    while(idx != -1)
    {
        thisArray.splice(idx, 1); // chop out element at idx

        idx = thisArray.indexOf(value); // look for next ocurrence of 'value'
    }

    return thisArray;
}

---

You can use without or pull from Lodash:

const _ = require('lodash');
_.without([1, 2, 3, 2], 2); // -> [1, 3]

---

Please do not use the variant with delete - it makes a hole in the array as it does not re-index the elements after the deleted item.

> Array.prototype.remove=function(v){
...     delete this[this.indexOf(v)]
... };
[Function]
> var myarray=["3","24","55","2"];
undefined
> myarray.remove("55");
undefined
> myarray
[ '3', '24', , '2' ]

---

I used the most voted option and created a function that would clean one array of words using another array of unwanted words:

function cleanArrayOfSpecificTerms(array,unwantedTermsArray) {
  $.each(unwantedTermsArray, function( index, value ) {
    var index = array.indexOf(value);
    if (index > -1) {
      array.splice(index, 1);        
    }
  });
  return array;
}

To use, do the following:

var notInclude = ['Not','No','First','Last','Prior','Next', 'dogs','cats'];
var splitTerms = ["call", "log", "dogs", "cats", "topic", "change", "pricing"];

cleanArrayOfSpecificTerms(splitTerms,notInclude)

---

let arr = [5, 15, 25, 30, 35];
console.log(arr); //result [5, 15, 25, 30, 35]
let index = arr.indexOf(30);

if (index > -1) {
   arr.splice(index, 1);
}
console.log(arr); //result [5, 15, 25, 35]

---

In a global function we can't pass a custom value directly but there are many way as below

 var ary = ['three', 'seven', 'eleven'];
 var index = ary.indexOf(item);//item: the value which you want to remove

 //Method 1
 ary.splice(index,1);

 //Method 2
 delete ary[index]; //in this method the deleted element will be undefined

---

var remove = function(array, value) {
    var index = null;

    while ((index = array.indexOf(value)) !== -1)
        array.splice(index, 1);

    return array;
};

---

I tried using the function method from jbaron above but found that I needed to keep the original array intact for use later, and creating a new array like this:

var newArray = referenceArray;

apparently creates by reference instead of value because when I removed an element from newArray the referenceArray also had it removed. So I decided to create a new array each time like this:

function newArrRemoveItem(array, item, newArray){
    for(var i = 0; i < array.length; i++) {
        if(array[i]!=item){
            newArray.push(array[i]);
        }
    }
}

Then I use it like this in another function:

var vesselID = record.get('VesselID');
var otherVessels = new Array();
newArrRemoveItem(vesselArr,vesselID,otherVessels);

Now the vesselArr remains intact while each time I execute the above code the otherVessels array includes all but the latest vesselID element.

참고URL : https://stackoverflow.com/questions/3954438/how-to-remove-item-from-array-by-value