在Typescript 4.1中，模板文字类型得到了相当大的升级。这是一个问题，我想解决了一段时间，并与一点调整设法想出这个：

type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}`
  ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
  : Lowercase<S>

type KeysToCamelCase<T> = {
    [K in keyof T as CamelCase<string &K>]: T[K] extends {} ? KeysToCamelCase<T[K]> : T[K]
}

interface SnakeCase {
    bar_value: string;
    baz_value: {
        blah_test: number;
    }
}

const transformed: KeysToCamelCase<SnakeCase> = {
    bazValue: {
        blahTest: 2
    },
    barValue: 'test'
}

我可以推荐阅读：https://dev.to/phenomnominal/i-need-to-learn-about-typescript-template-literal-types-51po，并尝试其中一些Typescript挑战https://github.com/type-challenges/type-challenges，以了解更多关于这些文字类型的信息。

如果你有一个嵌套数组的对象，你可以把它 Package 得更好。根据Max Eisenhardt的回答。
我们可以检查Array类型，如果是，则在现有功能中采用该Array的对象类型。
如果我们不这样做，数组函数将被标记为不可调用。

type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}`
    ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
    : Lowercase<S>

  type ObjectToCamel<T> = {
    [K in keyof T as CamelCase<string &K>]: T[K] extends Record<string, any> ? KeysToCamelCase<T[K]> : T[K]
  }

  type KeysToCamelCase<T> = {
    [K in keyof T as CamelCase<string &K>]: T[K] extends Array<any> ? KeysToCamelCase<T[K][number]>[] : ObjectToCamel<T[K]>
  }

而逆变换除了马克斯·艾森哈特的回答那些谁问：

type UpperCaseLetters = (
  'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' |
  'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' |
  'Y' | 'Z' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
)

type SnakeCaseSeq<S extends string> = S extends `${infer P1}${infer P2}`
  ? P1 extends UpperCaseLetters
    ? `_${Lowercase<P1>}${SnakeCaseSeq<P2>}`
    : `${P1}${SnakeCaseSeq<P2>}`
  : Lowercase<S>;

export type SnakeCase<S extends string> = S extends `${infer P1}${infer P2}`
  ? `${Lowercase<P1>}${SnakeCaseSeq<P2>}`
  : Lowercase<S>;

type ObjectToSnakeCase<T> = {
  [K in keyof T as SnakeCase<string &K>]: T[K] extends Record<string, any>
    ? KeysToSnakeCase<T[K]>
    : T[K];
};

export type KeysToSnakeCase<T> = {
  [K in keyof T as SnakeCase<string &K>]: T[K] extends Array<any>
    ? KeysToSnakeCase<T[K][number]>[]
    : ObjectToSnakeCase<T[K]>;
};

基于Max Eisenhardt和Hespen的回答，我建议即使你已经在你的原始类型中有了snake case键，这个解决方案也会起作用。否则，您将进行下一次转换：camelCase -> camelcase

type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}`
    ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
    : Lowercase<S>

type ObjectToCamel<T> = {
    [K in keyof T as CamelCase<string &K>]: T[K] extends Record<string, K> ? KeysToCamelCase<T[K]> : T[K]
}

type KeysToCamelCase<T> = {
    [K in keyof T as K extends `${infer P1}_${infer P2}`
        ? CamelCase<string &K>
        : K
    ]: T[K] extends Array<K>
        ? KeysToCamelCase<T[K][number]>[]
        : ObjectToCamel<T[K]>
}

我在向ChatGPT展示了另外两个答案后问它，它给了我这个，也解决了我之前遇到的它不能处理数组的问题。我测试了它，它似乎在所有情况下都有效：

type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}`
  ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
  : Lowercase<S>

type ObjectToCamel<T> = T extends Record<string, any>
  ? {
      [K in keyof T as CamelCase<string & K>]: T[K] extends Array<infer U>
        ? KeysToCamelCase<U>[]
        : T[K] extends Record<string, any>
        ? KeysToCamelCase<T[K]>
        : T[K]
    }
  : T

type KeysToCamelCase<T> = T extends Array<infer U>
  ? KeysToCamelCase<U>[]
  : ObjectToCamel<T>

其解释：The issue lies in the recursive part where you handle arrays in the KeysToCamelCase type. The current implementation doesn't properly handle arrays of objects. To address this, you need to differentiate between array types and non-array types in the recursive step.
虽然有点复杂。