对于对象迭代，我们通常使用For ..in循环。该结构将循环遍历所有可枚举属性，包括通过原型继承继承的属性。例如:

让obj = { prop1:(1), prop2: ' } 对于(let the in obj) { console.log (el); console.log (obj [ol]); }

然而，for. in将遍历所有可枚举元素，这将不能将迭代分割成块。为此，我们可以使用内置的object .keys()函数来检索数组中对象的所有键。然后，我们可以将迭代分解为多个for循环，并使用keys数组访问属性。例如:

让obj = { prop1: ' 1 ', prop2: ' 2 ', prop3:“3”, prop4:“4”, }; const keys = Object.keys(obj); console.log(键); 对于(设I = 0;I < 2;我+ +){ console.log (obj[键[我]]); ｝ For(令I = 2;I < 4;我+ +){ console.log (obj[键[我]]); ｝

->如果我们遍历一个JavaScript对象使用并找到数组的键 对象

Object.keys(Array).forEach(key => {

 console.log('key',key)

})

你可以尝试使用lodash-一个现代的JavaScript实用程序库，提供模块化，性能和额外的js来快速对象迭代

var  users  =   { 'fred':     {  'user':   'fred',     'age':  40  }, 'pebbles':  {  'user':   'pebbles',  'age':  1  } };  _.mapValues(users,  function(o)  {  return  o.age;  }); // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) // The `_.property` iteratee shorthand. console.log(_.mapValues(users,  'age')); // returns age property & value console.log(_.mapValues(users,  'user')); // returns user property & value console.log(_.mapValues(users)); // returns all objects // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash-compat/3.10.2/lodash.js"></script>

<script type="text/javascript">
// method 1
var images = {};
images['name'] = {};
images['family'] = {};
images[1] = {};
images['name'][5] = "Mehdi";
images['family'][8] = "Mohammadpour";
images['family']['ok'] = 123456;
images[1][22] = 2602;
images[1][22] = 2602;
images[1][22] = 2602;
images[1][22] = 2602;
images[1][23] = 2602;

for (const [key1, value1] of Object.entries(images)){
    for (const [key2, value2] of Object.entries(value1)){
        console.log(`${key1} => ${key2}: ${value2}`);
    }
}


console.log("=============================");

// method 2
var arr = [];
for(var x = 0; x < 5; x++){
     arr[x] = [];    
     for(var y = 0; y < 5; y++){ 
         arr[x][y] = x*y;    
     }    
 }

for(var i = 0; i < arr.length; i++) {
    var cube = arr[i];
    for(var j = 0; j < cube.length; j++) {
        console.log("cube[" + i + "][" + j + "] = " + cube[j]);
    }
}

</script>

在参数中定义object，避免选择器和下标

有许多语法选择，但这个在闭包的参数中定义了前面的对象，从而消除了迭代器中选择器或下标的需要。K是键，v是值，I是索引。

const obj = {
    kiwi: true,
    mango: false,
    pineapple: 500
};

Object.entries(obj).forEach(([k, v], i) => {
    console.log(k, v, i);
});

// kiwi true 0
// mango false 1
// pineapple 500 2

对于迭代数组、字符串或对象的键，使用For ..:

for (let key in yourobject) {
  console.log(key, yourobject[key]);
}

在ES6中，如果你同时需要键和值，那就这样做

for (let [key, value] of Object.entries(yourobject)) {
    console.log(key, value);
}

为了避免记录继承的属性，检查hasOwnProperty:

for (let key in yourobject) {
   if (yourobject.hasOwnProperty(key)) {
      console.log(key, yourobject[key]);
   }
}

如果你正在使用一个简单的对象(例如你自己用{}创建的对象)迭代键时，你不需要检查hasOwnProperty。

MDN文档更一般地解释了如何处理对象及其属性。

如果你想“大块”地执行，最好是在数组中提取键。由于订单不能保证，这是正确的方式。在现代浏览器中，您可以使用

let keys = Object.keys(yourobject);

为了更加兼容，你最好这样做:

 let keys = [];
 for (let key in yourobject) {      
     if (yourobject.hasOwnProperty(key)) keys.push(key);
 }

然后你可以通过索引迭代你的属性:

for (let i=300; i < keys.length && i < 600; i++) { 
   console.log(keys[i], yourobject[keys[i]]);
}