Javascript 使用递归为数组中的每个项返回值

我试图在JavaScript中使用递归深入遍历对象并返回其键和值

这方面的一个例子是：

var json2 = {
  'key1': {
    'key2Nested': {
      'key3Nested': {
        'key4Nested': 'SomeValue'
      },
      'key5Nested': 'unimportantValue',
      'key6Nested': 'SimpleValue'
    },
    'key7Nested': '2SimpleValue',
    'key8Nested': 'unimportantValue2'
  }
};

该函数将接受上述输入并返回如下内容

['key1/key2Nested/key3Nested/key4Nested', 'SomeValue'],
['key1/key2Nested/key5Nested', 'unimportantValue'],

等所有值。 问题是我试图在对象的所有键上使用for循环，并尝试在循环内使用递归。但是递归值返回一个数组，该数组结束for循环

以下是我目前掌握的代码：

var makeArray = function(obj) {
      var keysArray = Object.keys(obj);
      var returnArray = [];

      for (var i = 0; i < keysArray.length; i++) {
          var key = keysArray[i];
          var next_results;
          var path, value;

          if (typeof(value) != 'object' ) {
              value = obj[key];
              returnArray = orderedArray.concat([key, value]);
          } else if (typeof(value) == "object") {
              next_results = makeArray(obj[key]);
              if (next_results) { 
                  for (var j = 0; j < next_results.length; j++) {
                    next_results[j][1] = '/' + key + next_results[j][1];
                    returnArray = returnArray.concat(next_results[j]);
                  }
              }
          } 
          console.log(returnArray);
          return returnArray;

      }

  }

var makeArray=函数（obj）{
var keysArray=Object.keys（obj）；
var returnArray=[]；
对于（var i=0；i

函数需要保存从更深层次递归返回的键，以便将其连接到路径

---

也许我的算法可以改进，或者我认为它错了。有人能给点建议吗？谢谢

只是不要

在for循环体内部返回returnArray

，而只在它之后返回

此外，还有一些其他错误：

线路

似乎不对。您的键位于每个元组的第一个插槽中，您希望斜杠位于键之间，而不是在键之前：

next_results[j][0] = key + '/' + next_results[j][0];

在

在分配

值之前，您正在测试
值的类型（以便基本上使用上一次迭代中的值）。在条件之前移动属性访问

方法调用

不会做你认为它会做的事。您正在传入要附加到数组中的元组（数组），但合并了两个数组：

[key1，value1].concat（[key2，value]）==[key1，value1，key2，value2]

。您希望改为使用获取元组数组

整体而言：

function makeArray(obj) {
    var keys = Object.keys(obj);
    var returnArray = [];

    for (var i = 0; i < keys.length; i++) {
        var key = keys[i],
            value = obj[key];

        if (typeof value != 'object' ) {
            returnArray.push([key, value]);
        } else {
            var next_results = makeArray(value);
            for (var j = 0; j < next_results.length; j++) {
                next_results[j][0] = key + '/' + next_results[j][0];
                returnArray.push(next_results[j]);
            }
        }
    }
    return returnArray;
}

函数makeArray（obj）{
var keys=Object.keys（obj）；
var returnArray=[]；
对于（变量i=0；i

var path, value;
if (typeof(value) != 'object' ) {
     value = obj[key];

returnArray = returnArray.concat(…)

function makeArray(obj) {
    var keys = Object.keys(obj);
    var returnArray = [];

    for (var i = 0; i < keys.length; i++) {
        var key = keys[i],
            value = obj[key];

        if (typeof value != 'object' ) {
            returnArray.push([key, value]);
        } else {
            var next_results = makeArray(value);
            for (var j = 0; j < next_results.length; j++) {
                next_results[j][0] = key + '/' + next_results[j][0];
                returnArray.push(next_results[j]);
            }
        }
    }
    return returnArray;
}