Javascript 递归地将对象字段从snake case转换为camelCase

我有一个这样的对象（snake\u案例中的字段）

我想递归地将其字段转换为camelCase，因此预期输出如下所示

const obj = {
  vtCoreRandom: {
    userDetails: {
      firstName: "xyz",
      lastName: "abc",
      groups: [
        {
          id: 1,
          groupType: "EXT"
        },
        {
          id: 2,
          groupType: "INT"
        }
      ],
      addressType: {
        cityName: "LMN",
        state: {
          codeName: "KOP",
          name: "PSQ"
        }
      }
    }
  }
};

---

我试着使用mapKeys（），但我就是不能理解其中的递归部分。非常感谢您的帮助。此外，我还可以使用

lodash

，如果它使流程变得更简单

您可以尝试以下方法：

const obj={
vt_core_random：{
用户信息：{
名字：“xyz”，
姓氏：“abc”，
小组：[
{
id:1，
组类型：“外部”
},
{
id:2，
组类型：“INT”
}
],
地址类型：{
城市名称：“纳希克”，
声明：{
代码名称：“MH”，
名称：“马哈拉施特拉邦”
}
}
}
}
};
const toCamel=（str）=>{
返回str.replace（/（[-[a-z]）/ig，（$1）=>{
返回$1.toUpperCase（）
.替换（'-'，''）
.替换（“”，“”）；
});
};
常量isObject=函数（obj）{
返回obj==Object（obj）&&！Array.isArray（obj）&&typeof obj！='function'；
};
常量=函数（obj）{
if（对象（obj））{
常数n={}；
对象键（obj）
.forEach（（k）=>{
n[toCamel（k）]=keysToCamel（obj[k]）；
});
返回n；
}else if（Array.isArray（obj））{
返回对象映射（（i）=>{
返回（i）；
});
}
返回obj；
};
console.log（keystamel（obj））
我在这段代码中使用了lodash。
对于所有使用lodash的人，我已经操纵了公认的答案，因为lodash已经包含了实用功能，如isArray

isObject

camelCase

因此，代码简化为：

您可以使用lodash创建递归函数，该函数迭代键并使用camel大小写转换它们。Transform还可以处理数组，是迭代对象（

target）

是数组，我们不需要更改键

const camelize=obj=>转换（obj，（acc，value，key，target）=>{
常数camelKey=u.isArray（目标）？键：u.camelCase（键）；
acc[camelKey]=等分对象（值）？camelize（值）：值；
});
const obj={“vt_core_random”：{“user_details”：{“first_name”：“xyz”，“last_name”：“abc”，“groups”：[{“id”：1，“groupu type”：“EXT”}，{“id”：2，“groupu type”：“INT”}]，“address_type”：{“city_name”：“nashik”，“state”：{“code_name”：“MH”，“name”：“马哈拉施特拉邦”}；
const result=camelize（obj）；
控制台日志（结果）
您可以以一种相当通用的方式完成此操作，编写一个接受任意键转换函数的函数，然后返回一个接受对象并返回一个具有相同结构但已转换键的函数。这基本上并不比编写专门用于优化键的代码更难

以下是一种方法：


constfixkeys=（fn）=>（obj）=>Object.fromEntries(
Object.entries（obj.map）（[k，v]）=>[
fn（k），
Array.isArray（v）？v.map（fixKeys（fn））：v的类型=='object'？fixKeys（fn）（v）：v
])
)
常数camelCase=（s）=>s.replace（/（.）/g，（s，c）=>c.toUpperCase（））
常数camelizeKeys=固定键（camelCase）
const obj={vt_core_random:{user_details:{first_name:“xyz”，last_name:“abc”，组：[{id:1，组类型：“EXT”}，{id:2，组类型：“INT”}]，地址类型：{city_name:“nashik”，州：{code_name:“MH”，name:“Maharashtra”}}
log（camelizeKeys（obj））
适用于使用typescript的用户。我在这个问题的公认答案上加了打字

const toCamel = (str: string): string => {
  return str.replace(/([_-][a-z])/gi, ($1: string) => {
    return $1.toUpperCase().replace('-', '').replace('_', '');
  });
};

const isArray = function (
  input: Record<string, unknown> | Record<string, unknown>[] | unknown
): input is Record<string, unknown>[] {
  return Array.isArray(input);
};

const isObject = function (
  obj: Record<string, unknown> | Record<string, unknown>[] | unknown
): obj is Record<string, unknown> {
  return (
    obj === Object(obj) && !Array.isArray(obj) && typeof obj !== 'function'
  );
};

const camelize = function <T>(input: T): T {
  return (function recurse<
    K extends Record<string, unknown> | Record<string, unknown>[] | unknown
  >(input: K): K {
    if (isObject(input)) {
      return Object.keys(input).reduce((acc, key) => {
        return Object.assign(acc, { [toCamel(key)]: recurse(input[key]) });
      }, {} as K);
    } else if (isArray(input)) {
      return input.map((i) => recurse(i)) as K;
    }
    return input;
  })(input);
};

consttocamel=（str:string）：string=>{
返回str.replace（/（[[u-][a-z]）/gi，（$1:string）=>{
返回$1.toUpperCase（）.replace（'-'，''）.replace（'''''，''）；
});
};
常量isArray=函数(
输入：记录|记录[]|未知
)：输入为记录[]{
返回数组.isArray（输入）；
};
常量isObject=函数(
obj:记录|记录[]|未知
)：obj是记录{
返回(
obj==对象（obj）&&！数组.isArray（obj）&&typeof obj！=='function'
);
};
常数camelize=函数（输入：T）：T{
返回（函数递归）<
K扩展记录|记录[]|未知
>（输入：K）：K{
if（isObject（输入））{
返回对象。键（输入）。减少（（acc，键）=>{
返回Object.assign（acc，{[toCamel（key）]：recurse（input[key]）}）；
}，{}作为K）；
}else if（isArray（输入））{
返回input.map（（i）=>recurse（i））作为K；
}
返回输入；
})（输入）；
};
这不起作用，因为lodash中的
isObject
为数组返回true
检查值是否为对象的语言类型。（例如数组、函数、对象、正则表达式、新数字（0）和新字符串（“”））
@cip123修复了此问题。
const obj = {
  vt_core_random: {
    user_details: {
      first_name: "xyz",
      last_name: "abc",
      groups: [
        {
          id: 1,
          group_type: "EXT"
        },
        {
          id: 2,
          group_type: "INT"
        }
      ],
      address_type: {
        city_name: "nashik",
        state: {
          code_name: "MH",
          name: "Maharashtra"
        }
      }
    }
  }
};

function toCamel(o) {
  var newO, origKey, newKey, value
  if (o instanceof Array) {
    return o.map(function(value) {
        if (typeof value === "object") {
          value = toCamel(value)
        }
        return value
    })
  } else {
    newO = {}
    for (origKey in o) {
      if (o.hasOwnProperty(origKey)) {
        newKey = _.camelCase(origKey)
        value = o[origKey]
        if (value instanceof Array || (value !== null && value.constructor === Object)) {
          value = toCamel(value)
        }
        newO[newKey] = value
      }
    }
  }
  return newO
}

console.log(toCamel(obj));    const obj = {
  vt_core_random: {
    user_details: {
      first_name: "xyz",
      last_name: "abc",
      groups: [
        {
          id: 1,
          group_type: "EXT"
        },
        {
          id: 2,
          group_type: "INT"
        }
      ],
      address_type: {
        city_name: "nashik",
        state: {
          code_name: "MH",
          name: "Maharashtra"
        }
      }
    }
  }
};

function toCamel(o) {
  var newO, origKey, newKey, value
  if (o instanceof Array) {
    return o.map(function(value) {
        if (typeof value === "object") {
          value = toCamel(value)
        }
        return value
    })
  } else {
    newO = {}
    for (origKey in o) {
      if (o.hasOwnProperty(origKey)) {
        newKey = _.camelCase(origKey)
        value = o[origKey]
        if (value instanceof Array || (value !== null && value.constructor === Object)) {
          value = toCamel(value)
        }
        newO[newKey] = value
      }
    }
  }
  return newO
}

console.log(toCamel(obj));

function keysToCamel(obj) {
  if (isPlainObject(obj)) {
    const n = {};
    Object.keys(obj).forEach(k => (n[camelCase(k)] = keysToCamel(obj[k])));
    return n;
  } else if (isArray(obj)) obj.map(i => keysToCamel(i));
  return obj;
}

const toCamel = (str: string): string => {
  return str.replace(/([_-][a-z])/gi, ($1: string) => {
    return $1.toUpperCase().replace('-', '').replace('_', '');
  });
};

const isArray = function (
  input: Record<string, unknown> | Record<string, unknown>[] | unknown
): input is Record<string, unknown>[] {
  return Array.isArray(input);
};

const isObject = function (
  obj: Record<string, unknown> | Record<string, unknown>[] | unknown
): obj is Record<string, unknown> {
  return (
    obj === Object(obj) && !Array.isArray(obj) && typeof obj !== 'function'
  );
};

const camelize = function <T>(input: T): T {
  return (function recurse<
    K extends Record<string, unknown> | Record<string, unknown>[] | unknown
  >(input: K): K {
    if (isObject(input)) {
      return Object.keys(input).reduce((acc, key) => {
        return Object.assign(acc, { [toCamel(key)]: recurse(input[key]) });
      }, {} as K);
    } else if (isArray(input)) {
      return input.map((i) => recurse(i)) as K;
    }
    return input;
  })(input);
};