使用--strictNullChecks时如何防止打字稿中的`Required<T>`从类型中删除'undefined'

Question

Typescript 允许您使用 -? 映射类型修饰符删除“可选项性”(?)，以便与 Required<T> 类型一起使用。

type Required<T> = { [P in keyof T]-?: T[P] };

但是在使用--strictNullChecks 时注意following 很重要（就像我一样）。

注意，在 --strictNullChecks 模式下，当同态映射类型 删除一个？来自基础类型中的属性的修饰符 从该属性的类型中删除 undefined：

我正在寻找绕过这种副作用的方法...

即我想删除? 但如果|undefined 存在我想保留它

为什么？

我有服务器生成的接口，这些接口具有可选的 (?) 属性。我想重构我的服务器代码并添加/删除成员。因此，我想要一种方法，无论是否需要，我都必须为每个属性显式设置一个值（或显式设置为 undefined）。

困境：

• 如果我使用Required<T>，那么它会吞噬我的| undefined，但前提是还存在?。

因此，以下内容颇具讽刺意味：

export type RequiredDog = Required <{

    bark: 'loud' | 'quiet' | undefined,
    bite?: 'nip' | 'clamp' | undefined
}>; 

居然变成了这样：

type RequiredDog = {
    bark: "loud" | "quiet" | undefined;
    bite: "nip" | "clamp";
}

所以bite 比bark 更可选，现在实际上更少可选！

有没有办法在不删除undefined 的情况下删除?？

Answer 1

如果我试图实现一个 Required<> 不会从属性中剥离 undefined，我可能会这样做：

type RequiredKeepUndefined<T> = { [K in keyof T]-?: [T[K]] } extends infer U
  ? U extends Record<keyof U, [any]> ? { [K in keyof U]: U[K][0] } : never
  : never;

我在这里用一堆mapped 和conditional 类型做的是将值类型包装在一个单元组中，使其成为Required，然后解开单元组。这在精神上与您的答案相似，但如果有人在属性中使用 "undefined" 作为字符串文字，它不会与发生的事情发生冲突。

你可以看到它的行为如你所愿：

interface Dog {
    bark: "loud" | "quiet" | undefined;
    bite?: "nip" | "clamp" | undefined;
}

type RequiredKeepUndefinedDog = RequiredKeepUndefined<Dog>
/* type RequiredKeepUndefinedDog = {
    bark: "loud" | "quiet" | undefined;
    bite: "nip" | "clamp" | undefined;
} */

你可以把它想象成下面的变换

• {bark: "loud" | "quiet" | undefined, bite?: "nip" | "clamp" | undefined}
• {bark: ["loud" | "quiet" | undefined], bite?: ["nip" | "clamp" | undefined] | undefined}
• {bark: ["loud" | "quiet" | undefined], bite: ["nip" | "clamp" | undefined]}
• {bark: "loud" | "quiet" | undefined, bite: "nip" | "clamp" | undefined}

好的，希望对您有所帮助；祝你好运！

Link to code

Answer 2

我仍然喜欢更清洁的解决方案，但以下方法似乎可行：

我基本上创建了一个名为 'undefined' 的类型，我用这两个替换/取消替换真正的 undefined 类型：

type WrapUndefined<T> = {
    [P in keyof T]: undefined extends T[P] ? 'undefined' | T[P] : T[P];
};

type UnwrapUndefined<T> = {
    [P in keyof T]: 'undefined' extends T[P] ? Diff<T[P], 'undefined'> | undefined : T[P];
};

如果我有：

type Person = {
   firstName?: string;
}

然后WrapUndefined<Person> 成功

firstName?: string | undefined | 'undefined';     // *

然后您可以致电Required<T> 获取此信息：

firstName: string | 'undefined';    // 'undefined' doesn't get removed now

然后用UnwrapUndefined<T>反转得到

firstName: string | undefined;

然后我创建一个单一的类型来完成这一切：

export type SmartRequired<T> = UnwrapUndefined<Required<WrapUndefined<T>>>;

如果我在我原来的 Dog 类型上运行这个问题，我会得到我想要的：

export type RequiredDog = SmartRequired <{

    bark: 'loud' | 'quiet' | undefined,
    bite?: 'nip' | 'clamp' | undefined
}>; 

这是什么

type RequiredDog = {
    bark: "loud" | "quiet" | undefined;
    bite: "nip" | "clamp" | undefined;
}

---

* 高级说明：此步骤在 VSCode 中显示为 string | undefined，因为它似乎将“未定义”吸收到 string 中。幸运的是，当您运行所有三个步骤时，它最终会得到正确的结果。