将接口键映射到键值对数组

Question

给定一些接口

例如

interface Person {
    name: string;
    age: number ;
}

我想创建一个接受以下参数的通用函数

const res = Result.combineValues<Person>(
    { age: 18 },
    { name: 'John Doe' }
);

目前为止

class Result<T> {

    readonly value: T;

    private constructor(value: T) {
        this.value = value;
    }

    public static combineValues<T>(...results: { [key in keyof T]?: Result<T[key]> | T[key] }[]): Result<T> {
        let value: T;
        // ... compute value
        return new Result<T>(value);
    }
}

但问题是它允许未定义的值

const res = Result.combineValues<Person>(
    { age: undefined }, // this should give a compile error because age should be a number or Result<number>
    { name: 'John Doe' }
);

并且它不会验证所有属性都已定义

const res = Result.combineValues<Person>(
    { age: 18 } 
    // should give a compile error because `{name: 'Some Name'}` is missing from argument list
); 

Answer 1

Typescript 没有任何方法可以将联合或交集类型分解为其组成部分，或者指定许多未知类型必须“加起来”为已知类型。

出于这个原因，使函数在 Result 类型上成为泛型并尝试对可变参数元组强制执行条件是行不通的。

相反：我们在它传递的类型元组上使函数泛型，并根据所有这些类型的交集推断函数的返回类型。然后，您可以通过将函数的返回值分配给 Result<Person> 类型的变量来强制执行编译时约束，这将确保分配有效。

为了允许 Result 类的实例，我们还指定了一个类型来替换 Result<T> with T 类型的所有成员。

type ReplaceResultsIn<Obj> = {
  [Key in keyof Obj]: Obj[Key] extends Result<infer T> ? T : Obj[Key]
}
type Combine<T extends unknown[]> = T extends [infer First, ...infer Rest] ? (ReplaceResultsIn<First>) & Combine<Rest> : unknown

然后我们输入combineValues 函数返回Combine< the argument types >：

class Result<T> {
  readonly value: T;

  public constructor(value: T) {
    this.value = value;
  }
  public static combineValues<T extends object[]>(...args: T): Result<Combine<T>> {
        let value!: Combine<T>;
        // ... compute value
        return new Result<Combine<T>>(value);
    }
}

这个类的消费者现在可以存在类型安全：

interface Person {
  name: string;
  age: number;
};

// these are all OK
const person: Result<Person> = Result.combineValues({age: new Result(21)}, {name: ""});
const person2: Result<Person> = Result.combineValues({age: 21, name: ""});
const person3: Result<Person> = Result.combineValues({age: 21}, {name: ""});
const person4: Result<Person> = Result.combineValues({name: new Result("")}, {age: new Result(21)});

// these are all bad
const person5: Result<Person> = Result.combineValues({});
const person6: Result<Person> = Result.combineValues({age: 21});
const person7: Result<Person> = Result.combineValues({name: 21}, {age: 21});
const thing = Result.combineValues("");
const thing2 = Result.combineValues(null);

Playground link