const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
console.log(output)

Antwoord 18

Je kunt lodash _.pullgebruiken (array muteren), _.pullAt(array muteren) of _.zonder(muteert array niet),

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

Antwoord 19

Het verwijderen van een bepaald element/string uit een array kan in een one-liner:

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

waar:

theArray: de array waarvan u iets specifieks wilt verwijderen

stringToRemoveFromArray: de tekenreeks die u wilt verwijderen en 1 is het aantal elementen dat u wilt verwijderen.

OPMERKING: Als “stringToRemoveFromArray” niet in de array staat, wordt het laatste element van de array verwijderd.

Het is altijd een goede gewoonte om eerst te controleren of het element in uw array bestaat, voordat u het verwijdert.

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

Afhankelijk van of u een nieuwere of oudere versie van Ecmascript op de computers van uw klant heeft:

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

OF

var array = ['1','2','3','4','5','6'];
var newArray = array.filter(function(item){ return item !== '3' });

Waarbij ‘3’ de waarde is die u uit de array wilt verwijderen.
De array wordt dan: ['1','2','4','5','6']

Antwoord 20

Prestaties

Vandaag (2019-12-09) voer ik prestatietests uit op macOS v10.13.6 (High Sierra) voor gekozen oplossingen. Ik toon delete(A), maar ik gebruik het niet in vergelijking met andere methoden, omdat het lege ruimte in de array liet.

De conclusies

• de snelste oplossing is array.splice(C) (behalve Safari voor kleine arrays waar het de tweede keer is)
• voor grote arrays is array.slice+splice(H) de snelste onveranderlijke oplossing voor Firefox en Safari; Array.from(B) is het snelst in Chrome
• veranderlijke oplossingen zijn meestal 1,5x-6x sneller dan onveranderlijke
• voor kleine tabellen in Safari is verrassend genoeg de veranderlijke oplossing (C) langzamer dan de onveranderlijke oplossing (G)

Details

In tests verwijder ik het middelste element op verschillende manieren uit de array. De A, C-oplossingen zijn aanwezig. De B, D, E, F, G, Hoplossingen zijn onveranderlijk.

Resultaten voor een array met 10 elementen

In Chrome is de array.splice(C) de snelste interne oplossing. De array.filter(D) is de snelste onveranderlijke oplossing. De langzaamste is array.slice(F). U kunt de test hieruitvoeren op uw computer.

Resultaten voor een array met 1.000.000 elementen

In Chrome is de array.splice(C) de snelste oplossing ter plaatse (de delete(C) is even snel – maar er bleef een lege plek in de array (zodat deze geen ‘volledige verwijdering’ uitvoert)). De array.slice-splice(H) is de snelste onveranderlijke oplossing. De langzaamste is array.filter(D en E). U kunt de test hierop uw computer uitvoeren.

Antwoord 21

OK,u heeft bijvoorbeeld de onderstaande array:

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

En we willen nummer 4 verwijderen. Je kunt gewoon de onderstaande code gebruiken:

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

Als je deze functie hergebruikt, schrijf je een herbruikbare functie die wordt toegevoegd aan de nativearrayfunctie zoals hieronder:

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

Maar hoe zit het als je in plaats daarvan de onderstaande array hebt met een paar [5]en in de array?

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

We hebben een lus nodig om ze allemaal te controleren, maar een eenvoudigere en efficiëntere manier is het gebruik van ingebouwde JavaScript-functies, dus schrijven we een functie die in plaats daarvan een filter gebruikt zoals hieronder:

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]

Er zijn ook bibliotheken van derden die u hierbij helpen, zoals Lodash of Underscore. Kijk voor meer informatie op lodash _.pull, _.pullAt of _.without.

Antwoord 22

Ik ben vrij nieuw in JavaScript en had deze functionaliteit nodig. Ik schreef alleen dit:

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

En wanneer ik het wil gebruiken:

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

Uitvoer – Zoals verwacht.
[“item1”, “item1”]

Misschien heb je andere behoeften dan ik, dus je kunt ze gemakkelijk aanpassen. Ik hoop dat dit iemand helpt.

Antwoord 23

Als je complexe objecten in de array hebt, kun je dan filters gebruiken?
In situaties waar $.inArray of array.splice niet zo gemakkelijk te gebruiken is. Vooral als de objecten misschien ondiep zijn in de array.

Bijvoorbeeld als u een object heeft met een ID-veld en u wilt dat het object uit een array wordt verwijderd:

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

Antwoord 24

Ik wil antwoorden op basis van ECMAScript 6. Stel dat je een array hebt zoals hieronder:

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

Als je wilt verwijderen met een speciale index zoals 2, schrijf dan de onderstaande code:

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

Maar als je een speciaal item zoals 3wilt verwijderen en je weet de index niet, doe dan als volgt:

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

Hint: gebruik een pijlfunctie voor filtercallback, tenzij u een lege array krijgt.

Antwoord 25

Bijwerken:deze methode wordt alleen aanbevolen als u ECMAScript 2015 (voorheen bekend als ES6) niet kunt gebruiken. Als je het kunt gebruiken, bieden andere antwoorden hier veel nettere implementaties.

Deze kern hierlost uw probleem op en verwijdert ook alle exemplaren van het argument in plaats van slechts 1 (of een opgegeven waarde).

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

Gebruik:

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]

Antwoord 26

ES10-update

Dit bericht vat algemene benaderingen samen voor het verwijderen van elementen uit een array vanaf ECMAScript 2019 (ES10).

1. Algemene gevallen

1.1. Array-element op waarde verwijderen met .splice()

| Ter plaatse: Ja |
| Verwijdert duplicaten: Yes(loop), No(indexOf) |
| Op waarde / index: op index |

Als u de waarde weet die u uit een array wilt verwijderen, kunt u de splice-methode gebruiken. Eerst moet u de index van het doelitem identificeren. U gebruikt dan de index als startelement en verwijdert slechts één element.

// With a 'for' loop
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for( let i = 0; i < arr.length; i++){
  if ( arr[i] === 5) {
    arr.splice(i, 1);
  }
} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
// With the .indexOf() method
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf(5);
arr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

1.2. Array-element verwijderen met de methode .filter()

| Ter plaatse: Nee |
| Verwijdert duplicaten: Ja |
| Op waarde / index: op waarde |

Het specifieke element kan uitgefilterd wordenuit de array door middel van een filterfunctie. Zo’n functie wordt dan aangeroepen voor elk element in de array.

const value = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter(item => item !== value)
console.log(arr)
// [ 1, 2, 4, 5 ]

1.3. Array-element verwijderen door Array.prototype

uit te breiden

| In-place: Ja/Nee (afhankelijk van implementatie) |
| Verwijdert duplicaten: Ja/Nee (afhankelijk van implementatie) |
| Op waarde / index: op index / op waarde (afhankelijk van implementatie) |

Het prototype van Array kan worden uitgebreid met aanvullende methoden. Dergelijke methoden zijn dan beschikbaar voor gebruik op gemaakte arrays.

Opmerking:Het uitbreiden van prototypes van objecten uit de standaardbibliotheek van JavaScript (zoals Array) wordt door sommigen als een antipatroon beschouwd.

// In-place, removes all, by value implementation
Array.prototype.remove = function(item) {
    for (let i = 0; i < this.length; i++) {
        if (this[i] === item) {
            this.splice(i, 1);
        }
    }
}
const arr1 = [1,2,3,1];
arr1.remove(1) // arr1 equals [2,3]
// Non-stationary, removes first, by value implementation
Array.prototype.remove = function(item) {
    const arr = this.slice();
    for (let i = 0; i < this.length; i++) {
        if (arr[i] === item) {
            arr.splice(i, 1);
            return arr;
        }
    }
    return arr;
}
let arr2 = [1,2,3,1];
arr2 = arr2.remove(1) // arr2 equals [2,3,1]

1.4. Array-element verwijderen met de operator delete

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde / index: op index |

Het gebruik van de delete-operator heeft geen invloed op de eigenschap length. Het heeft ook geen invloed op de indexen van volgende elementen. De array wordt schaars, wat een mooie manier is om te zeggen dat het verwijderde item niet wordt verwijderd, maar ongedefinieerd wordt.

const arr = [1, 2, 3, 4, 5, 6];
delete arr[4]; // Delete element with index 4
console.log( arr ); // [1, 2, 3, 4, undefined, 6]

De delete-operator is ontworpen om eigenschappen van JavaScript-objecten te verwijderen, welke arrays objecten zijn.

1.5. Array-element verwijderen met behulp van Object-hulpprogramma’s (>= ES10)

| Ter plaatse: Nee |
| Verwijdert duplicaten: Ja |
| Op waarde / index: op waarde |

ES10 introduceerde Object.fromEntries, dat kan worden gebruikt om de gewenste array te maken van elk array-achtig object en ongewenste elementen tijdens het proces te filteren.

const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values(Object.fromEntries(
  Object.entries(object)
  .filter(([ key, val ]) => val !== valueToRemove)
));
console.log(arr); // [1,2,4]

2. Speciale gevallen

2.1 Element verwijderen als het aan het einde van de array staat

2.1.1. Array lengthwijzigen

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde/index: n.v.t. |

JavaScript-array-elementen kunnen aan het einde van een array worden verwijderd door de eigenschap length in te stellen op een waarde die kleiner is dan de huidige waarde. Elk element waarvan de index groter is dan of gelijk is aan de nieuwe lengte wordt verwijderd.

const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
console.log( arr ); // [1, 2, 3, 4, 5]

2.1.2. Met behulp van de .pop()methode

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde/index: n.v.t. |

De pop-methode verwijdert het laatste element van de array, retourneert dat element en werkt de eigenschap length bij. De pop-methode wijzigt de array waarop deze wordt aangeroepen. Dit betekent dat, in tegenstelling tot het gebruik van delete, het laatste element volledig wordt verwijderd en de lengte van de array wordt verminderd.

const arr = [1, 2, 3, 4, 5, 6];
arr.pop(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]

2.2. Element verwijderen als het aan het begin van de array staat

| Ter plaatse: Ja |
| Verwijdert duplicaten: Nee |
| Op waarde/index: n.v.t. |

De methode .shift()werkt ongeveer hetzelfde als de methode pop, behalve dat het het eerste element van een JavaScript-array verwijdert in plaats van het laatste. Wanneer het element wordt verwijderd, worden de overige elementen naar beneden geschoven.

const arr = [1, 2, 3, 4];
arr.shift(); // returns 1
console.log( arr ); // [2, 3, 4]

2.3. Element verwijderen als dit het enige element in de array is

| Ter plaatse: Ja |
| Verwijdert duplicaten: N.v.t. |
| Op waarde/index: n.v.t. |

De snelste techniek is om een ​​arrayvariabele op een lege array in te stellen.

let arr = [1];
arr = []; //empty array

Als alternatief kan de techniek van 2.1.1 worden gebruikt door de lengte in te stellen op 0.

Antwoord 27

U mag uw array nooit muteren. Omdat dit in strijd is met het functionele programmeerpatroon. U kunt een nieuwe array maken zonder te verwijzen naar de array waarvan u de gegevens wilt wijzigen met behulp van de ECMAScript 6-methode filter;

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

Stel dat u 5uit de array wilt verwijderen, dan kunt u dat eenvoudig als volgt doen:

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

Dit geeft je een nieuwe array zonder de waarde die je wilde verwijderen. Het resultaat is dus:

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

Voor meer begrip kunt u de MDN-documentatie lezen op Array.filter.

Antwoord 28

Je kunt een achterwaartse lus maken om ervoor te zorgen dat je de indexen niet verknoeit, als er meerdere instanties van het element zijn.

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);
}
console.log(myArray);

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

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

[1, 2, 4]

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