我想补充上面的答案，因为您可能与Javascript有不同的意图。JSON对象和Javascript对象是不同的东西，您可能想使用上面提出的解决方案迭代JSON对象的财产，然后感到惊讶。

假设您有一个JSON对象，如：

var example = {
    "prop1": "value1",
    "prop2": [ "value2_0", "value2_1"],
    "prop3": {
         "prop3_1": "value3_1"
    }
}

迭代其“财产”的错误方式：

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        recursivelyIterateProperties(jsonObject[prop]);
    }
}

迭代prop1、prop2和prop3_1的财产时，您可能会惊讶地看到控制台记录0、1等。这些对象是序列，序列的索引是Javascript中该对象的财产。

递归迭代JSON对象财产的更好方法是首先检查该对象是否为序列：

function recursivelyIterateProperties(jsonObject) {
    for (var prop in Object.keys(example)) {
        console.log(prop);
        if (!(typeof(jsonObject[prop]) === 'string')
            && !(jsonObject[prop] instanceof Array)) {
                recursivelyIterateProperties(jsonObject[prop]);

            }
            
     }
}

如果您只想迭代映射属性值，则lodash具有_.mapValues

常量对象={a： 2，b： 3个}常量res=_.map值（obj，v=>v*2）console.log（res）<script src=“https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js“></script>

实现这一点的简单明了的方法，即不迭代原型的现代JS，如下所示：

Object.prototype.iterateProperties = ((callback) => {
   Object.keys(obj).filter(key => obj.hasOwnProperty(key)).forEach((key) => {
      callback(key, obj[key]);
   });
});

解释

这段代码在所有对象的原型中创建了一个可以在每个object实例中访问的函数。该函数迭代对象的所有自己的财产，并运行回调函数，该函数为对象中的每个属性获取（键、值）。

使用示例

obj.iterateProperties((key, value) => console.log(key + ': ' + value));

还添加了递归方式：

function iterate(obj) {
    // watch for objects we've already iterated so we won't end in endless cycle
    // for cases like var foo = {}; foo.bar = foo; iterate(foo);
    var walked = [];
    var stack = [{obj: obj, stack: ''}];
    while(stack.length > 0)
    {
        var item = stack.pop();
        var obj = item.obj;
        for (var property in obj) {
            if (obj.hasOwnProperty(property)) {
                if (typeof obj[property] == "object") {
                  // check if we haven't iterated through the reference yet
                  var alreadyFound = false;
                  for(var i = 0; i < walked.length; i++)
                  {
                    if (walked[i] === obj[property])
                    {
                      alreadyFound = true;
                      break;
                    }
                  }
                  // new object reference
                  if (!alreadyFound)
                  {
                    walked.push(obj[property]);
                    stack.push({obj: obj[property], stack: item.stack + '.' + property});
                  }
                }
                else
                {
                    console.log(item.stack + '.' + property + "=" + obj[property]);
                }
            }
        }
    }
}

用法：

iterate({ foo: "foo", bar: { foo: "foo"} }); 

在这里，我迭代每个节点并创建有意义的节点名称。如果您注意到，instanceOfArray和instanceOfObject几乎做了相同的事情（在我的应用程序中，我给出了不同的逻辑）

function iterate(obj,parent_node) {
    parent_node = parent_node || '';
    for (var property in obj) {
        if (obj.hasOwnProperty(property)) {
            var node = parent_node + "/" + property;
            if(obj[property] instanceof Array) {
                //console.log('array: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            } else if(obj[property] instanceof Object){
                //console.log('Object: ' + node + ":" + obj[property]);
                iterate(obj[property],node)
            }
            else {
                console.log(node + ":" + obj[property]);
            }
        }
    }
}

注：我受到了翁德雷·斯文达尔（Ondrej Svejdar）的回答的启发。但此解决方案具有更好的性能和更少的模糊性

Object.keys(obj).forEach(key =>
  console.log(`key=${key} value=${obj[key]}`)
);