七爪源码：基本型把守

ng { text: string; }

现今我们的预下定义顶多了。

const formatErrorMessage = (value: string | Error | Warning): string => { const prefix = 'Error: '; // If it's a string, return the string with the prefix if (typeof value === 'string') { return prefix + value; // <- value: string } // If it's an Error, return the Error.message with the prefix return prefix + value.message; // <- value: Error | Warning }; interface Warning { text: string; }

之前，我们的 value 函数勉强是 if 表达式之前的 Error 程序中。

const formatErrorMessage = (value: string | Error): string => { const prefix = 'Error: '; // If it's a string, return the string with the prefix if (typeof value === 'string') { return prefix + value; // <- value: string } // If it's an Error, return the Error.message with the prefix return prefix + value.message; // <- value: Error }; interface Warning { text: string; }

但现今，它确实是偏差 | 通告和 .message 要素在通告之前不发挥作用。

const formatErrorMessage = (value: string | Error | Warning): string => { const prefix = 'Error: '; // If it's a string, return the string with the prefix if (typeof value === 'string') { return prefix + value; // <- value: string } // If it's an Error, return the Error.message with the prefix return prefix + value.message; // <- value: Error | Warning }; interface Warning { text: string; }

typeof codice_在这里对我们无法帮助，因为 typeof 个数对于这两种情况都是“都可”。

const formatErrorMessage = (value: string | Error | Warning): string => { const prefix = 'Error: '; // If it's a string, return the string with the prefix if (typeof value === 'string') { return prefix + value // <- value: string } // If it's a Warning, return the Warning.text with the prefix if (???) { return prefix + value.text } // If it's an Error, return the Error.message with the prefix return prefix + value.message // <- value: Error | Warning } interface Warning { text: string }

在 JavaScript 之前处理这种情况的单指方法之一是检测 value 是不是不具备 .text 要素。 如果是这样，那就是通告。 我们可以运用于 in 操作员戒备森严来算是到这一点。

const formatErrorMessage = (value: string | Error | Warning): string => { const prefix = 'Error: '; // If it's a string, return the string with the prefix if (typeof value === 'string') { return prefix + value; // <- value: string } // If it's a Warning, return the Warning.text with the prefix if ('text' in value) { return prefix + value.text; // <- value: Warning } // If it's an Error, return the Error.message with the prefix return prefix + value.message; // <- value: Error }; interface Warning { text: string; }

如果可下定义都可不具备可下定义要素，则此codice_回到 true。 在这种才会，如果 value 不具备 .text 要素。

TypeScript 并不知道我们的 if 表达式只有在 value 是一个通告时才为真，因为这是唯一确实的 value 不具备名为 .text 的要素的子类，因此它将子类扩大到 if 块内的通告。

在第一个 if 表达式之前，个数可以是 Warning | 偏差。 在第二个 if 表达式之前，勉强是 Error。

公正拉长

支持可选实例也很罕见，这意味着意味着 value 为 null 或 undefined。

const formatErrorMessage = (value: null | undefined | string | Error | Warning): string => { const prefix = 'Error: '; // If it's null or undefined, return "Unknown" with the prefix if (???) { return prefix + 'Unknown' } // If it's a string, return the string with the prefix if (typeof value === 'string') { return prefix + value // <- value: string } // If it's a Warning, return the Warning.text with the prefix if ('text' in value) { return prefix + value.text // <- value: Warning } // If it's an Error, return the Error.message with the prefix return prefix + value.message // <- value: Error } interface Warning { text: string }

我们可以运用于 typeof codice_来处理未下定义的情况，但它不适主要用途 null。

跑去说一句，如果您一切都是并不知道为什么它不适主要用途 null 以及 null 和 undefined 之间的区别。 我有一篇非常开头且内容丰富的篇名辩解进行了说明了。 我会在参考文献之前留下来一个客户端。

对于 null 和 undefined，我们可以算是的是运用于相等codice_，例如 ===：

const formatErrorMessage = ( value: null | undefined | string | Error | Warning ): string => { const prefix = 'Error: '; // If it's null or undefined, return "Unknown" with the prefix if (value === null || value === undefined) { return prefix + 'Unknown'; } // If it's a string, return the string with the prefix if (typeof value === 'string') { 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 return prefix + value.message; }; interface Warning { text: string; }

我们的 if 表达式只有在 value 大于 null 或 undefined 时才为真，因此 TypeScript 将我们的子类扩大为 null | 不指明的。

这称做等式扩大，它也适主要用途其他相当codice_，例如：

不大于！== 强而有力大于 == 强而有力不大于！=

想像性扩大

但坏事就是这样。 等式扩大不是 JavaScript 检测 null 的单指方式 | 不指明的。 这样算是的单指方法是检测该个数是不是为真。

我有一篇开头的篇名说明了了 JavaScript 之前什么是真假。 我会把客户端置放参考文献之前。 如果你能快速观赏那将是最好的，这样我们就可以在我们的脑海之前对想像和虚假的下定义保持新鲜感。 去吧，我在等。

既然我们都对想像和虚假的下定义记忆犹新，让我向您介绍想像性扩大。

与其运用于等式扩大来检测 value 是不是大于 null 或 undefined，我们可以只看它是不是是 falsy。

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 (typeof value === 'string') { 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 return prefix + value.message; }; interface Warning { text: string; }

我们可以通过在它上去加上一个逻辑 NOT ! 来算是到这一点。 这会将个数反转为布尔个数并将其反转。 如果它是假的，它将被反转为假，然后反转为真。

示例归纳

到目前为止，我们以前在避免运用于戒备森严来检测 value 是不是是 Error 类的程序中。 我告诉过你我们是如何算是到这一点的。 我们正在处理所有确实的子类，以便最后只剩 Error 子类。

这种技术在 JavaScript 之前很罕见，也是一种扩大范围。 我们以前在算是的正确术语是“示例归纳”。

示例归纳是根据预下定义的可达性对我们的预下定义进行归纳。

TypeScript 并不知道除非个数是真的，否则我们难以开到第一个 if 表达式。

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 (typeof value === 'string') { // 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 return prefix + value.message; }; interface Warning { text: string; }

除非 value 是数组，否则我们难以开到第二个 if 表达式。

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 (typeof value === 'string') { 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 return prefix + value.message; }; interface Warning { text: string; }

如果不是通告，我们就难以达到第三个。 所以最后只剩一种子类，它勉强是一个偏差。

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 (typeof value === 'string') { 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 return prefix + value.message; }; interface Warning { text: string; }

这些子类正在扩大，因为 TypeScript 正在运用于示例归纳。

Operator Guard 程序中

但是我们不勉强依靠示例归纳来将我们的子类扩大到偏差。 我们可以运用于一个非常简单且单指的 JavaScript codice_来算是到这一点。 instanceof codice_。

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 (typeof value === 'string') { 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 (value instanceof Error) { return prefix + value.message; } // We will never reach here throw new Error(MLT-Invalid value typeMLT-); }; interface Warning { text: string; }

在这里，我们检测 value 是不是是 Error 类的程序中，因此 TypeScript 将我们的子类扩大为 Error。 在最后一个 if 表达式之前无法任何子类，我们而会一定会开到它之前的任何预下定义。

从来不读写（15 秒）

如果你一切都是并不知道 TypeScript 在我们所有的 if 表达式之前视为什么是个数的子类，无误而会一定会。

never 是一种特殊子类，表示不确实的坏事，不不应时有发生的坏事。

结论

那些是大体子类的戒备森严，它们非常有效率，但它们勉强带你到此为止。 在下一篇篇名之前，我将向您展现如何创建自下定义子类确保。 不一切都是错失就订阅吧。

。

广州白癜风最好医院是哪个
贵阳妇科专科医院哪家好
漳州白癜风正规的医院
济南妇科医院专家预约挂号
天津前列腺炎治疗医院