for each (n in nodes) is faster than for (i=0; …) though.

I ask about the 1.7 iterators because I was curious if they captured all of what you are trying to do.

Do you know if it is possible with JS 1.7 to, for instance, apply a forEach() method to an HTML Collection object? This is the best I could come up with:

var nodes = Iterator(document.getElementsByTagName(”input”))
for ( n in nodes )
if ( n[1].getAttribute(”type”) == “text” )
n[1].value = null

But that doesn’t seem any different than:

var nodes = document.getElementsByTagName(”input”)
for ( let i = 0; i

JavaScript 1.7’s iterators *are* what I proposed here, plus other enhancements. They effectively tracked Python 2.5’s iterators.

Second, now that Javascript 1.7 is available with built in Python-esque iterators, how does that compare with what you were trying to achieve?

Property enumeration is only really useful for debugging, since chances are the objects will have a lot of properties that you do not want them to have, and there is no standard way to have properties that are hidden from enumeration.

This is a gross exageration. There’s an easy way to transform an array into an associative array such that you can iterate over it using the ‘in’ syntax. A simple example:


function arrayIter(array)
{
var obj = {};
for (var i = 0; i < array.length; i++)
{
obj[array[i]] = true;
}
return obj;
}

for (elem in arrayIter(myArray))
{
document.writeln(elem);
}

Admittedly I don’t see a way of having ‘in’ work together with arbitrary iterators, representing infinite streams or the like.

for (var i=0, obj; ! (obj=all[i]) === undefined; i++) {}

In theory undefined is a more purely sentinal object than null or the other false objects.

If you wanted to make a purely sentinal object that would be less likely to leak into the environment, you could probably do:


function makeMakeSentinal() {
  var sentinal = new Object();
  function create() {
    return sentinal;
  }
}
makeSentinal = makeMakeSentinal();


This would give you a truly private object with a unique and persistent identity that could only be retrieved with a function call, and so would never appear in any enumeration of an object (so long as people are disciplined enough not to store the result of that function call anywhere except in private local variables).

But the only justification I see for one over the other is performance, which requires testing, which I am too lazy to do now, so I can’t complain…

for (var i = 0, obj; obj = all[i]; i++) { …

might be better than

for (var i = 0; i < all.length; i++) { var obj = all[i]; …