Wsrtjtyk

This is a pretty common issue. The solution is to loop backwards:

for (var i = Auction.auctions.length - 1; i >= 0; i--) {

    Auction.auctions[i].seconds--;

    if (Auction.auctions[i].seconds < 0) { 

        Auction.auctions.splice(i, 1);

    }

}

It doesn't matter if you're popping them off of the end because the indices will be preserved as you go backwards.

Recalculate the length each time through the loop instead of just at the outset, e.g.:

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

      auction = Auction.auctions[i];

      Auction.auctions[i]['seconds'] --;

      if (auction.seconds < 0) { 

          Auction.auctions.splice(i, 1);

          i--; //decrement

      }

}

That way you won't exceed the bounds.

EDIT: added a decrement in the if statement.

Although your question is about deleting elements from the array being iterated upon and not about removing elements (in addition to some other processing) efficiently, I think one should reconsider it if in similar situation.

The algorithmic complexity of this approach is O(n^2) as splice function and the for loop both iterate over the array (splice function shifts all elements of array in the worst case). Instead you can just push the required elements to the new array and then just assign that array to the desired variable (which was just iterated upon).

var newArray = ;

for (var i = 0, len = Auction.auctions.length; i < len; i++) {

    auction = Auction.auctions[i];

    auction.seconds--;

    if (!auction.seconds < 0) { 

        newArray.push(auction);

    }

}

Auction.auctions = newArray;

Since ES2015 we can use Array.prototype.filter to fit it all in one line:

Auction.auctions = Auction.auctions.filter(auction => --auction.seconds >= 0);

Auction.auction = Auction.auctions.filter(function(el) {

  return --el["seconds"] > 0;

});

Here is another example for the proper use of splice. This example is about to remove 'attribute' from 'array'.

for (var i = array.length; i--;) {

    if (array[i] === 'attribute') {

        array.splice(i, 1);

    }

}

Another simple solution to digest an array elements once:

while(Auction.auctions.length){

    // From first to last...

    var auction = Auction.auctions.shift();

    // From last to first...

    var auction = Auction.auctions.pop();



    // Do stuff with auction

}

If you are e using ES6+ - why not just use Array.filter method?

Auction.auctions = Auction.auctions.filter((auction) => {

  auction['seconds'] --;

  return (auction.seconds > 0)

})  

Note that modifying the array element during filter iteration only works for objects and will not work for array of primitive values.

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

        i--;

        len--;

    }

}

Try to relay an array into newArray when looping:

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;

You can just look through and use shift()

There are lot of wonderful answers on this thread already. However I wanted to share my experience when I tried to solve "remove nth element from array" in ES5 context.

JavaScript arrays have different methods to add/remove elements from start or end. These are:

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 

Essentially none of the above methods can be used directly to remove nth element from the array.

A fact worth noting is that this is in contrast with java iterator's
using which it is possible to remove nth element for a collection
while iterating.

This essentially leaves us with only one array method Array.splice to perform removal of nth element (there are other things you could do with these methods as well, but in the context of this question I am focusing on removal of elements):

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

Here is the code copied from original answer (with comments):

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

}

Another noteworthy method is Array.slice. However the return type of this method is the removed elements. Also this doesn't modify original array. Modified code snippet as follows:

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

  }

}

Having said that, we can still use Array.slice to remove nth element in the following way and as you can observe it is lot more code (hence inefficient)

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

  }



}

The Array.slice method is extremely important to achieve
immutability in functional programming à la redux