Schleife durch Array und Entfernen von Elementen, ohne die for-Schleife zu unterbrechen

Question

Ich habe die folgende for-Schleife, und wenn ich verwenden splice() um ein Element zu entfernen, erhalte ich die Meldung, dass "Sekunden" nicht definiert ist. Ich könnte überprüfen, ob es undefiniert ist, aber ich denke, es gibt wahrscheinlich einen eleganteren Weg, dies zu tun. Der Wunsch ist es, einfach ein Element zu löschen und weiterzumachen.

for (i = 0, len = Auction.auctions.length; i < len; i++) {
    auction = Auction.auctions[i];
    Auction.auctions[i]['seconds'] --;
    if (auction.seconds < 0) { 
        Auction.auctions.splice(i, 1);
    }           
}

Answer 1

Zwei Beispiele, die funktionieren:

Beispiel EINS

// Remove from Listing the Items Checked in Checkbox for Delete
let temp_products_images = store.state.c_products.products_images
if (temp_products_images != null) {
    for (var l = temp_products_images.length; l--;) {
        // 'mark' is the checkbox field
        if (temp_products_images[l].mark == true) {
            store.state.c_products.products_images.splice(l,1);         // THIS WORKS
            // this.$delete(store.state.c_products.products_images,l);  // THIS ALSO WORKS
        }
    }
}

Beispiel ZWEI

// Remove from Listing the Items Checked in Checkbox for Delete
let temp_products_images = store.state.c_products.products_images
if (temp_products_images != null) {
    let l = temp_products_images.length
    while (l--)
    {
        // 'mark' is the checkbox field
        if (temp_products_images[l].mark == true) {
            store.state.c_products.products_images.splice(l,1);         // THIS WORKS
            // this.$delete(store.state.c_products.products_images,l);  // THIS ALSO WORKS
        }
    }
}

Answer 2

Warum CPU-Zyklen für .splice verschwenden? Diese Operation muss immer wieder die gesamte Schleife durchlaufen, um ein Element aus einem Array zu entfernen.

warum nicht einfach die traditionellen 2 Flaggen in einer Schleife verwenden?

const elements = [1, 5, 5, 3, 5, 2, 4];
const remove = 5

i = 0

for(let j = 0; j < elements.length; j++){
  if (elements[j] !== remove) {
    elements[i] = elements[j]
    i++
  }
}
elements.length = i

Answer 3

Versuchen Sie das mal

RemoveItems.forEach((i, j) => {
    OriginalItems.splice((i - j), 1);
});

Answer 4

Versuchen Sie, ein Array in newArray weiterzugeben, wenn Sie eine Schleife durchlaufen:

var auctions = Auction.auctions;
var auctionIndex;
var auction;
var newAuctions = [];

for (
  auctionIndex = 0; 
  auctionIndex < Auction.auctions.length;
  auctionIndex++) {

  auction = auctions[auctionIndex];

  if (auction.seconds >= 0) { 
    newAuctions.push(
      auction);
  }    
}

Auction.auctions = newAuctions;

Answer 5

Es gibt bereits viele wunderbare Antworten in diesem Thread. Ich wollte jedoch meine Erfahrung teilen, als ich versuchte, "n-te Element aus Array entfernen" in ES5-Kontext zu lösen.

JavaScript-Arrays haben verschiedene Methoden zum Hinzufügen/Entfernen von Elementen am Anfang oder Ende. Diese sind:

arr.push(ele) - To add element(s) at the end of the array 
arr.unshift(ele) - To add element(s) at the beginning of the array
arr.pop() - To remove last element from the array 
arr.shift() - To remove first element from the array 

Im Wesentlichen kann keine der oben genannten Methoden direkt verwendet werden, um das n-te Element aus dem Array zu entfernen.

Es ist erwähnenswert, dass dies im Gegensatz zu Java-Iterator's mit denen es möglich ist, das n-te Element einer Sammlung zu entfernen während der Iteration zu entfernen.

Damit bleibt uns im Grunde nur noch eine Array-Methode Array.splice um das n-te Element zu entfernen (es gibt noch andere Dinge, die man mit diesen Methoden tun könnte, aber im Zusammenhang mit dieser Frage konzentriere ich mich auf das Entfernen von Elementen):

Array.splice(index,1) - removes the element at the index 

Hier ist der Code aus der ursprünglichen Antwort kopiert (mit Kommentaren):

var arr = ["one", "two", "three", "four"];
var i = arr.length; //initialize counter to array length 

while (i--) //decrement counter else it would run into IndexOutBounds exception
{
  if (arr[i] === "four" || arr[i] === "two") {
    //splice modifies the original array
    arr.splice(i, 1); //never runs into IndexOutBounds exception 
    console.log("Element removed. arr: ");

  } else {
    console.log("Element not removed. arr: ");
  }
  console.log(arr);
}

Eine weitere bemerkenswerte Methode ist Array.slice . Der Rückgabetyp dieser Methode sind jedoch die entfernten Elemente. Außerdem wird das ursprüngliche Array dadurch nicht verändert. Geänderter Codeschnipsel wie folgt:

var arr = ["one", "two", "three", "four"];
var i = arr.length; //initialize counter to array length 

while (i--) //decrement counter 
{
  if (arr[i] === "four" || arr[i] === "two") {
    console.log("Element removed. arr: ");
    console.log(arr.slice(i, i + 1));
    console.log("Original array: ");
    console.log(arr);
  }
}

Allerdings können wir immer noch die Array.slice um das n-te Element wie unten gezeigt zu entfernen. Es ist jedoch viel mehr Code (daher ineffizient)

var arr = ["one", "two", "three", "four"];
var i = arr.length; //initialize counter to array length 

while (i--) //decrement counter 
{
  if (arr[i] === "four" || arr[i] === "two") {
    console.log("Array after removal of ith element: ");
    arr = arr.slice(0, i).concat(arr.slice(i + 1));
    console.log(arr);
  }

}

Le site Array.slice Methode ist äußerst wichtig, um Folgendes zu erreichen Unveränderlichkeit in der funktionalen Programmierung à la redux