我正在用TypeScript编写一个类型化的List实现，作为一个普通对象，其结构使用type表达式来保证。我选择将其编写为普通对象而不是类，因为我相信普通对象更容易让我确保其不变性。此对象的类型定义如下所示：
type List<T> = Readonly<{
head: T;
tail: List<T> | void;
}>;
我想为此结构编写一个类型保护，以便我可以确保在其他代码中对List对象进行操作。我当前的类型保护如下所示：
export function isList(list: any): list is List {
if (isNil(list)) {
return false;
}
return ("head" in list && "tail" in list);
}
此实现在第一行有一个错误，list is List：TypeScript 抱怨类型List<T>是泛型的，因此，我必须在对它的引用中提供一个类型。
此函数的预期输出将如下所示：
import {getListSomehow, isList} from "list";
const list = getListSomehow("hello", "world", "etc...");
const arr = ["hello", "world", "etc..."];
console.log(isList(list)); // true
console.log(isList(arr)); // false
console.log(isList("a value")); // false
有没有办法在不必知道T类型的情况下编写这种类型保护？如果没有，有没有办法以某种方式检索此类型，同时仍然允许函数获取任何值？
这个问题暴露了TypeScript的一些缺点。 简短的回答是：你可能做不到你想做的事情，至少不能以你想做的方式。 (我们在问题的评论中对此进行了一些讨论。
为了类型安全，TypeScript 通常依赖于编译时类型检查。 与JavaScript不同，TypeScript标识符具有类型;有时这是显式给出的，有时是由编译器推断的。 通常，如果尝试将标识符视为与其已知类型不同的类型，编译器将抱怨。
这给与现有 JavaScript 库的接口带来了问题。 JavaScript 中的标识符没有类型。 此外，无法在运行时可靠地检查值的类型。
这导致了类型防护装置的出现。 可以在 TypeScript 中编写一个函数，其目的是告诉编译器，如果函数返回 true，则传递给它的参数之一已知是特定类型。 这允许你实现自己的鸭子类型，作为JavaScript和TypeScript之间的一种联络。 类型防护函数看起来有点像这样：
const isDuck = (x: any): x is Duck => looksLikeADuck(x) && quacksLikeADuck(x);
这不是一个很好的解决方案，但只要您小心检查类型，并且实际上没有任何替代方案，它就可以工作。
但是，类型保护不适用于泛型类型。 请记住，类型保护的目的是获取any输入并确定它是否为特定类型。 我们可以使用泛型类型实现部分目标：
function isList(list: any): list is List<any> {
if (isNil(list)) {
return false;
}
return "head" in list && "tail" in list;
}
不过，这仍然不理想。 我们现在可以测试某物是否是List<any>，但我们不能测试更具体的东西，比如List<number>——没有它，结果可能不会对我们特别有用，因为我们所有封装的值仍然是未知的类型。
我们真正想要的是可以检查某物是否是List<T>的东西。 这有点棘手：
function isList<T>(list: any): list is List<T> {
if (isNil(list)) {
return false;
}
if (!("head" in list && "tail" in list)) {
return false;
}
return isT<T>(list.head) && (isNil(list.tail) || isList<T>(list.tail));
}
现在我们必须定义isT<T>：
function isT<T>(x: any): x is T {
// What goes here?
}
但我们不能那样做。 我们无法在运行时检查值是否为任意类型。 我们可以解决这个问题：
function isList<T>(list: any, isT: (any) => x is T): list is List<T> {
if (isNil(list)) {
return false;
}
if (!("head" in list && "tail" in list)) {
return false;
}
return isT(list.head) && (isNil(list.tail) || isList<T>(list.tail, isT));
}
现在是呼叫者的问题：
function isListOfNumbers(list: any): list is List<number> {
return isList<number>(list, (x): x is number => typeof x === "number");
}
这些都不是理想的。 如果你能避免它，你应该;而是依靠 TypeScript 的严格类型检查。 我已经提供了一些例子，但首先，我们需要调整List<T>的定义：
type List<T> = Readonly<null | {
head: T;
tail: List<T>;
}>;
现在，有了这个定义，而不是：
function sum(list: any) {
if (!isList<number>(list, (x): x is number => typeof x === "number")) {
throw "Panic!";
}
// list is now a List<number>--unless we wrote our isList or isT implementations incorrectly.
let result = 0;
for (let x = list; x !== null; x = x.tail) {
result += list.head;
}
return result;
}
用：
function sum(list: List<number>) {
// list is a List<number>--unless someone called this function directly from JavaScript.
let result = 0;
for (let x = list; x !== null; x = x.tail) {
result += list.head;
}
return result;
}
当然，如果你正在编写一个库或处理普通的JavaScript，你可能没有到处进行严格的类型检查，但你应该尽最大努力在可能的情况下依赖它。