Hoe verwijdert u item van array per waarde? [DUPLICEER]

Is er een methode om een ​​item uit een JavaScript-array te verwijderen?

Gegeven een array:

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

Ik zou graag iets willen doen als:

removeItem('seven', ary);

Ik heb onderzocht in splice()maar die alleen door het positienummer verwijdert, terwijl ik iets nodig heb om een ​​item te verwijderen door zijn waarde.

Antwoord 1, Autoriteit 100%

Dit kan een wereldwijde functie of een methode van een aangepast object zijn, als u niet mag toevoegen aan native prototypes. Het verwijdert alle items uit de array die overeenkomt met een van de argumenten.

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
*/

om het een wereldwijd te maken –

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
*/

en om voor IE8 en hieronder te zorgen –

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

Antwoord 2, autoriteit 96%

U kunt de methode indexOfgebruikenzoals dit:

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

Opmerking: U zult moet het opvullen voor IE8 en lager

Antwoord 3, autoriteit 93%

Een oneliner zal het doen,

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

Dit maakt gebruik van de filter-functie in JS. Het wordt ondersteund in IE9 en hoger.

Wat het doet (van de doc-link)

Filter () noemt een meegeleverde callback-functie eenmaal voor elk element in een array en construeert een nieuwe reeks van alle waarden waarvoor callback een waarde retourneert die dwingt. Terugbellen wordt alleen ingeroepen voor indexen van de array die waarden heeft toegewezen; Het wordt niet aangeroepen voor indexen die zijn verwijderd of die nooit waarden zijn toegewezen. Array-elementen die niet doorgeven aan de callback-test zijn eenvoudig overgeslagen en zijn niet opgenomen in de nieuwe array.

Zo eigenlijk is dit hetzelfde als de andere for (var key in ary) { ... }oplossingen, behalve dat de for inConstruct wordt ondersteund vanaf IE6.

In principe is filter een gemaksmethode die er veel leuker uitziet (en lekker is) in tegenstelling tot de for inconstructie (AFAIK).

Antwoord 4, Autoriteit 26%

U kunt underscore.js gebruiken. Het maakt het echt eenvoudig.

Bijvoorbeeld, hiermee:

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

en resultZal ['three','eleven'].

In uw geval is de code die u moet schrijven:

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

Het vermindert de code die u schrijft.

Antwoord 5, Autoriteit 12%

U kunt het met deze twee manieren doen:

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

1. De eerste manier:

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

2. De tweede manier (ES6) speciaal zonder muteren:

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

Antwoord 6, autoriteit 10%

Bekijk op deze manier:

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

en in een functie:

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

Antwoord 7, autoriteit 8%

De eenvoudigste oplossing is:

array – array voor het verwijderen van een element valueForRemove;
valueForRemove – element om te verwijderen;

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

Eenvoudiger:

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

Niet mooi, maar werkt:

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

Niet mooi, maar werkt:

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

P.S. De methode filter() maakt een nieuwe array met alle elementen die de test doorstaan die door de geleverde functie is geïmplementeerd. Zie https://developer.mozilla.org/ nl-NL/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Antwoord 8, autoriteit 7%

Hier is een versie die de inArray-functievan jQuery gebruikt:

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

Antwoord 9, autoriteit 6%

Gewoon

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

Antwoord 10, autoriteit 6%

U kunt uw eigen methode maken, waarbij u door de array gaat en de waarde die u wilt verwijderen:

function removeItem(arr, item){
 return arr.filter(f => f !== item)
}

Dan kun je dit aanroepen met:

ary = removeItem(ary, 'seven');

Antwoord 11, autoriteit 6%

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

Antwoord 12, autoriteit 3%

Wat je zoekt is filteren

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

Hiermee kunt u het volgende doen:

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

Dit werd ook ergens anders in deze thread opgemerkt: https://stackoverflow.com/a/20827100/293492

Antwoord 13, autoriteit 3%

ES6 manier.

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

Antwoord 14, autoriteit 3%

Aangezien er geen mooie is, is hier een eenvoudige en herbruikbare ES6-functie.

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

Gebruik:

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

Antwoord 15, autoriteit 2%

Als u een waarde meerdere keren in de array moet verwijderen (bijv. [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]

Je kunt splice gebruiken om een enkel element uit de array te verwijderen, maar splice kan niet meerdere vergelijkbare elementen uit de array verwijderen.

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]

Antwoord 16, autoriteit 2%

Ik begrijp echt niet waarom dit niet kan worden opgelost met

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

Of misschien wil je vanilla JS gebruiken

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

Antwoord 17, autoriteit 2%

Als je unieke waarden in je array hebt en de volgorde maakt niet uit, dan kun je Setgebruiken, en het heeft 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.

Antwoord 18

In alle unieke waarden kunt u:

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]

Antwoord 19

Alle overeenkomende elementen uit de array verwijderen (in plaats van alleen de eerste, zoals hier het meest voorkomende antwoord lijkt te zijn):

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

Ik heb jQuery gebruikt voor het zware werk, maar je snapt het idee als je native wilt gaan.

Antwoord 20

een zeer schone oplossing die in alle browsers en zonder enig framework werkt, is om een nieuwe array toe te wijzen en deze eenvoudig terug te sturen zonder het item dat u wilt verwijderen:

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

Antwoord 21

U kunt dit bereiken met Lodash_.removefunctie.

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/[email protected]/lodash.min.js"></script>

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

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

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

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

var remove = function(array, value) {
    var index = null;
    while ((index = array.indexOf(value)) !== -1)
        array.splice(index, 1);
    return array;
};

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

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

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]

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