TypeScript自定义类型守卫导致实例类型变为never的异常问题

当使用自定义类型守卫执行类型检查时，条件语句外部的变量会被TypeScript判定为never类型。示例代码如下：

class Fruite {
  num: number;
  constructor(num: number) {
    this.num = num;
  }
}
class Apple extends Fruite {
  constructor(num: number) {
    super(num);
  }
}
class Banana extends Fruite {
  constructor(num: number) {
    super(num);
  }
}

const items = [new Apple(1), new Banana(10)];

// 正常工作的版本：直接使用instanceof
const clone = (items: Fruite[]) => {
  return items.map(item => {
    if (item instanceof Apple) {
      return new Apple(item.num);
    } else if (item instanceof Banana) {
      return new Banana(item.num);
    }
    return new Banana(item.num); // item类型为Fruite
  });
}

// 出现问题的版本：使用自定义类型守卫
const isApple = (item: Fruite): item is Apple => {
  return item instanceof Apple;
}

const isBanana = (item: Fruite): item is Banana => {
  return item instanceof Banana;
}

const clone2 = (items: Fruite[]) => {
  return items.map(item => {
    if (isApple(item)) {
      return new Apple(item.num);
    } else if (isBanana(item)) {
      return new Banana(item.num);
    }
    return new Banana(item.num); // item被判定为never类型！
  });
}

核心原因：TypeScript对类类型与自定义类型守卫的收窄逻辑差异 #

1. 直接使用instanceof的情况
   TypeScript将类视为开放类型——默认允许存在未定义的子类。因此，即使排除了Apple和Banana，剩余变量的类型依然会被推断为Fruite（可能存在其他未声明的子类），不会被判定为never。

2. 使用自定义类型守卫的情况
   自定义类型守卫的item is Apple是精确的类型断言，TypeScript会严格基于这些断言做类型收窄：

• 当isApple(item)返回false时，变量类型被收窄为Exclude<Fruite, Apple>（即Fruite中排除Apple的部分）；
• 当isBanana(item)也返回false时，变量类型进一步收窄为Exclude<Fruite, Apple | Banana>；
• 由于代码中没有定义这两个类之外的Fruite子类，TypeScript无法找到该剩余类型的具体实现，因此将其判定为never（表示理论上不存在这样的类型）。

解决方法 #

如果Fruite的实例只能是Apple或Banana，可以将Fruite定义为联合类型，而非基类，让TypeScript明确知道所有可能的类型：

class Apple {
  num: number;
  constructor(num: number) {
    this.num = num;
  }
}
class Banana {
  num: number;
  constructor(num: number) {
    this.num = num;
  }
}

// 用联合类型限定Fruite的所有可能类型
type Fruite = Apple | Banana;

const items: Fruite[] = [new Apple(1), new Banana(10)];

const isApple = (item: Fruite): item is Apple => {
  return item instanceof Apple;
}

const isBanana = (item: Fruite): item is Banana => {
  return item instanceof Banana;
}

const clone2 = (items: Fruite[]) => {
  return items.map(item => {
    if (isApple(item)) {
      return new Apple(item.num);
    } else if (isBanana(item)) {
      return new Banana(item.num);
    }
    // 此时不会出现never类型，因为联合类型已穷尽所有可能
    throw new Error("未知的水果类型");
  });
}

若需要保留基类结构，也可以在最后一行添加类型断言，绕过never类型的限制：

return new Banana((item as Fruite).num);

内容的提问来源于stack exchange，提问作者Byeongin Yoon