for..in循环是否跟踪对象的属性顺序？

Question

I'm a beginner for programming in general, and JavaScript is my first language. While I was studying, I faced with this concern, and I'm not sure if my concern is appropriate.

I thought for..in loop does not keep track of orders when we loop through an Object, because, unlike Arrays, Object's properties are not index based.

This leads me to question my work on recreating some of the methods from Underscore.js such as _.each and _.reduce

Below is my attempts to recreate those methods.

var each = function(list, iteratee) {
    if (Array.isArray(list)) {
        for (var i = 0; i < list.length; i++) {
            iteratee(list[i], i, list);
        }
    } else if (list.constructor === Object) {
        for (var key in list) {
            iteratee(list[key], key, list);
        }
    }
};

var reduce = function(list, iteratee, memo){  
  var memoUndefined = arguments.length < 3;
  each(list, function(elem, index, list){
    if (memoUndefined) {
      memoUndefined = false;
      memo = elem;
    } else {
        memo = iteratee(memo, elem, index, list);
    }
  });
  return memo;
};

They seem to work correctly, such that works on both Array and Object as its list , with or without memo supplied to it.

However, what makes me wonder is that how does my each function keep track of the orders of properties it is iterating over? How would it make sure the orders of the properties being looped is always consistent? It makes sense for Arrays because it's properties are index. But Object's is not. I believe this might have a potential issue when being implemented in a function like my reduce above. If what iteratee does in the future is just simple addition or subtraction it might be fine, but what about multiplications or division? The orders of values each will iterate will be crucial. Is my concern appropriate?

Answer 1

The ECMAScript ES5 specification specifically says that the order of properties is not guaranteed for a for/in loop. From section 12.6.4 in the ES5 specification:

The mechanics and order of enumerating the properties (step 6.a in the first algorithm, step 7.a in the second) is not specified.

Though, in most browser implementations of ES5, properties are iterated in the order they were created.

I have read that it has been proposed to document the order of properties for for/in as the order created in the emerging ES6 specification.

I haven't found this specific wording in the ES6 draft, but there is this note about Object.keys() :

If an implementation defines a specific order of enumeration for the for-in statement, the same order must be used for the elements of the array returned in step 4.

Keep in mind that even if the order is always a specific way, there are no features for modifying the order. So, if you really care about order of properties, then it is likely that a for/in loop on an object is not really the right way to store/access an ordered set of properties.