Javascript how to use setTimeout on an iterative list operation?

This is what you probably want:

for(var i=0;i<aList.length;i++)
{
    (function(i){
        // Retain `i` in this scope, for use later (after timeout)
        setTimeout(function(){
           aList[i].doSomething();
        }, 500 * i);
    })(i);
}

You want the 500 * i so that each step is 500ms later than the last, otherwise everything will happen at once after 500ms. Notice the extra wrapping function -- this essentially traps/retains the value of i.

One of the variants:

var array = [/*elements*/],
    i,
    length = array.length,
    loop = setInterval(function() {
        array[i].doSomething();
        i += 1;
        if (i === length) {
            clearInterval(loop);
        }
    }, 500);

Just define the function before the timeout

for(var i=0; nextFunction = aList[i];i++) {
    var waitAndDoSomething = function(func) {
        return function() { func.doSomething(); }
    };
    setTimeout(waitAndDoSomething(nextFunction),500*i);  
}

Another Possible Answer

At minitect's suggestion, I started to think about other possible solutions. A solution that I feel comes out clean is to use bind

String.prototype.doSomething = function() { alert(this); } // Just for testing
var aList = ['one', 'two', 'three']; // Just for testing

for(var i=0;obj = aList[i];i++) { 
    setTimeout(obj.doSomething.bind(obj),500*i); 
}

However, I am not sure how well this would work in the context of Razor Storm's question because I don't know what aList[i] would represent.

Does this answer the question

I also wonder if this is the intended behavior. It will not actually sleep after the execution but rather sets timing. This can be deceiving, but if we really want to execute a function and then sleep for a half a second before the next one our timing is off here. Instead I would use recursion:

String.prototype.doSomething = function() { alert(this); }
var aList = ['one', 'two', 'three'];

var doNextSomething = function(index) {
    if (!index) { index = 0 }
    if (nextObject = aList[index]) {
        nextObject.doSomething();
        setTimeout(doNextSomething, 500, index + 1);    
    }
};

doNextSomething();

Now, it will wait for 500 milliseconds after the function is executed (evident in a long running task).

I think that the answers posted were more what Razor Storm had it mind though.

before the for loop do something like:

var _aList = aList;

Within the loop you have to setTimeout and the delay 500 * i.

So the result will be:

var _aList = aList;
for(var i=0;i<aList.length;i++)
{
    (function(obj, index) {
        setTimeout(function(){
           obj.doSomething();
        },500 * index); 
    })(aList[i], i);
}