Typescript 通过函数传递确切的类型，但验证额外的字段

请考虑以下示例:

type Test = {
  field: number
}

function a(param: Record<string, Test>) {
  return param;
}

type Validation<T extends Record<string, Test>> = {
  [Prop in keyof T]: {
    /**
     * Iterate through keys of root properties
     * If a Key dont extends 'field' it means that it is anvialid key
     * and we can assign 'never' type to it so it will be unrepresentable
     */
    [Key in keyof T[Prop]]: Key extends 'field' ? T[Prop][Key] : never
  }
}
const b = <
  const Field extends Test,
  T extends Record<string, Field>
>(param: Validation<T>) => param

const x = b({
  first: {
    field: 13,
    notExists: -1, // TS2345:  Object literal may only specify known properties, and not_exists does not exist in type Test
  },
});


type xb = typeof x['first']['field'] // 13

Playground个

您需要遍历测试对象类型，并将never赋给每个非field键.

例如，如果类型测试={a:number；b:number}|{c:number，d:number}，则这将不起作用

请考虑以下几点:

// taken from here https://stackoverflow.com/questions/65805600/type-union-not-checking-for-excess-properties#answer-65805753
type UnionKeys<T> = T extends T ? keyof T : never;
type StrictUnionHelper<T, TAll> =
  T extends any
  ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;

type StrictUnion<T> = StrictUnionHelper<T, T>

type Test = StrictUnion<{ a: number; b: number } | { c: number, d: number }>

const b = <
  const Field extends Test,
  T extends Record<string, Field>
>(param: T) => param

const x = b({
  first: {
    a: 1,
    b: 1,
  },
});


type xb = typeof x['first']['a'] // 1

Playground个