for (var i in items) { ... }

Then it always gave me an error, and I don’t understand why.

I later know that i was “length”.

Very good technique. Too bad I don’t do so much OOPs.

The new YUI JSON singleton provides the same functionality without adding Object.toJsonString (Instead: YAHOO.lang.JSON.parse() or .stringify())

Although, safety with for-in loops should always be considered (in JS anyways).

David, although, I agree that Associative JavaScript Arrays technically don’t exist (they are simply objects) and should never be used. It is still possible to syntactically create them.

Florin, you are absolutely right, it is much faster to know what you are testing for and just test against it. I however, have used Functions as members of an Array on more than one occasion.

Mills, I like your approach and will have to explore it more.

As an example. I want any object I use in my library to be able to find their own attributes.
So here’s how I might go about doing that…

var ExtendedObject = function(obj) {
for(var attr in obj) {this[attr] = obj[attr];
}

ExtendedObject.prototype.findAttribute = () {
…//Put code here
}

This allows me to create my own extended object like this.

var obj = new ExtendedObject({test: ‘test’});

The native object has not been changed, so someone else is free to use the object however they wish. You can determine if the object is of type ExtendedObject by using the instanceof operator. Additionaly, you’d probably want to have an ExtendedObject.prototype.stripObject function that filters your extended object.

The only major drawback is that you have to use “new ExtendedObject” (or whatever you choose to call it), everytime you want to create an object, rather than just “{}”. It’s only a drawback in size, though…in return you get code that works well with others.

anyways i find it easyer and faster to test the type of the element in the loop depending on the situation.
for (var i in obj) {
if (typeof obj[i] != ‘function’) {
}
}

I guess your code is very usefull when u nead to iterate thru methods also.

With this discipline, it’s perfectly acceptable to extend Array.prototype since you shouldn’t be iterating over arrays using for .. in anyway. Use a conventional for or while loop instead, and leave for .. in to object literals. (Of course, it’s still bad practice to extend Object.prototype for this reason.)