Does JavaScript Guarantee Object Property Order?

Does JavaScript Guarantee Object Property Order?

If I create an object like this:
var obj = {};
obj.prop1 = “Foo”;
obj.prop2 = “Bar”;

Will the resulting object always look like this?
{ prop1 : “Foo”, prop2 : “Bar” }

That is, will the properties be in the same order that I added them?

Solutions/Answers:

Solution 1:

No, properties order in objects is not guaranteed in JavaScript; you need to use an Array.

Definition of an Object from ECMAScript Third Edition (pdf):

4.3.3 Object

An object is a member of the
type 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.

Since ECMAScript 2015, using the Map object could be an alternative. A Map shares some similarities with an Object and guarantees the keys order:

A Map iterates its elements in insertion order, whereas iteration order is not specified for Objects.

Solution 2:

YES (for non-integer keys) – the answer above is WRONG!

Current Language Spec (since ES2015) insertion order is preserved, except in the case of keys that parse as integers (eg “7” or “99”), where behavior varies between browsers. For example, Chrome/V8 does not respect insertion order when the keys are parse as numeric.

Old Language Spec (before ES2015): Iteration order was technically undefined, but all major browsers complied with the ES2015 behavior.

Note that the ES2015 behavior was a good example of the language spec being driven by existing behavior, and not the other way round. To get a deeper sense of that backwards-compatibility mindset, see http://code.google.com/p/v8/issues/detail?id=164, a Chrome bug that covers in detail the design decisions behind Chrome’s iteration order behavior.
Per one of the (rather opinionated) comments on that bug report:

Standards always follow implementations, that’s where XHR came from, and Google does the same thing by implementing Gears and then
embracing equivalent HTML5 functionality. The right fix is to have ECMA formally
incorporate the de-facto standard behavior into the next rev of the spec.

Solution 3:

At the time of writing, most browsers did return properties in the same order as they were inserted, but it was explicitly not guaranteed behaviour so shouldn’t have been relied upon.

The ECMAScript specification used to say:

The mechanics and order of enumerating the properties … is not specified.

However in ES2015 and later non-integer keys will be returned in insertion order.

Solution 4:

Property order in normal Objects is a complex subject in Javascript.

While in ES5 explicitly no order has been specified, ES2015 has an order in certain cases. Given is the following object:

o = Object.create(null, {
  m: {value: function() {}, enumerable: true},
  "2": {value: "2", enumerable: true},
  "b": {value: "b", enumerable: true},
  0: {value: 0, enumerable: true},
  [Symbol()]: {value: "sym", enumerable: true},
  "1": {value: "1", enumerable: true},
  "a": {value: "a", enumerable: true},
});

This results in the following order (in certain cases):

Object {
  0: 0,
  1: "1",
  2: "2",
  b: "b",
  a: "a",
  m: function() {},
  Symbol(): "sym"
}
  1. integer-like keys in ascending order
  2. normal keys in insertion order
  3. Symbols in insertion order

Thus, there are three segments, which may alter the insertion order (as happened in the example). And integer-like keys don’t stick to the insertion order at all.

The question is, for what methods this order is guaranteed in the ES2015 spec?

The following methods guarantee the order shown:

  • Object.assign
  • Object.defineProperties
  • Object.getOwnPropertyNames
  • Object.getOwnPropertySymbols
  • Reflect.ownKeys

The following methods/loops guarantee no order at all:

  • Object.keys
  • for..in
  • JSON.parse
  • JSON.stringify

Conclusion: Even in ES2015 you shouldn’t rely on the property order of normal objects in Javascript. It is prone to errors. Use Map instead.

Solution 5:

This whole answer is in the context of spec compliance, not what any engine does at a particular moment or historically.

Generally, no

The actual question is very vague.

will the properties be in the same order that I added them

In what context?

The answer is: it depends on a number of factors. In general, no.

Sometimes, yes

Here is where you can count on property key order for plain Objects:

  • ES2015 compliant engine
  • Own properties
  • Object.getOwnPropertyNames(), Reflect.ownKeys(), Object.getOwnPropertySymbols(O)

In all cases these methods include non-enumerable property keys and order keys as specified by [[OwnPropertyKeys]] (see below). They differ in the type of key values they include (String and / or Symbol). In this context String includes integer values.

Object.getOwnPropertyNames(O)

Returns O‘s own String-keyed properties (property names).

Reflect.ownKeys(O)

Returns O‘s own String– and Symbol-keyed properties.

Object.getOwnPropertySymbols(O)

Returns O‘s own Symbol-keyed properties.

[[OwnPropertyKeys]]

The order is essentially: integer-like Strings in ascending order, non-integer-like Strings in creation order, Symbols in creation order. Depending which function invokes this, some of these types may not be included.

The specific language is that keys are returned in the following order:

  1. … each own property key P of O [the object being iterated] that is an integer index, in ascending numeric index order

  2. … each own property key P of O that is a String but is not an integer index, in property creation order

  3. … each own property key P of O that is a Symbol, in property creation order

Map

If you’re interested in ordered maps you should consider using the Map type introduced in ES2015 instead of plain Objects.

Solution 6:

In modern browsers you can use the Map data structure instead of a object.

Developer mozilla > Map

A Map object can iterate its elements in insertion order…