One of the misleading things of

for(var i = 0; i < arr.length; i++) { }

is "i" is hoisted to the top of the object scope and not contained within the for loop. I would suggest declaring it outside the loop at the top as a general practice and then setting it like so:

// declared at top of object scope (function scope)
var i;
// … code
for(i = 0; i < arr.length; i++) { }

This is anal but its important for people not to misunderstand how JavaScript works as you are getting a lot of traffic so you have more responsibility to be a good role model. Lots of good stuff here by the way.

Maybe I should do a short post about it on my blog, but I’m not 100% sure. We’ll see.

It will be very useful this tuts for me!!

Just to complement, look some of my posts about Javascript Design Patterns

http://www.udgwebdev.com/design-patterns-para-javascript-parte-1/

http://www.udgwebdev.com/design-patterns-para-javascript-parte-2/

I know its in portuguese, but I’m very proud to be a brazilian! 😀

Yes, I know about forEach. The reason I wrote it that way was as an example to show the implementation (which definitely isn’t ES5 compliant), for his “expressive diversity” thing.

A regular for loop is always going to be faster than a forEach call. Method calls are expensive, the browser has to allocate a new function object, and the callback function is called for every element of the array. Compared to a low-level loop, it’s quite slow.

@Rob:

BAD IDEA.

Object.prototype.method = function () { return 42; };
Array.prototype.func = function () { return 'beef'; };

var o = {
  p1: 1,
  p2: 2,
  p3: 3
};
 
var a = [1, 2, 3];
 
for(var i in o) {
  alert(o[i]);
}
// Alerts 1, 2, 3, function () { return 42; }
 
for(var i in a) {
  alert(a[i]);
}
// Alerts 1, 2, 3, function () { return 'beef'; }, function () { return 42; }

This can be fixed by adding a hasOwnProperty check to the loops:

(function (hasOwn) {

var i;

for (i in o) {
  if (hasOwn.call(o, i))
    alert(o[i]);
}
// Alerts 1, 2, 3

for (i in a) {
  if (hasOwn.call(a, i))
    alert(a[i]);
}
// Alerts 1, 2, 3

})({}.hasOwnProperty);

But you shouldn’t do that with arrays because it’s really slow. Even a forEach call is faster.

@Strx: That’s cute. I usually use + for coercion to a number, but that returns NaN for ‘a’, undefined, function () { }, etc (all of which ~~ returns 0 for). Still, + is going to be faster, and ~~ floors the operand (incorrectly no less, try ~~-1.2).

@Tom: -‘222’ returns -222. You probably want -(-‘222′) which behaves exactly the same as +’222’ (where ‘222’ can be anything).

typeof num; // => ‘number’

+ is used for string concatenation as well, so I don’t really know if it’s a good idea to use it?

Thanks again. Darragh

For your last example you could do

var obj = {
    value: 234,
    fn: function(){ return this.value; }
};
 
obj.fn(); // = 234
 
var fn = obj.fn;
fn.call(obj); // = 234