在挑选功能（TypeScript）中挑选后约束\'pickable\'属性

Question

我在我的代码库中创建了以下 util 函数：

const pick = <T extends object, P extends keyof T, R = Pick<T,P>>(
obj: T,
keys: P[]
): R => {
if (!obj) return {} as R
return keys.reduce((acc, key) => {
   return {...acc, [key]:obj[key] };
}, {} as R)
};

该函数工作正常，并且 TS 推断出正确的返回类型。唯一的问题是 keys 参数，我想根据之前选择的键来限制它。

例子：

const obj = {name: 'John Doe', age: '33', city: 'NYC'} 

// When typing the keys in the keys array param, it infers the keys correctly
const a = pick(obj, ['name', 'age']) 

// BUT, this is also possible, and TS doesnt complain
const b = pick(obj, ['name', 'age', 'age']) 

// ALSO, when I have already entered for example 'name', I want intellisense only to show 'age' and 'city' as possible options, currently it still shows all keys.

我尝试了很多东西（甚至对函数进行了柯里化），但没有成功，事实证明这是一个艰难的 TS 难题。我希望我能得到一些帮助！

Answer 1

TypeScript 本身并不支持没有重复元素的“唯一”数组的概念。所以没有简单的方法来写keys: UniqueArray<P>。

相反，您可以尝试构建一个复杂的generic 和conditional 类型，其作用类似于您为keys 传入的tuple type 的约束，其中每个元素类型excludes 所有先前的元素类型。因此，如果您传入一个K extends Array<keyof T> 类型的数组，编译器将确保K 可分配给ExcludeArray<keyof T, K>，如果没有则抱怨。

它可能看起来像这样：

type ExcludeArray<T, U extends any[], A extends any[] = []> =
    number extends U['length'] ? [...T[]] : (
        U extends [infer F, ...infer R] ?
        ExcludeArray<Exclude<T, F>, R, [...A, F extends T ? F : T]> : A
    );

function pick<T extends object, K extends Array<keyof T>>(
    obj: T,
    keys: [...K] extends ExcludeArray<keyof T, K> ? K : ExcludeArray<keyof T, K>
): Pick<T, K[number]>;
function pick(obj: any, keys: PropertyKey[]) {
    if (!obj) return {}
    return keys.reduce((acc, key) => {
        return { ...acc, [key]: obj[key] };
    }, {})
};

ExcludeArray<T, U> 类型接受 T 类型和元组类型 U 并遍历 U 构建它的一个版本，其中每个元素都排除所有先前的元素：

type Example1 = ExcludeArray<1 | 2 | 3 | 4, [1, 2, 3, 4]> 
// type Example1 = [1, 2, 3, 4]
type Example2 = ExcludeArray<1 | 2 | 3 | 4, [1, 2, 2, 4]> 
// type Example2 = [1, 2, 3 | 4, 4]

所以Example1和传入的U是一样的，因为没有重复。但Example2 显示第三个元素已从2（重复）更改为3 | 4（当时允许的值）。

请注意，在一个完美的世界中，我们可以这样写pick()

function pick<T extends object, K extends ExcludeArray<keyof T, K>>(
  obj: T, keys: K
): Pick<T, K[number]> {...}

但是约束K extends ExcludeArray<keyof T, K>> 是非法循环的。相反，我们需要跳过K extends Array<keyof T> 在声明时的圈套，然后我们说服编译器将K 视为在使用站点受到如此限制，因此keys: [...K] extends ExcludeArray<keyof T, K> ? K : ExcludeArray<keyof T, K>。

---

无论如何，让我们测试一下：

const obj = { name: 'John Doe', age: '33', city: 'NYC' }

const a = pick(obj, ['name', 'age']); // okay
const b = pick(obj, ['name', 'age', 'age']); // error!  
// -------------------------------> ~~~~~
// Type '"age"' is not assignable to type '"city"'
const c = pick(obj, ["name", "age", "ss"])
// -------------------------------> ~~~~
// Type '"ss"' is not assignable to type '"name" | "age" | "city"'

这表现得如愿。

---

不幸的是，正如您所注意到的，您没有从 IntelliSense 获得自动完成提示行为。当您正在调用pick() 时，提示的值将是完整的键集，甚至是您已经使用过的键：

const d = pick(obj, ["age", "?"]) 
// ------------------------> ^^ <-- prompted with "age", "city", "name"

所以你可以选择重复，然后编译器会抱怨。

我对此无能为力。 IntelliSense 仅使用约束 Array<keyof T> 进行提示，它不会尝试评估 ExcludeArray<keyof T, K>，也不能轻松地这样做，因为您的中期开发字符串文字不太可能是正确的值之一，因此推理失败反正。这基本上超出了编译器的能力。

---

所以上面我提出了一个复杂的解决方案，它的行为主要是你想要的方式，但没有很好的 IntelliSense 支持。您可能需要考虑替代方案......也就是说，只需接受 Array<keyof T> 并可能重复。毕竟，来自pick() 的值和类型仍然是正确的。 ["name", "age", "age"] 的问题是最后一个 "age" 是不必要;它不是有害以任何方式。由于允许重复的后果是如此轻微，我会说在这种情况下治愈比疾病更糟糕。但这当然取决于你。

Playground link to code