Typescript 创建具有只读和可选属性的映射类型(还保留顺序)

一种方法是按如下方式编写ToObj:

type ToObj<T extends Record<keyof T, PropertyAttributes>> = {
  -readonly [K in keyof T]-?: (x:
    MaybeOptional<
      MaybeReadonly<
        Record<K, T[K]['value']
        >, T[K]['readonly']
      >, T[K]['optional']
    >) => void }[keyof T] extends ((x: infer I) => void) ?
  { [K in keyof I]: I[K] } : never;

其中MaybeOptional<T, B>和MaybeReadonly<T, B>是实用程序类型，它们根据布尔式B是否为true而将Partial或Readonly应用于对象类型T:

type MaybeOptional<T, B extends boolean | undefined> =
  B extends true ? Partial<T> : T

type MaybeReadonly<T, B extends boolean | undefined> =
  B extends true ? Readonly<T> : T;

ToObj<T>在这里的工作方式是使用mapped type依次遍历T的每个属性，并创建一个具有optional或readonly位的单个属性对象.在这里，让我们把这一部分分解成它自己的东西:

type ToObjStepOne<T extends Record<keyof T, PropertyAttributes>> = {
  -readonly [K in keyof T]-?:
  MaybeOptional<
    MaybeReadonly<
      Record<K, T[K]['value']
      >, T[K]['readonly']
    >, T[K]['optional']
  > }

您可以看到这在输入类型上的行为:

type S1 = ToObjStepOne<{
  readonlyRequired: { readonly: true; value: "someValue" };
  readonlyOptional: { readonly: true; optional: true; value: "someValue" };
  mutableRequired: { value: "someValue" };
  mutableOptional: { optional: true; value: "someValue" };
}>;
/* type S1 = {
    readonlyRequired: Readonly<Record<"readonlyRequired", "someValue">>;
    readonlyOptional: Partial<Readonly<Record<"readonlyOptional", "someValue">>>;
    mutableRequired: Record<"mutableRequired", "someValue">;
    mutableOptional: Partial<Record<"mutableOptional", "someValue">>;
} */

然后我们使用从Transform union type to intersection type开始的相同技术，我们将每个属性放在contravariant的位置，这样我们就可以推断出单个intersection:

type ToObjStepTwo<T extends Record<keyof T, PropertyAttributes>> =
  ToObjStepOne<T> extends infer T1 ?
  { [K in keyof T1]: (x: T1[K]) => void }[keyof T1] extends
  (x: infer I) => void ? I : never
  : never

type S2 = ToObjStepTwo<{⋯}>
/* type S2 = 
  Readonly<Record<"readonlyRequired", "someValue">> & 
  Partial<Readonly<Record<"readonlyOptional", "someValue">>> & 
  Record<"mutableRequired", "someValue"> & 
  Partial<Record<"mutableOptional", "someValue">> 
*/

你可以看到，这个十字路口基本上就是你想要的类型，尽管它很难看.至少这些属性的顺序是正确的.因此，如果我们现在在对象上进行最后一点映射，它将把丑陋的交叉点变成单一的对象类型:

type ToObjStepThree<T extends Record<keyof T, PropertyAttributes>> =
  ToObjStepTwo<T> extends infer T2 ?
  { [K in keyof T2]: T2[K] }
  : never

type S3 = ToObjStepThree<{⋯}>
/* type S3 = {
    readonly readonlyRequired: "someValue";
    readonly readonlyOptional?: "someValue" | undefined;
    mutableRequired: "someValue";
    mutableOptional?: "someValue" | undefined;
} */

让我们确保这是我们在运行单件定义时得到的结果:

type T1 = ToObj<{
  readonlyRequired: { readonly: true; value: "someValue" };
  readonlyOptional: { readonly: true; optional: true; value: "someValue" };
  mutableRequired: { value: "someValue" };
  mutableOptional: { optional: true; value: "someValue" };
}>;
/* type T1 = {
    readonly readonlyRequired: "someValue";
    readonly readonlyOptional?: "someValue" | undefined;
    mutableRequired: "someValue";
    mutableOptional?: "someValue" | undefined;
} */

看上go 不错！

Playground link to code个