在每个项目的键之间具有相同的泛型类型的类型

Question

我想编写一个类型记录函数，它接受这样的参数：

myFunc([
  {
    initialValue: 6, // number
    finalValue: 8    // number
  },
  {
    initialValue: 'hello', // string
    finalValue: 'goodbye'  // string
  }
])

但如果考虑到这一点，就会失败：

myFunc([
  {
    initialValue: 6, // number
    finalValue: 'goodbye' // should fail because not a number!
  }
])

它感觉这个解决方案应该包含泛型，但是在每个数组项中是泛型的，而不是整个数组中的泛型。

编辑：我想要一个解决方案，它可以处理任何类型的值，而不仅仅是字符串或整数。我可能也需要将它用于类/函数。

Answer 1

您可以使用泛型和映射类型获得这样的结果。我们将使用类型参数来捕获参数的实际类型(不管是什么，即使is确实包含无效的初始/最终对)。然后，我们将此类型转换为一个新类型，其中finalValue是根据传入的实际initialValue输入的。我们将这个新类型与参数类型中的交集一起使用。这将意味着将参数的类型推断为类型参数，但对照转换后的类型进行检查：

type FinalValues<T extends Array<{ initialValue: any }>> = {
    [P in keyof T]: T[P] extends { initialValue: infer I } ? { initialValue: I, finalValue: I }: never 
}

function myFunc<T extends [{ initialValue: any }] | Array<{ initialValue: any }>>(v: T & FinalValues<T>): FinalValues<T> {

}

myFunc([
  {
    initialValue: 6, // number
    finalValue: 8    // number
  },
  {
    initialValue: 'hello', // string
    finalValue: 'goodbye'  // string
  }
])

myFunc([
  {
    initialValue: 6, // number
    finalValue: "string"    // err
  },
  {
    initialValue: 'hello', // string
    finalValue: 1  // err
  }
])

玩

您还可以更有创造性地添加一种自定义错误，以便这些错误更易读：玩。

Answer 2

解决方案是将列表元素类型定义为成员或两个字符串或两个数字的和类型。

type A = {
  initialValue: number
  finalValue: number
}
type B = {
  initialValue: string
  finalValue: string
}

type ListAB = (A | B) [] // type contains or A(two numbers) or B(two strings)

现在，具有ListAB类型的数组严格由Sum A | B输入。示例用法：

function myFunc(list: ListAB) {
  // implementation
}

// correct
myFunc([
  {
    initialValue: 6, // number
    finalValue: 8    // number
  },
  {
    initialValue: 'hello', // string
    finalValue: 'goodbye'  // string
  }
])

// will have error
myFunc([
  {
    initialValue: 6, // number
    finalValue: 'a'    // string
  },
  {
    initialValue: 1, // number
    finalValue: 'goodbye'  // string
  }
])

Answer 3

也许你可以试试下面这样的方法。我不能百分之百确定它是否正确，但是它适用于上面提到的场景。

interface type1 {
    arg1: Array<string>,
    arg2: Array<string>
}

interface type2 {
    arg1: Array<number>,
    arg2: Array<number>
}

var t = function Test(arg: type1 | type2) {
    alert(arg.arg1);
    alert(arg.arg2);
}

var arg = { arg1: [2], arg2: [1]};
t(arg);

告诉我你的想法。