Does the "for…in" loop in Javascript loop through the hashtables/elements in the order they are declared? Is there a browser which doesn't do it in order?
The object I wish to use will be declared once and will never be modified.
Suppose I have:
var myObject = { A: "Hello", B: "World" };
And I further use them in:
for (var item in myObject) alert(item + " : " + myObject[item]);
Can I expect 'A : "Hello"' to always come before 'B : "World"' in most decent browsers?
Currently all major browsers loop over the properties of an object in the order in which they were defined. Chrome does this as well, except for a couple cases. [...] This behavior is explicitly left undefined by the ECMAScript specification. In ECMA-262, section 12.6.4:
The mechanics of enumerating the properties ... is implementation dependent.
However, specification is quite different from implementation. All modern implementations of ECMAScript iterate through object properties in the order in which they were defined. Because of this the Chrome team has deemed this to be a bug and will be fixing it.
All browsers respect definition order with the exception of Chrome and Opera which do for every non-numerical property name. In these two browsers the properties are pulled in-order ahead of the first non-numerical property (this is has to do with how they implement arrays). The order is the same for Object.keys as well.
This example should make it clear what happens:
var obj = {
"first":"first",
"2":"2",
"34":"34",
"1":"1",
"second":"second"
};
for (var i in obj) { console.log(i); };
// Order listed:
// "1"
// "2"
// "34"
// "first"
// "second"
The technicalities of this are less important than the fact that this may change at any time. Do not rely on things staying this way.
In short: Use an array if order is important to you.
true here. Properties should be in insertion order because of the usage of shapes/hidden classes. –
Glycoprotein EnumerateObjectProperties and EnumerableOwnPropertyNames order is implementation dependent. Maps iterate with insertion order for example. Object.keys order is still implementation dependent apparently. –
Fixture Bumping this a year later...
It is 2012 and the major browsers still differ:
function lineate(obj){
var arr = [], i;
for (i in obj) arr.push([i,obj[i]].join(':'));
console.log(arr);
}
var obj = { a:1, b:2, c:3, "123":'xyz' };
/* log1 */ lineate(obj);
obj.a = 4;
/* log2 */ lineate(obj);
delete obj.a;
obj.a = 4;
/* log3 */ lineate(obj);
gist or test in current browser
Safari 5, Firefox 14
["a:1", "b:2", "c:3", "123:xyz"]
["a:4", "b:2", "c:3", "123:xyz"]
["b:2", "c:3", "123:xyz", "a:4"]
Chrome 21, Opera 12, Node 0.6, Firefox 27
["123:xyz", "a:1", "b:2", "c:3"]
["123:xyz", "a:4", "b:2", "c:3"]
["123:xyz", "b:2", "c:3", "a:4"]
IE9
[123:xyz,a:1,b:2,c:3]
[123:xyz,a:4,b:2,c:3]
[123:xyz,a:4,b:2,c:3]
delete is interesting because at least in V8, it instantly causes the object to be backed up by a hash table. However, the hash table in V8 stores in insertion order. Most interesting result here is IE, I wonder what kind of ugliness they do to pull that off... –
Glycoprotein From the ECMAScript Language Specification, section 12.6.4 (on the for .. in loop):
The mechanics of enumerating the properties is implementation dependent. The order of enumeration is defined by the object.
And section 4.3.3 (definition of "Object"):
It is an unordered collection of properties each of which contains a primitive value, object, or function. A function stored in a property of an object is called a method.
I guess that means you cant rely on the properties being enumerated in a consistent order across JavaScript implementations. (It would be bad style anyway to rely on implementation-specific details of a language.)
If you want your order defined, you will need to implement something that defines it, like an array of keys that you sort before accessing the object with it.
The elements of an object that for/in enumerates are the properties that don't have the DontEnum flag set. The ECMAScript, aka Javascript, standard explicitly says that "An Object is an unordered collection of properties" (see http://www.mozilla.org/js/language/E262-3.pdf section 8.6).
It's not going to be standards conformant (i.e. safe) to assume all Javascript implementations will enumerate in declaration order.
Iteration order is also confused with respect to deleting of properties, but in this case with IE only.
var obj = {};
obj.a = 'a';
obj.b = 'b';
obj.c = 'c';
// IE allows the value to be deleted...
delete obj.b;
// ...but remembers the old position if it is added back later
obj.b = 'bb';
for (var p in obj) {
alert(obj[p]); // in IE, will be a, bb, then c;
// not a, c, then bb as for FF/Chrome/Opera/Safari
}
The desire for changing the spec to fix the iteration order seems to be quite a popular desire among developers if the discussion at http://code.google.com/p/v8/issues/detail?id=164 is any indication.
in IE6, the order is not guaranteed.
The order cannot be trusted. Both Opera and Chrome return the list of properties unordered.
<script type="text/javascript">
var username = {"14719":"A","648":"B","15185":"C"};
for (var i in username) {
window.alert(i + ' => ' + username[i]);
}
</script>
The code above shows B, A, C in Opera and C, A, B in Chrome.
As stated by other answers, no, the order is not guaranteed.
If you want to iterate in order, you can do something like:
const sortedKeys = Object.keys(myObject).sort();
for (let key of sortedKeys) {
let value = myObject[key];
// Do what you want with key and value
}
Note that performance-wise, this is not optimal, but that's the price when you want a nice alphabetical display.
This does not answer the question per se, but offers a solution to the basic problem.
Assuming that you cannot rely on order to preserved, why not use an array of objects with key and value as properties?
var myArray = [
{
'key' : 'key1'
'value' : 0
},
{
'key' : 'key2',
'value' : 1
} // ...
];
Now, it is up to you to ensure that the keys are unique (assuming that this is also important to you). As well, direct addressing changes, and for (...in...) now returns indices as 'keys'.
> console.log(myArray[0].key);
key1
> for (let index in myArray) {console.log(myArray[index].value);}
0
1
As of 2022,
I have just found out (to my surprise), that Chrome does not respect the definition order. It rather sorts it alphabetically but not naturally. For example key "a12" comes BEFORE "a3". So be careful.
© 2022 - 2024 — McMap. All rights reserved.