Summary
Iterates over the enumerable properties of an object, in
arbitrary order. For each distinct property, statements can be executed.
Statement
Implemented in: JavaScript
1.0
ECMA Version: ECMA-262
Syntax
for (variable in object) {
...
}
Parameters
variable
A different property name is assigned to variable on each
iteration.
object
Object whose enumerable properties are iterated.
Description
A for...in loop does not iterate over non–enumerable
properties. Objects created from built–in constructors like Array and Object
have inherited non–enumerable properties from Object.prototype and
String.prototype that are not enumerable, such as String's indexOf method or
Object's toString method. The loop will iterate over all enumerable properties of
the object itself and those the object inherits from its constructor's
prototype (properties closer to the object in the prototype chain override
prototypes' properties).
A for...in loop iterates over the properties of an object in
an arbitrary order (see the delete operator for more on why one cannot depend
on the seeming orderliness of iteration, at least in a cross-browser setting).
If a property is modified in one iteration and then visited at a later time,
its value in the loop is its value at that later time. A property that is
deleted before it has been visited will not be visited later. Properties added
to the object over which iteration is occurring may either be visited or
omitted from iteration. In general it is best not to add, modify or remove
properties from the object during iteration, other than the property currently
being visited. There is no guarantee whether or not an added property will be
visited, whether a modified property (other than the current one) will be
visited before or after it is modified, or whether a deleted property will be
visited before it is deleted.
If you only want to consider properties attached to the
object itself, and not its prototypes, use getOwnPropertyNames or perform a
hasOwnProperty check (propertyIsEnumerable can also be used). Alternatively, if
you know there won't be any outside code interference, you can extend built-in
prototypes with a check method.
for..in should not be used to iterate over an Array where
index order is important. Array indexes are just enumerable properties with
integer names and are otherwise identical to general Object properties. There
is no guarantee that for...in will return the indexes in any particular order
and it will return all enumerable properties, including those with non–integer
names and those that are inherited.
Because the order of iteration is implementation dependent,
iterating over an array may not visit elements in a consistent order. Therefore
it is better to use a for loop with a numeric index (or Array.forEach or the
non-standard for...of loop) when iterating over arrays where the order of
access is important.
Examples
The following function takes as its arguments an object and
the object's name. It then iterates over all the object's enumerable properties
and returns a string of the property names and their values.
var o = {a:1, b:2, c:3};
function show_props(obj, objName) {
var result =
"";
for (var prop in
obj) {
result += objName
+ "." + prop + " = " + obj[prop] + "\n";
}
return result;
}
alert(show_props(o, "o")); /* alerts: o.a = 1 o.b
= 2 o.c = 3 */
The following function illustrates the use of
hasOwnProperty: the inherited properties are not displayed.
var triangle = {a:1, b:2, c:3};
function ColoredTriangle() {
this.color =
"red";
}
ColoredTriangle.prototype = triangle;
function show_own_props(obj, objName) {
var result =
"";
for (var prop in
obj) {
if(
obj.hasOwnProperty( prop ) ) {
result +=
objName + "." + prop + " = " + obj[prop] + "\n";
}
}
return result;
}
o = new ColoredTriangle();
alert(show_own_props(o, "o")); /* alerts: o.color
= red */
Iterating over only
FIXME:
See also
for...of - a similar statement that iterates over the
property values
for each...in - a similar statement, but iterates over the
values of object's properties, rather than the property names themselves (New
in JavaScript 1.6 but deprecated)
for
Generator expressions (uses the for...in syntax)
Enumerability and ownership of properties
getOwnPropertyNames
hasOwnProperty
Array.prototype.forEach
No comments:
Post a Comment