深入理解 TypeScript 中的 never 类型：原理与应用

于 2025-03-28 09:08:18 发布
阅读量1.1k 收藏 12
点赞数 13
CC 4.0 BY-SA版权
分类专栏： TypeScript 文章标签： typescript javascript 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vvilkim/article/details/146543183

TypeScript 的类型系统是其最强大的特性之一，而 never 类型则是这个系统中一个独特且重要的组成部分。本文将全面解析 never 类型的本质，探讨其设计哲学，并通过大量实际应用场景展示如何利用 never 类型来构建更健壮、更安全的 TypeScript 代码。

1. never 类型的本质与设计哲学

1.1 什么是 never 类型？

在 TypeScript 的类型系统中，never 类型代表永远不会出现的值的类型。它是类型系统中最底层的类型，可以看作是"空类型"或"零类型"，类似于数学中的空集（∅）。

从集合论的角度来看：

  • unknown 是全集（包含所有可能的值的类型）

  • never 是空集（不包含任何值的类型）

1.2 为什么需要 never 类型？

never 类型的存在有几个重要原因：

  1. 完整性保证：确保类型系统的数学完整性，就像数字系统中的零一样必不可少

  2. 类型安全：帮助编译器识别不可达代码或逻辑错误

  3. 高级类型操作：在条件类型和类型推断中扮演关键角色

1.3 never 与其他特殊类型的比较

类型含义示例
any任意类型，绕过类型检查let x: any = 'anything'
unknown类型安全的任意类型，必须检查后才能使用let x: unknown = 'something'
void函数没有返回值（返回undefined）function log(): void { console.log() }
never永远不会出现的值function fail(): never { throw Error() }

2. never 类型的基本用法

2.1 函数永远不会正常返回

最常见的 never 类型应用场景是那些永远不会正常返回的函数：

// 抛出错误的函数
function throwError(message: string): never {
    throw new Error(message);
}

// 无限循环的函数
function infiniteLoop(): never {
    while (true) {
        // 永远不会退出
    }
}

2.2 类型收窄中的 never

在类型守卫（Type Guard）中，never 可以表示不可能的分支：

type PossibleValues = string | number | boolean;

function processValue(value: PossibleValues) {
    if (typeof value === "string") {
        // 这里 value 被收窄为 string
        return value.toUpperCase();
    } else if (typeof value === "number") {
        // 这里 value 被收窄为 number
        return value.toFixed(2);
    } else if (typeof value === "boolean") {
        // 这里 value 被收窄为 boolean
        return !value;
    } else {
        // 这里 value 是 never，因为所有可能性都已处理
        const exhaustiveCheck: never = value;
        return exhaustiveCheck;
    }
}

2.3 确保穷尽性检查

never 类型可以强制我们处理所有可能的类型变体，这在处理联合类型时特别有用：

type Shape = "circle" | "square" | "triangle";

function getArea(shape: Shape): number {
    switch (shape) {
        case "circle":
            return Math.PI * 2 ** 2;
        case "square":
            return 4 * 4;
        case "triangle":
            return (3 * 4) / 2;
        default:
            // 如果 Shape 新增类型但忘记处理，这里会报错
            const _exhaustiveCheck: never = shape;
            return _exhaustiveCheck;
    }
}

如果后来我们给 Shape 添加了 "rectangle" 但忘记在 switch 中处理，TypeScript 会在 default 分支报错，提醒我们处理新情况。

3. never 在高级类型中的应用

3.1 条件类型中的 never

never 在条件类型中非常有用，可以用来过滤类型：

// 从类型 T 中排除 null 和 undefined
type NonNullable<T> = T extends null | undefined ? never : T;

// 示例
type T1 = NonNullable<string | null | undefined>; // string

3.2 类型推断与 never

在 infer 推断中，never 可以用来表示不可能的情况：

type GetReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type T1 = GetReturnType<() => string>; // string
type T2 = GetReturnType<string>; // never

3.3 分布式条件类型中的 never

当条件类型作用于联合类型时，never 会被自动过滤掉：

type FilterStrings<T> = T extends string ? T : never;

type T1 = FilterStrings<string | number | boolean>; // string

4. 实际应用场景

4.1 实现安全的 Redux Action 处理

在使用 Redux 时，never 可以帮助我们确保处理了所有可能的 action 类型：

type Action = 
    | { type: "ADD_TODO"; text: string }
    | { type: "REMOVE_TODO"; id: number }
    | { type: "CLEAR_TODOS" };

function todosReducer(state: Todo[], action: Action): Todo[] {
    switch (action.type) {
        case "ADD_TODO":
            return [...state, { text: action.text, completed: false }];
        case "REMOVE_TODO":
            return state.filter(todo => todo.id !== action.id);
        case "CLEAR_TODOS":
            return [];
        default:
            const _exhaustiveCheck: never = action;
            return _exhaustiveCheck;
    }
}

4.2 构建更安全的 API 客户端

type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";

async function apiRequest(
    method: HttpMethod,
    url: string,
    data?: unknown
): Promise<unknown> {
    switch (method) {
        case "GET":
            return fetch(url).then(res => res.json());
        case "POST":
            return fetch(url, { method: "POST", body: JSON.stringify(data) })
                .then(res => res.json());
        case "PUT":
            return fetch(url, { method: "PUT", body: JSON.stringify(data) })
                .then(res => res.json());
        case "DELETE":
            return fetch(url, { method: "DELETE" })
                .then(res => res.json());
        default:
            const _exhaustiveCheck: never = method;
            throw new Error(`Unknown method: ${_exhaustiveCheck}`);
    }
}

4.3 实现类型安全的断言函数

function assert(condition: unknown, message?: string): asserts condition {
    if (!condition) {
        throw new Error(message || "Assertion failed");
    }
}

function assertIsString(value: unknown): asserts value is string {
    if (typeof value !== "string") {
        throw new Error("Value is not a string");
    }
}

// 使用示例
function process(input: unknown) {
    assertIsString(input);
    // 这里 input 被推断为 string
    console.log(input.toUpperCase());
}

5. never 的进阶技巧

5.1 与 keyof 结合使用

// 获取对象中值为特定类型的键
type KeysOfType<T, U> = {
    [K in keyof T]: T[K] extends U ? K : never
}[keyof T];

interface Person {
    name: string;
    age: number;
    address: string;
}

type StringKeys = KeysOfType<Person, string>; // "name" | "address"

5.2 构建互斥类型

type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;

type A = { a: string };
type B = { b: number };
type C = XOR<A, B>;

// 正确
const c1: C = { a: "hello" };
const c2: C = { b: 42 };

// 错误
const c3: C = { a: "hello", b: 42 }; // 不能同时有 a 和 b

5.3 实现类型安全的枚举检查

function checkEnum<T extends string>(
    value: string,
    validValues: readonly T[]
): value is T {
    return (validValues as readonly string[]).includes(value);
}

enum Direction {
    Up = "UP",
    Down = "DOWN",
    Left = "LEFT",
    Right = "RIGHT"
}

function move(direction: string) {
    if (!checkEnum(direction, Object.values(Direction))) {
        throw new Error(`Invalid direction: ${direction}`);
    }
    
    // 这里 direction 被推断为 Direction
    console.log(`Moving ${direction}`);
}

6. 常见误区与最佳实践

6.1 不要混淆 void 和 never

  • void 表示函数没有返回值（返回 undefined）

  • never 表示函数永远不会返回

// 返回 void
function logMessage(): void {
    console.log("Hello");
    // 隐式返回 undefined
}

// 返回 never
function crash(): never {
    throw new Error("Boom!");
    // 永远不会返回
}

6.2 谨慎使用 never 断言

有时开发者会使用 as never 来强制通过类型检查，但这通常意味着设计有问题：

// 不推荐的做法
const x = "hello" as never;

// 更好的做法是重新审视类型设计

6.3 利用 never 进行防御性编程

在编写工具类型时，考虑意外情况的处理：

type SafePropertyAccess<T, K> = K extends keyof T ? T[K] : never;

interface User {
    name: string;
    age: number;
}

type Name = SafePropertyAccess<User, "name">; // string
type Email = SafePropertyAccess<User, "email">; // never

总结

TypeScript 的 never 类型是一个强大的工具，它：

  1. 表示不可能存在的值或状态

  2. 帮助实现穷尽性检查，提高代码安全性

  3. 在高级类型操作中扮演关键角色

  4. 可以构建更严格的类型约束

  5. 促进防御性编程实践

掌握 never 类型的使用将使你能够：

  • 编写更健壮的类型定义

  • 构建更安全的应用程序

  • 利用 TypeScript 类型系统的全部能力

  • 在编译时捕获更多潜在错误

随着 TypeScript 项目的复杂度增加，合理使用 never 类型可以帮助维护代码的可维护性和可靠性，是每个 TypeScript 开发者都应该掌握的重要概念。

TypeScript 基础类型 —— Never
且听风吟的博客
06-01 2289
声明为 Never 类型表示永远不存在的值的类型。 Never 类型可以用来表示会抛出异常或根本不会有返回值的函数表达式或箭头函数表达式的返回值类型；被永不为真的类型保护所约束时的变量也可用 Never 来表示。
Typescript高级: 深入理解Extract类型
Wang的专栏
05-20 1084
在TypeScript这一逐渐成为前端开发首选的静态类型检查语言中，类型系统提供了丰富的工具来帮助开发者编写更加健壮和可维护的代码。其中，是一个强大的内置实用类型，用于从一个联合类型T中提取出属于另一个类型U的那些类型。本文将深入探讨Extract类型的工作原理、应用场景以及如何有效利用它来提升代码的类型安全性和表达力。Extract是一个条件类型，其定义为：从类型T中选取那些同时也可以被类型U赋值的类型简而言之，它像一个过滤器，保留了T中与U兼容的部分。
Typescript - never 类型（详细入门教程）
前端开发大师鸭
02-09 2199
TS 中 never 类型怎么用，TS类型: never，TS 中 never类型详解，TS全解:never类型怎么用，ts中的void和never类型，TypeScript中的never类型具体有什么用?TS 永远达不到的类型never，TS中never类型是什么，ts never类型详细讲解教程，TypeScript 的 never 类型，TypeScript--Never 类型，Typescript - never 类型（详细入门教程）。
TypeScript：never 类型的神奇妙用
weixin_52648900的博客
10-31 1817
在 TypeScript 中，never 是一个特殊类型，表示“永不存在的值类型”，通常用于表示不可能发生的情况。它适用于抛出异常、不返回值的函数或处理逻辑上永远不会出现的分支。
Typescript学习--Never
包磊磊的博客
02-28 814
never类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是never的子类型或可以赋值给never类型（除了never本身之外）。 即使 any也不可以赋值给never。通常表现为抛出异常或无法执行到终止点（例如无线循环）。比如： let x: never; let y: number; // 运行错误，数字类型不能转为 never 类型 x = 123; // 运行正确，ne...
TypeScript12 - never类型
m0_61877308的博客
07-30 442
TypeScript使用never类型来表示不应该存在的状态。
Typescript高级: 深入理解Exclude类型
Wang的专栏
06-02 530
Exclude 是一个强大的类型操作符，用于从一个类型集合中排除另一个类型集合中存在的类型这对于创建更加精确和动态的类型定义非常有用，尤其是在处理复杂的类型系统和进行类型筛选时Exclude 是一个高级类型，用于从类型 T 中排除那些可以赋值给类型 U 的所有成员换句话说，Exclude 类型返回一个新类型，该类型包含类型 T 中所有不属于类型 U 的成员never : T;Exclude 类型操作符是 TypeScript 强大类型系统的一个缩影。
深入理解TypeScript1
08-03
【深入理解TypeScript1】是关于TypeScript编程语言的深度解析，主要涵盖了多个核心概念和技术。TypeScript是一种静态类型的超集，它增强了JavaScript的功能，提高了代码的可读性和可维护性，尤其适合大型项目。 ...
Typescript高级: 深入理解ConstructorParameters类型及借助infer构建带参数的工厂实例方法
Wang的专栏
06-01 1166
在TypeScript中，利用泛型和类型推断，我们可以编写出既灵活又安全的代码特别是在处理类和其实例化过程中，这些特性显得尤为重要我们着重关注构造函数参数（constructor parameters）的类型处理以及如何利用泛型工厂函数来创建类的实例构造函数是面向对象编程中初始化对象状态的核心手段在TypeScript中，通过为构造函数及其参数添加类型注解可以确保在创建对象时遵循预定义的类型规则，从而提高程序的健壮性。
深入理解TypeScript项目：编译上下文、名空间、导入、类型系统以及错误提示
深入理解TypeScript项目-7 -声明空间模块命名空间动态导入表达式 TypeScript是一种由微软开发的开源编程语言，它是JavaScript的超集，可以编译成纯JavaScript。TypeScript通过静态类型检查提高了代码的可读性和可...
TypeScript的never类型的妙用
m0_74293254的博客
06-05 524
在 TypeScript 中，"never" 是一个表示永远不会发生的值类型。
TypeScript13(never类型)
xiaojian044的博客
12-02 163
never类型
TypeScript 中的 never 和 void 类型详解
最新发布
涂涂
12-25 954
TypeScript 中的void和never类型都用于描述函数的返回类型，但它们的语义和使用场景有很大的不同。void用于标识函数不返回任何值实际上返回 undefined可以显式返回 undefinednever函数抛出异常函数进入无限循环类型保护中的永远不可能达到的分支副作用（Side Effects）是指函数除了返回值之外，还对函数外部的状态进行了修改。修改全局变量修改传入的参数进行 API 调用操作 DOM写入文件打印日志。
TypeScript中的never类型具体有什么用？
包磊磊的博客
04-01 431
作者：尤雨溪 链接：https://www.zhihu.com/question/354601204/answer/888551021 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 举个具体点的例子，当你有一个 union type: interface Foo { type: 'foo' } interface Bar { type: 'bar' } type All = Foo | Bar 在 switch 当中判断 type，TS 是可以收.
TypeScript Never 与 Unknown
YunWisdom
04-10 1013
TypeScript Never 与 Unknown 本节介绍 never 和 unknown 类型，其中 unknown 类型作为 any 类型对应的安全类型使用起来更加安全，如果有 any 类型的使用需求，应尽量使用 unknown 类型来替代 any 类型。 1. 慕课解释 never类型表示那些永不存在的值的类型。 unknown类型是any类型对应的安全类型。 ...
TypeScript学习日志-第十三天（never类型）
weixin_45983676的博客
04-28 389
当我们定义好了一个方法，且定义好了对应的类型，这时候别人来更改的时候，就会提示错了，这时候就体现出这个的有用性了。这时候需要的是又是字符又是数字的，这时候就不能正常实现，这时候就会被定义为。类型 只是没有返回值 本身不会出错 但是。
typescript基础之never
hhbbeijing的专栏
08-29 492
TypeScript 的 never 类型是一种特殊的类型，它表示的是那些永远不存在的值的类型。例如，一个抛出异常或无限循环的函数的返回值类型就是 never，因为它们永远不会返回任何值。never 类型是所有类型的子类型，也就是说，任何类型都可以赋值给 never 类型，但是 never 类型只能赋值给自己和 any 类型。• never 类型可以用来表示不可能发生的情况，例如在 switch 语句中的 default 分支，或者在类型保护中排除掉所有可能的情况。
never 类型
monkey's的博客
10-24 865
never 是其它类型（包括 null 和 undefined）的子类型，代表从不会出现的值。
【TS】never类型的妙用
呆呆狗
01-03 1415
TS-never类型的妙用~
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值