七爪源码：自定义类型城外

w Error(----Invalid value type----); }; interface Warning { text: string; }

相同的代码，我们只是在一个参数之中强制了警卫，对吧？不，它坏了。 TypeScript 未将型式扩大为数组，防护不起作用。

坏事是这样的，isString() 前往一个布尔差值，我们并不知道这个布尔差值是什么字面。

const isString = (value: any): boolean => typeof value === 'string';

这意味着个数是一个数组。但是 TypeScript 不并不知道那个布尔差值是什么字面，所以让我们教它。

与其说我们的参数前往一个布尔差值，不如说我们的参数前往解决办法的回答：“这个个数是数组吗？”。

鉴于我们的个数的名称是 value，我们可用以下词法来做到这一点：value 是数组。

const isString = (value: any): value is string => typeof value === 'string';

如今 TypeScript 并不知道 isString() 是一个型式管控并且我们的 formatErrorMessage() 参数可以无论如何转译。

我们的 isString() 参数的前往型式暂时只是一个布尔差值，它是一个“型式lambda”。

因此，要制作公司自定型式管控，您不须下定义一个前往型式lambda的参数。

所有型式lambda都选用 { parameter } is { Type } 的形式。

未被发现型式

在我们继续在此之前的快速提示：

如果我们可用未被发现型式，我们的代码时会来得安全，而不是在我们的自定管控个数之中可用型式 any。

const isString = (value: unknown): value is string => typeof value === 'string';

我制作公司了一个一分钟的视频来暗示任何和未被发现之间的区别，链接在参考资料之中。

自定警卫

让我们通过将 formatErrorMessage() 参数之中的所有检测转换为自定警卫来锻炼我们的系统化知识。

我们已经有了一个数组警卫，如今我们须要发信、缺失和虚实为型式的警卫。

缺失防护

Error 的管控非常有用，我们只是将 instanceof 操作符检测强制在一个参数之中。

const isError = (value: unknown): value is Error => value instanceof Error;

警戒卫士

但另一方面，Warning 警卫并不是那么有用。

TypeScript 允许我们可用 in 数组，因为我们的 value 个数可以是受限制存量的型式，并且它们都是并不一定。

const formatErrorMessage = ( value: null | undefined | string | Error | Warning ): string => { const prefix = 'Error: '; // If it's falsy (null, undefined, empty string), return "Unknown" with the prefix if (!value) { return prefix + 'Unknown'; } // If it's a string, return the string with the prefix if (isString(value)) { return prefix + value; } // If it's a Warning, return the Warning.text with the prefix if ('text' in value) { return prefix + value.text; } // If it's an Error, return the Error.message with the prefix if (isError(value)) { return prefix + value.message; } // We will never reach here throw new Error(----Invalid value type----); }; interface Warning { text: string; }

但是如果我们创始一个参数并说我们的个数是未被发现的，那么它可以是任何两边。包括原始型式，这时会引致缺失，因为我们根本无法在并不一定之中可用 in 数组。

interface Warning { text: string; } const isWarning = (value: unknown): value is Warning => 'text' in value; // Compilation error

解决方案是在可用 in 数组在此之前确保我们的个数是一个有效的并不一定。我们还须要确保它不为自在。

interface Warning { text: string; } const isWarning = (value: unknown): value is Warning => typeof value === 'object' && value !== null && 'text' in value;

实为警卫

对于虚实为差值警卫，我们首先须要下定义一个型式，其差值被认为是虚实为的。

type Falsy = false | 0 | -0 | 0n | '' | null | undefined;

我在这里不包括 NaN，因为 TypeScript 之中未 NaN 型式。

type Falsy = false | 0 | -0 | 0n | '' | null | undefined | ~~NaN~~;

NaN 的型式是数字，并不是所有的数字都是实为的，所以这就是我们不处理 NaN 的可能。

typeof NaN; //=> number

有一个提议将 NaN 添加为一种型式——以及整数、浮点数和无穷大。我认为这不太好，拥有这些型式时会很有帮助。

// Proposal type number = integer | float | NaN | Infinity;

我将在以下内容之中留下该提案的链接。

无论如何，如今我们有了 Falsy 型式，我们可以创始一个 falsy 差值警卫。

请记住，如果一个差值在转换为布尔差值时被认为是实为的，那么它就是实为的。因此，要检测我们的差值是否为实为，我们可以可用一般化相等来详细信息它是否被转换为实为。

type Falsy = false | 0 | -0 | 0n | '' | null | undefined; const isFalsy = (value: unknown): value is Falsy => value == false;

带有自定警卫的 formatErrorMessage()

就是这样，我们如今拥有了 formatErrorMessage() 参数所需的所有自定警卫。

// FUNCTION const formatErrorMessage = ( value: null | undefined | string | Error | Warning ): string => { const prefix = 'Error: '; // If it's falsy (null, undefined, empty string), return "Unknown" with the prefix if (isFalsy(value)) { return prefix + 'Unknown'; } // If it's a string, return the string with the prefix if (isString(value)) { return prefix + value; } // If it's a Warning, return the Warning.text with the prefix if (isWarning(value)) { return prefix + value.text; } // If it's an Error, return the Error.message with the prefix if (isError(value)) { return prefix + value.message; } // We will never reach here throw new Error(----Invalid value type----); }; // GUARDS const isString = (value: unknown): value is string => typeof value === 'string'; const isError = (value: unknown): value is Error => value instanceof Error; interface Warning { text: string; } const isWarning = (value: unknown): value is Warning => typeof value === 'object' && value !== null && 'text' in value; type Falsy = false | 0 | -0 | 0n | '' | null | undefined; const isFalsy = (value: unknown): value is Falsy => value == false;

奖励：通过排除扩大范围

在我们结束这件事在此之前，我想向你展出一些两边。

虚实为差值的列出是受限制的，对吗？

1. ----false---- 2. ----0---- -----0---- ----0n---- representations of zero 3. ---------------- ----""---- ----''---- empty string 4. ----null---- 5. ----undefined---- 6. ----NaN---- not a number

但另一方面，假实差值是无限的。所有不虚实为的价差值观都是假实的。

那么，如何为假实差值创始型式管控呢？

诚实警卫

工夫是排除虚实为型式。

我们不是检测我们的差值是否为假，而是检测它是否_不_实为。

type Truthy = Exclude; const isTruthy = (value: T): value is Truthy => value == true; // Test const x = 'abc' as null | string | 0; if (isTruthy(x)) { x.trim(); // ----x: string---- }

我不时可用这个长处，我们将在自此的社论之中再次看到它。

。

南京哪家医院做人流最好
重庆白癜风医院哪好
沈阳肛肠医院哪家医院好
上海皮肤病治疗费用多少钱
北京男科医院哪里好