如何以对象作为成员在普通JavaScript对象中循环？

如何循环遍历JavaScript对象中的所有成员，包括作为对象的值

例如，我如何循环（访问每个人的“您的姓名”和“您的信息”）

---

如果使用递归，则可以返回任意深度的对象属性-

function lookdeep(object){
    var collection= [], index= 0, next, item;
    for(item in object){
        if(object.hasOwnProperty(item)){
            next= object[item];
            if(typeof next== 'object' && next!= null){
                collection[index++]= item +
                ':{ '+ lookdeep(next).join(', ')+'}';
            }
            else collection[index++]= [item+':'+String(next)];
        }
    }
    return collection;
}

//example

var O={
    a:1, b:2, c:{
        c1:3, c2:4, c3:{
            t:true, f:false
        }
    },
    d:11
};
var lookdeepSample= 'O={'+ lookdeep(O).join(',\n')+'}';


/*  returned value: (String)
O={
    a:1, 
    b:2, 
    c:{
        c1:3, c2:4, c3:{
            t:true, f:false
        }
    },
    d:11
}

*/

这个问题是什么

for (var key in validation_messages) {
   var obj = validation_messages[key];
   for (var prop in obj) {
      alert(prop + " = " + obj[prop]);
   }
}

您还将循环遍历基本体对象的原型

使用此选项，您将避免：

for (var key in validation_messages) {
   if (validation_messages.hasOwnProperty(key)) {
      var obj = validation_messages[key];
      for (var prop in obj) {
         if (obj.hasOwnProperty(prop)) {
            alert(prop + " = " + obj[prop]);
         }
      }
   }
}

---

在ECMAScript 5下，您可以组合

Object.keys（）

和

Array.prototype.forEach（）

：

var obj={
第一个：“约翰”，
最后：“能源部”
};
//
//访问非继承的可枚举密钥
//
Object.keys（obj）.forEach（函数（key）{
console.log（key，obj[key]）；
});我知道已经很晚了，但我确实花了2分钟来编写AgileJon答案的优化和改进版本：

var key, obj, prop, owns = Object.prototype.hasOwnProperty;

for (key in validation_messages ) {

    if (owns.call(validation_messages, key)) {

        obj = validation_messages[key];

        for (prop in obj ) {

            // using obj.hasOwnProperty might cause you headache if there is
            // obj.hasOwnProperty = function(){return false;}
            // but owns will always work 
            if (owns.call(obj, prop)) {
                console.log(prop, "=", obj[prop]);
            }

        }

    }

}

使用：

我无法让上面的帖子完全符合我的要求

在这里玩过其他回复之后，我做了这个。它很粗糙，但它很有效

对于此对象：

var myObj = {
    pageURL    : "BLAH",
    emailBox   : {model:"emailAddress", selector:"#emailAddress"},
    passwordBox: {model:"password"    , selector:"#password"}
};

。。。此代码：

// Get every value in the object into a separate array item ...
function buildArray(p_MainObj, p_Name) {
    var variableList = [];
    var thisVar = "";
    var thisYes = false;
    for (var key in p_MainObj) {
       thisVar = p_Name + "." + key;
       thisYes = false;
       if (p_MainObj.hasOwnProperty(key)) {
          var obj = p_MainObj[key];
          for (var prop in obj) {
            var myregex = /^[0-9]*$/;
            if (myregex.exec(prop) != prop) {
                thisYes = true;
                variableList.push({item:thisVar + "." + prop,value:obj[prop]});
            }
          }
          if ( ! thisYes )
            variableList.push({item:thisVar,value:obj});
       }
    }
    return variableList;
}

// Get the object items into a simple array ...
var objectItems = buildArray(myObj, "myObj");

// Now use them / test them etc... as you need to!
for (var x=0; x < objectItems.length; ++x) {
    console.log(objectItems[x].item + " = " + objectItems[x].value);
}

在我的情况下（在前面的基础上），任何级别都是可能的

var myObj = {
    rrr: undefined,
    pageURL    : "BLAH",
    emailBox   : {model:"emailAddress", selector:"#emailAddress"},
    passwordBox: {model:"password"    , selector:"#password"},
    proba: {odin:{dva:"rr",trr:"tyuuu"}, od:{ff:5,ppa:{ooo:{lll:'lll'}},tyt:'12345'}}
};


function lookdeep(obj,p_Name,gg){
    var A=[], tem, wrem=[], dd=gg?wrem:A;
    for(var p in obj){
        var y1=gg?'':p_Name, y1=y1 + '.' + p;
        if(obj.hasOwnProperty(p)){
           var tem=obj[p];
           if(tem && typeof tem=='object'){
               a1=arguments.callee(tem,p_Name,true);
               if(a1 && typeof a1=='object'){for(i in a1){dd.push(y1 + a1[i])};}
            }
            else{
               dd.push(y1 + ':' + String(tem));
            }
        }
    };
    return dd
};


var s=lookdeep(myObj,'myObj',false);
for (var x=0; x < s.length; ++x) {
console.log(s[x]+'\n');}

下面是AgileJon解决方案（）的改进和递归版本：

此解决方案适用于各种不同深度。
另一个选项：

var testObj = {test: true, test1: false};
for(let x of Object.keys(testObj)){
    console.log(x);
}

在ES6/2015中，您可以通过以下对象进行循环：（使用）

Object.keys（myObj.forEach）（key=>{
console.log（key）；//当前密钥的名称。
log（myObj[key]）；//当前键的值。
});


在ES7/2016中，您可以使用而不是
对象。键
并循环通过如下对象：

Object.entries（myObj.forEach）（[key，val]）=>{
console.log（key）；//当前密钥的名称。
console.log（val）；//当前键的值。
});

上述内容也可作为一条线使用：

Object.entries（myObj.forEach）（[key，val]）=>console.log（key，val））；


如果您还想循环嵌套对象，可以使用递归函数（ES6）：

const loopNestedObj=obj=>{
Object.keys（obj.forEach）（key=>{
if（obj[key]&&typeof obj[key]=“object”）循环嵌套对象（obj[key]）；//递归。
else console.log（key，obj[key]）；//或使用key和val执行某些操作。
});
};


与上面的函数相同，但使用ES7
Object.entries（）
而不是
Object.keys（）
：

const loopNestedObj=obj=>{
Object.entries（obj.forEach）（[key，val]）=>{
if（val&&typeof val==“object”）loopNestedObj（val）；//递归。
else console.log（key，val）；//或使用key和val执行某些操作。
});
};

在这里，我们通过使用
object.entries（）
和（ES10/2019）循环嵌套对象更改值并一次性返回新对象：

const loopNestedObj=obj=>
Object.fromEntries(
Object.entries（obj.map）（[key，val]）=>{
if（val&&typeof val==“object”）[key，loopNestedObj（val）]；//递归
else[key，updateMyVal（val）]；//或使用key和val执行某些操作。
})
);

通过对象循环的另一种方法是使用for。。。在和中为。。。属于。请参阅。
我认为值得指出的是，jQuery使用
$.each（）
很好地解决了这个问题

见：

示例：

$('.foo').each(function() {
    console.log($(this));
});

$（this）
是对象中的单个项。如果您不想使用jQuery的选择器引擎，请将
$（'.foo'）
交换为变量。
ECMAScript-2017，一个月前刚刚完成，引入了Object.values（）。现在你可以这样做了：

let v;
for (v of Object.values(validation_messages))
   console.log(v.your_name);   // jimmy billy

在ES7中，您可以执行以下操作：

for (const [key, value] of Object.entries(obj)) {
  //
}

这个答案是本文中提供的解决方案的集合
贴上一些。我想有两个
用例和OP没有提到他是否需要访问密钥才能使用它们
在循环过程中

I.需要访问密钥，
✔ 
和
对象的
键
接近

let k;
for (k of Object.keys(obj)) {

    /*        k : key
     *   obj[k] : value
     */
}

let k;
for (k in obj) {

    /*        k : key
     *   obj[k] : value
     */
}

for (const [key, value] of Object.entries(obj)) {

}

let v;
for (v of Object.values(obj)) {

}

✔ 
方法中的

let k;
for (k of Object.keys(obj)) {

    /*        k : key
     *   obj[k] : value
     */
}

let k;
for (k in obj) {

    /*        k : key
     *   obj[k] : value
     */
}

for (const [key, value] of Object.entries(obj)) {

}

let v;
for (v of Object.values(obj)) {

}

请谨慎使用此选项，因为它可以打印
obj

✔ ES7方法

let k;
for (k of Object.keys(obj)) {

    /*        k : key
     *   obj[k] : value
     */
}

let k;
for (k in obj) {

    /*        k : key
     *   obj[k] : value
     */
}

for (const [key, value] of Object.entries(obj)) {

}

let v;
for (v of Object.values(obj)) {

}

但是，在编辑时，我不推荐ES7方法，因为JavaScript在内部初始化了许多变量来构建这个过程（请参阅反馈以获得证明）。除非你不是在开发一个值得优化的大型应用程序，否则这没关系，但如果优化是你的首要任务，你应该考虑一下

II。我们只需要访问每个值，
✔ 
和
对象的
值
接近

let k;
for (k of Object.keys(obj)) {

    /*        k : key
     *   obj[k] : value
     */
}

let k;
for (k in obj) {

    /*        k : key
     *   obj[k] : value
     */
}

for (const [key, value] of Object.entries(obj)) {

}

let v;
for (v of Object.values(obj)) {

}


关于测试的更多反馈：

缓存
Object.key
或
Object.value
的性能可以忽略不计

比如说,

const keys = Object.keys(obj);
let i;
for (i of keys) {
  //
}
// same as
for (i of Object.keys(obj)) {
  //
}


对于
Object.values
情况，在Firefox中使用带有缓存变量的本机
For
循环似乎比使用
For…of
循环要快一点。然而，区别并不是那么重要，Chrome运行
for…of
的速度比原生
for
循环快，因此我建议在处理
对象时使用
for…of

在Firefox中，
for…In
循环非常慢，因此当我们想在迭代过程中缓存密钥时，最好使用
Object.keys
。另外，Chrome正在以相同的速度运行这两个结构（第一次和最后一次测试）


您可以在此处检查测试：

p是值

for (var key in p) {
  alert(key + ' => ' + p[key]);
}

或

对我有效的解决方案如下

_private.convertParams=function(params){
    var params= [];
    Object.keys(values).forEach(function(key) {
        params.push({"id":key,"option":"Igual","value":params[key].id})
    });
    return params;
}


var obj={
名称：“沙”，
年龄：“27”
}
目标
recursiveObj(validation_messages);

JSON.stringify(validation_messages,(field,value)=>{
  if(!field) return value;
  
  // ... your code
  
  return value;
})

Object.entries(validation_messages).map(([key,object]) => {

    alert(`Looping through key : ${key}`);

    Object.entries(object).map(([token, value]) => {
        alert(`${token} : ${value}`);
    });
});

export const iterate = (object, func) => {
  const entries = Object.entries(object).map(([key, value]) =>
    Array.isArray(value)
      ? [key, value.map(e => iterate(e, func))]
      : typeof value === 'object'
      ? [key, iterate(value, func)]
      : [key, func(value)]
  );
  return Object.fromEntries(entries);
};

const r = iterate(data, e=>'converted_'+e);
console.log(r);

var lunch = {
    sandwich: 'ham',
    age: 48,
};
lunch.forEach2(function (item, key) {
    console.log(key);
    console.log(item);
});

if (!Object.prototype.forEach2) {
    Object.defineProperty(Object.prototype, 'forEach2', {
        value: function (callback, thisArg) {
            if (this == null) {
                throw new TypeError('Not an object');
            }
            thisArg = thisArg || window;
            for (var key in this) {
                if (this.hasOwnProperty(key)) {
                    callback.call(thisArg, this[key], key, this);
                }
            }
        }
    });
}