For me it depends on the task; generally I try to avoid anything that introduces the overhead of function calls on each iteration; a problem with JS Object.forEach and callbacks is it introduces overhead and by definition should be significantly slower on simpler tasks than a simple for loop.
But the question is WHY am I looping and WHAT am I processing. Each of the methods exists for different purposes. I'm soften surprised that you don't see do/while more, though you'll see while/do all the time. MAYBE it's because my first high level language was pascal with it's repeat/until structure, maybe it's because my first programming language was assembly where you load the count and only do logic AFTER an iteration, but the repeat/until (pascal) aka do/while (c, php, js, every other C syntax language) structure is the one that just makes more sense in my head.
Certainly far more sense than setting up a new stack reference, copying values or a pointer onto the stack, and making a far call -- which is what the object based 'each' is basically having to do under the hood to function.
Though with JavaScript arrays being so painfully and agonizingly slow (since they're pointered lists not true arrays of fixed size) it likely makes little difference in that environment.
STILL, most benchmarks and engines for JavaScript will STILL tell you that
for (var i = 0, iLen = a.length; i < iLen; i++) {
is going to be WAY faster than Array.each, though how much faster would depend entirely on what you are doing inside the loop.
Also in JS I still have to support legacy UA's where Array.each and Object.forEach simply don't exist yet, and rather than polyfills I just use classical "for".
I mean hell, look at the code I was just reviewing to see if I could squeeze a hair more performance from it:
; procedure stickUpdate;
pProcNoArgs stickUpdate
mov dx, 0x201
mov cx, stickLimit
xor ax, ax
mov bx, ax
mov di, ax
mov si, ax
mov ah, [stickMask]
push bp
mov bp, bx
cli
.loop:
in al, dx
and al, ah
ror al, 1
adc bx, 0
ror al, 1
adc di, 0
ror al, 1
adc si, 0
ror al, 1
adc bp, 0
or al, al
loopnz .loop
sti
mov [stickData], bx
mov [stickData + 2], di
mov [stickData + 4], si
mov [stickData + 6], bp
pop bp
retf
So... basically the right tool for the right job. Answer varies depending on which language, what's being processed, and even what the target runtime environment is. You can do a lot of stuff in node.js thanks to it being a standalone of V8 you can't do on a website using the same language, since Christmas only knows how much of ECMAScript 262-5, much less -6 is even available to you.