Javascript JQuery和下划线“；每一个；数组的保证顺序？

我读了Javascript：好的部分

由于JavaScript的数组实际上是对象，因此可以使用

for in

语句迭代数组的所有属性。不幸的是，因为in不能保证属性的顺序

据我所知，“each”函数基于

for in

，那么

函数形成JQuery和下划线库在迭代数组时是否保证顺序？我正试图避免

的恼人标准

提前感谢。
在遍历数组时，顺序总是有保证的。当你在（非数组）对象中迭代的时候，是没有保证的时候。顺便说一下，数组仍然是对象


对于对象，每个
都只不过是in的一个
，对于类似数组的对象，
只不过是
。该框架为作业确定正确的循环，并应用相同的逻辑：数组迭代是有序的，而对象迭代不是有序的

下划线的来源：

var each = _.each = _.forEach = function (obj, iterator, context) {
        if (obj == null) return;
        if (nativeForEach && obj.forEach === nativeForEach) {
            obj.forEach(iterator, context);
        } else if (obj.length === +obj.length) {
            for (var i = 0, l = obj.length; i < l; i++) {
                if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
            }
        } else {
            for (var key in obj) {
                if (_.has(obj, key)) {
                    if (iterator.call(context, obj[key], key, obj) === breaker) return;
                }
            }
        }
    };

each: function (object, callback, args) {
    var name, i = 0,
        length = object.length,
        isObj = length === undefined || jQuery.isFunction(object);
    if (args) {
        if (isObj) {
            for (name in object) {
                if (callback.apply(object[name], args) === false) {
                    break;
                }
            }
        } else {
            for (; i < length;) {
                if (callback.apply(object[i++], args) === false) {
                    break;
                }
            }
        }
        // A special, fast, case for the most common use of each
    } else {
        if (isObj) {
            for (name in object) {
                if (callback.call(object[name], name, object[name]) === false) {
                    break;
                }
            }
        } else {
            for (; i < length;) {
                if (callback.call(object[i], i, object[i++]) === false) {
                    break;
                }
            }
        }
    }
    return object;
}

var each=\ each=\ forEach=函数（obj、迭代器、上下文）{
if（obj==null）返回；
if（nativeForEach&&obj.forEach===nativeForEach）{
forEach（迭代器，上下文）；
}否则如果（对象长度===+对象长度）{
对于（变量i=0，l=obj.length；i

jQuery的来源：

var each = _.each = _.forEach = function (obj, iterator, context) {
        if (obj == null) return;
        if (nativeForEach && obj.forEach === nativeForEach) {
            obj.forEach(iterator, context);
        } else if (obj.length === +obj.length) {
            for (var i = 0, l = obj.length; i < l; i++) {
                if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
            }
        } else {
            for (var key in obj) {
                if (_.has(obj, key)) {
                    if (iterator.call(context, obj[key], key, obj) === breaker) return;
                }
            }
        }
    };

each: function (object, callback, args) {
    var name, i = 0,
        length = object.length,
        isObj = length === undefined || jQuery.isFunction(object);
    if (args) {
        if (isObj) {
            for (name in object) {
                if (callback.apply(object[name], args) === false) {
                    break;
                }
            }
        } else {
            for (; i < length;) {
                if (callback.apply(object[i++], args) === false) {
                    break;
                }
            }
        }
        // A special, fast, case for the most common use of each
    } else {
        if (isObj) {
            for (name in object) {
                if (callback.call(object[name], name, object[name]) === false) {
                    break;
                }
            }
        } else {
            for (; i < length;) {
                if (callback.call(object[i], i, object[i++]) === false) {
                    break;
                }
            }
        }
    }
    return object;
}

each:函数（对象、回调、参数）{
变量名称，i=0，
长度=object.length，
isObj=长度===未定义的| | jQuery.isFunction（对象）；
如果（args）{
if（isObj）{
for（对象中的名称）{
if（callback.apply（对象[名称]，参数）==false）{
打破
}
}
}否则{
对于（；i
有两种方法可以在数组上循环：一种是在数组的索引元素上循环数值，另一种是在数组的对象属性上循环

var a = ['a','b'];
a[3] = 'e';
a[2] = 'd';
a.foo = function() { };
for(key in a)
    console.log(key);

这将返回
0 1 3 2 foo
，因为这是属性定义的顺序（但也不能保证浏览器需要显示该行为）

到目前为止，数值循环看起来更优越，但它们无法处理备用阵列，即有间隙的阵列。ES5
数组。forEach
忽略未指定的值，而jQuery的
$。每个
使用基于
length
属性的数字循环

var a = [1,2];
a[1000000] = 4;
a[9000] = 3;
a.foo = function() {};

// outputs 0, 1, 9000, 1000000 -- note they are in order
a.forEach(function(elem, index){ console.log(index); })

// outputs 0, 1, 9000, 1000000 -- same as above
_.each(a, function(elem, index){ console.log(index); }) 

// outputs a million values and locks up  your browser for a while
$.each(a, function(index){ console.log(index); })

因此，
forEach
和
$都是如此。每个
都以索引顺序返回值，但是
forEach
和下划线对于稀疏数组似乎更为优越，因为它们忽略了没有赋值的索引。
确保你清楚什么是数组，什么是JavaScript中的对象……我编辑了这个问题，因为我认为它不清楚。比起对象/数组问题，我更关心函数。@davidgnin每一个都不过是
for
和
for in
循环。同样的逻辑也适用。谢谢！然后在数组中，每个都是for，而不是in。这正是我想知道的。