Javascript 递归重命名对象键

我有一个递归函数来重命名一个对象的键名，但我不知道如何重命名其中两个键（问题键是对象）

我认为问题在于我在哪里检查对象类型，但如何在那一点上重命名键

实际阵列非常大，但下面是精简版

谢谢你的帮助

var keys_short = ['ch','d','u','tz'];
var keys_long = ['children','data','user_id','time_zone'];
function refit_keys(o){
    build = {};
    for (var i in o){
        if(typeof(o[i])=="object"){
            o[i] = refit_keys(o[i]);
            build = o;
        }else{
            var ix = keys_short.indexOf(i);
            if(ix!=-1){
                build[keys_long[ix]] = o[keys_short[ix]];
            }
        }
    }
    return build;
}

我的输入如下所示：

{
    "id":"1",
    "ch":[
        {
            "id":"3",
            "ch":[
            ],
            "d":{
                "u":"3",
                "tz":"8.00"
            }
        },
        {
            "id":"45",
            "ch":[
                {
                    "id":"70",
                    "ch":[
                        {
                            "id":"43",
                            "ch":[
                            ],
                            "d":{
                                "u":"43",
                                "tz":"-7.00"
                            }
                        }
                    ],
                    "d":{
                        "u":"70",
                        "tz":"-7.00"
                    }
                }
            ],
            "d":{
                "u":"45",
                "tz":"-7.00"
            }
        }
    ],
    "d":{
        "u":"1",
        "tz":"8.00"
    }
}

{
    "id":"1",
    "ch":[
        {
            "id":"3",
            "ch":[
            ],
            "d":{
                "user_id":"3",
                "time_zone":"8.00"
            }
        },
        {
            "id":"45",
            "ch":[
                {
                    "id":"70",
                    "ch":[
                        {
                            "id":"43",
                            "ch":[
                            ],
                            "d":{
                                "user_id":"43",
                                "time_zone":"-7.00"
                            }
                        }
                    ],
                    "d":{
                        "user_id":"70",
                        "time_zone":"-7.00"
                    }
                }
            ],
            "d":{
                "user_id":"45",
                "time_zone":"-7.00"
            }
        }
    ],
    "d":{
        "user_id":"1",
        "time_zone":"8.00"
    }
}

我的输出如下：

{
    "id":"1",
    "ch":[
        {
            "id":"3",
            "ch":[
            ],
            "d":{
                "u":"3",
                "tz":"8.00"
            }
        },
        {
            "id":"45",
            "ch":[
                {
                    "id":"70",
                    "ch":[
                        {
                            "id":"43",
                            "ch":[
                            ],
                            "d":{
                                "u":"43",
                                "tz":"-7.00"
                            }
                        }
                    ],
                    "d":{
                        "u":"70",
                        "tz":"-7.00"
                    }
                }
            ],
            "d":{
                "u":"45",
                "tz":"-7.00"
            }
        }
    ],
    "d":{
        "u":"1",
        "tz":"8.00"
    }
}

{
    "id":"1",
    "ch":[
        {
            "id":"3",
            "ch":[
            ],
            "d":{
                "user_id":"3",
                "time_zone":"8.00"
            }
        },
        {
            "id":"45",
            "ch":[
                {
                    "id":"70",
                    "ch":[
                        {
                            "id":"43",
                            "ch":[
                            ],
                            "d":{
                                "user_id":"43",
                                "time_zone":"-7.00"
                            }
                        }
                    ],
                    "d":{
                        "user_id":"70",
                        "time_zone":"-7.00"
                    }
                }
            ],
            "d":{
                "user_id":"45",
                "time_zone":"-7.00"
            }
        }
    ],
    "d":{
        "user_id":"1",
        "time_zone":"8.00"
    }
}

---

问题之一可能是变量

build

实际上是一个全局变量。因此，它只包含递归中第一个深度的结果

---

在

build

之前添加

var

应该可以解决部分问题。

这里有几个问题

一个是由于未能在函数中声明

build

变量而受到攻击

但逻辑也有问题，这里有一个最小的修改：

var keys_short = ["ch","d","u","tz"];
var keys_long = ["children","data","user_id","time_zone"];
function refit_keys(o){
    var build, key, destKey, ix, value;

    // Only handle non-null objects
    if (o === null || typeof o !== "object") {
        return o;
    }

    // Handle array just by handling their contents
    if (Array.isArray(o)) {
        return o.map(refit_keys);
    }

    // We have a non-array object
    build = {};
    for (key in o) {
        // Get the destination key
        ix = keys_short.indexOf(key);
        destKey = ix === -1 ? key : keys_long[ix];

        // Get the value
        value = o[key];

        // If this is an object, recurse
        if (typeof value === "object") {
            value = refit_keys(value);
        }

        // Set it on the result using the destination key
        build[destKey] = value;
    }
    return build;
}

实例：

“严格使用”；
变量输入={
“id”：“1”，
“ch”：[
{
“id”：“3”，
“ch”：[
],
“d”：{
“u”：“3”，
“tz”：“8.00”
}
},
{
“id”：“45”，
“ch”：[
{
“id”：“70”，
“ch”：[
{
“id”：“43”，
“ch”：[
],
“d”：{
“u”：“43”，
“tz”：“-7.00”
}
}
],
“d”：{
“u”：“70”，
“tz”：“-7.00”
}
}
],
“d”：{
“u”：“45”，
“tz”：“-7.00”
}
}
],
“d”：{
“u”：“1”，
“tz”：“8.00”
}
};
var key_short=[“ch”、“d”、“u”、“tz”]；
var keys_long=[“子项”、“数据”、“用户id”、“时区”]；
功能重新安装按键（o）{
var构建，键，键，ix，值；
//仅处理非空对象
如果（o==null | | o的类型！==“对象”）{
返回o；
}
//仅通过处理数组的内容来处理数组
if（数组isArray（o））{
返回o.map（重新安装_键）；
}
//我们有一个非数组对象
build={}；
用于（输入o）{
//获取目标密钥
ix=键\u短索引（键）；
destKey=ix==-1？键：键长[ix]；
//获取值
值=o[键]；
//如果这是一个对象，则递归
如果（值的类型==“对象”）{
值=重新安装钥匙（值）；
}
//使用目标键在结果上设置它
构建[destKey]=值；
}
返回构建；
}
控制台日志（重新安装按键（输入））
。作为控制台包装器{
最大高度：100%！重要；
}
有点晚了，但我正在寻找一个很好的、也能处理阵列的简短实现（前面的答案没有），因此我决定发布我的通用ES6实现，因为它可能会帮助一些人：

function deepMapKeys(originalObject, callback) {
  if (typeof originalObject !== 'object') {
    return originalObject
  }

  return Object.keys(originalObject || {}).reduce((newObject, key) => {
    const newKey = callback(key)
    const originalValue = originalObject[key]
    let newValue = originalValue
    if (Array.isArray(originalValue)) {
      newValue = originalValue.map(item => deepMapKeys(item, callback))
    } else if (typeof originalValue === 'object') {
      newValue = deepMapKeys(originalValue, callback)
    }
    return {
      ...newObject,
      [newKey]: newValue,
    }
  }, {})
}

就有关个案而言，电话为：

deepMapKeys(inputObject, key => (keys_long[keys_short.indexOf(key)] || key))

也就是说，如果您可以使用npm，那么有几个包（这里是…）
我喜欢这种方法。但我偶然发现：

您可以这样称呼它：
deepMapKeys（{testValue:[“justString”]}，key=>（key））

返回值包含：

{0: "j", 1: "u", 2: "s", 3: "t", 4: "S", 5: "t", 6: "r", 7: "i", 8: "n", 9: "g"}

长度：1

会说，它将我的字符串转换为数组。
不，这不是唯一的问题。这是一个问题，不仅仅是一个问题，更重要的是。很好地工作，教会了我一些东西，并找到了一种更好的方法任何证明seconf方法更好/更快的证据？@benoror：我不认为我声称它更好或更快，但一般来说，并行阵列是一个维护问题。太容易修改其中一个而不是另一个。更难错误地修改属性初始值设定项的一半。；-）@潘曼-谢谢！我已经解决了这个问题，并且通常会更新一点。感谢@Chris H.的反馈，我已经更新了答案来解决这个用例。你应该直接评论我的答案，因为这不是问题的答案，所以很混乱。另外，除非你对答案发表评论，否则我不会收到任何通知（我无意中注意到你的反馈）。干杯，感谢您提供这些软件包的链接。