我在 JavaScript 中有一个对象：
{
abc: '...',
bca: '...',
zzz: '...',
xxx: '...',
ccc: '...',
// ...
}
我想使用for循环来获取它的属性。而且我想分部分迭代它（不是一次所有对象属性）。
使用简单的数组，我可以使用标准for循环来完成：
for (i = 0; i < 100; i++) { ... } // first part
for (i = 100; i < 300; i++) { ... } // second
for (i = 300; i < arr.length; i++) { ... } // last
但是如何处理对象呢？
对于大多数对象，请使用for .. in：
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);
}
然后你可以通过 index: 迭代你的属性yourobject[keys[i]]：
for (let i=300; i < keys.length && i < 600; i++) {
console.log(keys[i], yourobject[keys[i]]);
}
这是现代浏览器的另一种迭代解决方案：
Object.keys(obj)
.filter((k, i) => i >= 100 && i < 300)
.forEach(k => console.log(obj[k]));
或者没有过滤功能：
Object.keys(obj).forEach((k, i) => {
if (i >= 100 && i < 300) {
console.log(obj[k]);
}
});
但是，您必须考虑 JavaScript 对象中的属性没有排序，即没有顺序。
使用Object.entries你做这样的事情。
// array like object with random key ordering
const anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.entries(anObj)); // [ ['2', 'b'],['7', 'c'],['100', 'a'] ]
Object.entries() 方法返回给定对象自己的可枚举属性 [key, value] 的数组
因此，您可以遍历 Object 并为每个对象拥有keyandvalue并获得类似的东西。
const anObj = { 100: 'a', 2: 'b', 7: 'c' };
Object.entries(anObj).map(obj => {
const key = obj[0];
const value = obj[1];
// do whatever you want with those values.
});
或者像这样
// Or, using array extras
Object.entries(obj).forEach(([key, value]) => {
console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
});
如需参考，请查看对象条目的 MDN 文档
借助新的 ES6/ES2015 特性，您不必再使用对象来迭代哈希。您可以使用Map。Javascript Maps 将键保持在插入顺序中，这意味着您可以迭代它们而无需检查 hasOwnProperty，这一直是一个 hack。
遍历地图：
var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
console.log(key + " = " + value);
}
// Will show 2 logs; first with "0 = zero" and second with "1 = one"
for (var key of myMap.keys()) {
console.log(key);
}
// Will show 2 logs; first with "0" and second with "1"
for (var value of myMap.values()) {
console.log(value);
}
// Will show 2 logs; first with "zero" and second with "one"
for (var [key, value] of myMap.entries()) {
console.log(key + " = " + value);
}
// Will show 2 logs; first with "0 = zero" and second with "1 = one"
或使用 forEach：
myMap.forEach(function(value, key) {
console.log(key + " = " + value);
}, myMap)
// Will show 2 logs; first with "0 = zero" and second with "1 = one"
如果您在迭代时需要键和值，可以使用for...of循环和Object.entries。
const myObj = {a: 1, b: 2}
for (let [key, value] of Object.entries(myObj)) {
console.log(`key=${key} value=${value}`)
}
// output:
// key=a value=1
// key=b value=2
唯一可靠的方法是将您的对象数据保存到 2 个数组，一个键和一个用于数据：
var keys = [];
var data = [];
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
keys.push(key);
data.push(obj[key]); // Not necessary, but cleaner, in my opinion. See the example below.
}
}
然后，您可以像往常一样遍历数组：
for(var i = 0; i < 100; i++){
console.log(keys[i], data[i]);
//or
console.log(keys[i], obj[keys[i]]); // harder to read, I think.
}
for(var i = 100; i < 300; i++){
console.log(keys[i], data[i]);
}
我没有使用Object.keys(obj)，因为那是 IE 9+。
-> 如果我们使用并找到对象数组的键来遍历 JavaScript 对象
Object.keys(Array).forEach(key => {
console.log('key',key)
})
如果您有一个简单的对象，则可以使用以下代码对其进行迭代：
let myObj = {
abc: '...',
bca: '...',
zzz: '...',
xxx: '...',
ccc: '...',
// ...
};
let objKeys = Object.keys(myObj);
//Now we can use objKeys to iterate over myObj
for (item of objKeys) {
//this will print out the keys
console.log('key:', item);
//this will print out the values
console.log('value:', myObj[item]);
}如果您有一个嵌套对象，您可以使用以下代码对其进行迭代：
let b = {
one: {
a: 1,
b: 2,
c: 3
},
two: {
a: 4,
b: 5,
c: 6
},
three: {
a: 7,
b: 8,
c: 9
}
};
let myKeys = Object.keys(b);
for (item of myKeys) {
//print the key
console.log('Key', item)
//print the value (which will be another object)
console.log('Value', b[item])
//print the nested value
console.log('Nested value', b[item]['a'])
}如果您有对象数组，则可以使用以下代码对其进行迭代：
let c = [
{
a: 1,
b: 2
},
{
a: 3,
b: 4
}
];
for(item of c){
//print the whole object individually
console.log('object', item);
//print the value inside the object
console.log('value', item['a']);
}const o = {
name: "Max",
location: "London"
};
for (const [key, value] of Object.entries(o)) {
console.log(`${key}: ${value}`);
}
如果你想一次迭代整个对象，你可以使用for in循环：
for (var i in obj) {
...
}
但是，如果您想将对象分成几部分，实际上是做不到的。无法保证对象中的属性按任何指定的顺序排列。因此，我可以想到两种解决方案。
首先是“删除”已经读取的属性：
var i = 0;
for (var key in obj) {
console.log(obj[key]);
delete obj[key];
if ( ++i > 300) break;
}
我能想到的另一个解决方案是使用 Array of Arrays 而不是对象：
var obj = [['key1', 'value1'], ['key2', 'value2']];
然后，标准for循环将起作用。
我终于想出了一个方便的实用函数，它有一个统一的接口来迭代对象、字符串、数组、TypedArrays、Maps、Sets（任何 Iterables）。
const iterate = require('@a-z/iterate-it');
const obj = { a: 1, b: 2, c: 3 };
iterate(obj, (value, key) => console.log(key, value));
// a 1
// b 2
// c 3
对于对象迭代，我们通常使用for..in循环。该结构将遍历所有可枚举的属性，包括通过原型继承继承的属性。例如：
let obj = {
prop1: '1',
prop2: '2'
}
for(let el in obj) {
console.log(el);
console.log(obj[el]);
}但是，for..in它将遍历所有可枚举元素，这将无法让我们将迭代分成块。为此，我们可以使用内置Object.keys()函数来检索数组中对象的所有键。然后，我们可以将迭代拆分为多个 for 循环并使用键数组访问属性。例如：
let obj = {
prop1: '1',
prop2: '2',
prop3: '3',
prop4: '4',
};
const keys = Object.keys(obj);
console.log(keys);
for (let i = 0; i < 2; i++) {
console.log(obj[keys[i]]);
}
for (let i = 2; i < 4; i++) {
console.log(obj[keys[i]]);
}是的。您可以使用 for 循环遍历对象。这是一个例子
var myObj = {
abc: 'ABC',
bca: 'BCA',
zzz: 'ZZZ',
xxx: 'XXX',
ccc: 'CCC',
}
var k = Object.keys (myObj);
for (var i = 0; i < k.length; i++) {
console.log (k[i] + ": " + myObj[k[i]]);
}注意：上面提到的例子只适用于 IE9+。请参阅此处的Objec.keys 浏览器支持。
<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>
var Dictionary = {
If: {
you: {
can: '',
make: ''
},
sense: ''
},
of: {
the: {
sentence: {
it: '',
worked: ''
}
}
}
};
function Iterate(obj) {
for (prop in obj) {
if (obj.hasOwnProperty(prop) && isNaN(prop)) {
console.log(prop + ': ' + obj[prop]);
Iterate(obj[prop]);
}
}
}
Iterate(Dictionary);
您可以尝试使用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>真正的 PITA，这不是标准 Javascript 的一部分。
/**
* Iterates the keys and values of an object. Object.keys is used to extract the keys.
* @param object The object to iterate
* @param fn (value,key)=>{}
*/
function objectForEach(object, fn) {
Object.keys(object).forEach(key => {
fn(object[key],key, object)
})
}
注意：我将回调参数切换为 (value,key) 并添加了第三个对象以使 API 与其他 API 保持一致。
像这样使用它
const o = {a:1, b:true};
objectForEach(o, (value, key, obj)=>{
// do something
});
这是一个手工制作的解决方案：
function iterationForObject() {
let base = 0,
Keys= Object.keys(this);
return {
next: () => {
return {
value: {
"key": Keys[base],
"value": this[Keys[base]]
},
done: !(base++ < Keys.length)
};
}
};
}
Object.prototype[Symbol.iterator] = iterationForObject;
然后你可以循环任何对象：
for ( let keyAndValuePair of (Object Here) ) {
console.log(`${keyAndValuePair.key} => ${keyAndValuePair.value}`);
}