Javascript将下划线大小写转换为小写大小写

我有一个API，它在

undescore\u case

中返回响应，前台使用

lowercase

。我还使用NodeJS在前端和后端之间进行调解

我想将任何类型的Javascript变量转换为

lowerCamelCase

，为此我编写了以下函数：

function transform(any) {
    if(Array.isArray(any)) {
        any.forEach((v, k) => any[k] = transform(v));
    } else if(typeof any === "object" && any != null) {
        Object.keys(any).forEach(key => {
            let t = key.replace(/_\w/g, (m) => m[1].toUpperCase());
            if(t !== key) {
                any[t] = transform(any[key]);
                delete any[key];
            }
        });
    }

    return any;
}

它是有效的，但我想知道是否有任何方法可以让它更快

我生成此数据，例如：

let list = [];
for(let i = 0; i < 1000; i++)
    list.push({
        some_thing: {
            aa_bb: 1,
            bb_cc: 2,
            cc_dd: 3
        },
        stuff_underscore: "aaa",
        ordinary: 1
    });

---

那么，有什么方法可以加快转换速度吗？

您可以使用第二个参数

JSON.parse

在反序列化过程中进行转换。与反序列化后遍历结果相比，这可能会节省一些时间：

var myJson='[{“aa_aa:1，“bb_bb:2}，{“cc_cc:3}]；
var obj=JSON.parse（myJson，（键，值）=>{
if（typeof value=='object'&&！Array.isArray（value））{object.keys（value）.forEach（keyInner=>{
设t=keyInner.replace（/\uw/g，m=>m[1].toUpperCase（））；
如果（t！==keyInner）{
值[t]=值[keyInner]；
删除值[keyInner]；
}
});
}
返回值；
});
控制台日志（obj）您正在做（至少）三件众所周知非常慢的事情：在循环中重复条件检查、正则表达式和删除对象键

const transform = obj => {
  const keys = Object.keys(obj);
  const newKeys = keys.map(k => {
    const [first, ...rest] = k.split('_');
    return first + rest.reduce((acc, s) => {
      return acc + s[0].toUpperCase() + s.slice(1);
    }, '');
  });
  return newKeys.reduce((acc, k, i) => {
    acc[k] = obj[keys[i]];
    return acc;
  }, {});
};

现在我们使用字符串函数而不是正则表达式，构造新对象而不是就地修改对象，并且在转换函数中不做任何条件检查（这些检查应该在调用它之前进行）。
如果您自己反序列化它（使用
JSON.parse
），您可以在反序列化过程中更改键。您是在反序列化它，还是库在为您反序列化？这可能更适合CodeReview SE而不是这里。按照这些思路：保持简单。与其对参数类型进行条件检查，不如只使用一个作用于对象的函数，然后将其映射到一个对象数组上。我自己使用的是
JSON.parse
。@JaredSmith问题是，API可以返回一个数字、一个对象、一个数组、一个包含对象数组的对象数组等等。@Amit那又怎么样？不要用一堆不必要的条件逻辑使函数复杂化。一个函数检查返回类型，另一个函数调用以更改键。每个功能坚持一件事，而不是一个厨房水槽功能。否则，它必须在每次递归时进行所有条件检查，而不是在从API获取返回值时仅进行一次。这似乎是一个很好的解决方案。这看起来也是朝着正确方向迈出的一步，但它如何解决数组的问题，还是对象内部的数组？你是说
.split
和
.reduce
的复杂混乱比
RegEx#replace
更快？当然要详细得多。你是说从头开始创建一个全新的对象会更快地删除和添加属性吗？此外，这也不能满足OP的要求，因为它不处理任何属性值。对于数组，您只需将其映射到数组上。对于嵌套，您使用递归的想法是正确的，但您希望将其移动到一个单独的函数中，该函数调用我编写的函数。这个概念被称为单一责任原则。为了解决这个问题，这个解决方案虽然在上面的小例子中起作用，但在我的测试中需要多花20-30%的时间
const transform = obj => {
  const keys = Object.keys(obj);
  const newKeys = keys.map(k => {
    const [first, ...rest] = k.split('_');
    return first + rest.reduce((acc, s) => {
      return acc + s[0].toUpperCase() + s.slice(1);
    }, '');
  });
  return newKeys.reduce((acc, k, i) => {
    acc[k] = obj[keys[i]];
    return acc;
  }, {});
};