TypeScript类型系统实现斐波那契数列推算详解

作者：纸飞机时间：2026-10-24 22:14:40浏览：597

本文基于TypeScript 4.5.4版本，深入探讨如何利用类型系统推算斐波那契数列。文章详细拆解了类型递归、元组长度计算、加法模拟及非负数判断等核心难点，通过具体的类型定义代码展示了从基础逻辑到完整实现的推导过程，为TypeScript高级类型编程提供了实用参考。

前言

本文的运行环境为TypeScript，具体版本号为4.5.4。

斐波那契数列基础

尽管斐波那契数列广为人知，这里仍简要回顾其定义。这是一个著名的数学序列，其推导规则如下：

Fib(0) = 0
Fib(1) = 1
Fib(n) = Fib(n-1) + Fib(n-2)

根据上述规则生成的数列依次为：

0 1 1 2 3 5 8 13 21 34 55 89 ...

实现逻辑分析

在介绍完斐波那契数列的基本概念后，接下来探讨TypeScript类型推算需要解决的核心问题。

第0项和第1项直接返回自身。
后续每一项等于前两项之和。
计算某一项需要循环或递归地获取前两项的值。
输入参数必须为数字，且不能为负数。

分析完需求后，我们进一步考察TypeScript能提供哪些支持，以及存在哪些局限。

第一个问题：第0和第1个数返回自身

这一点可以通过extends关键字轻松实现。

type GetSelf<T> = T extends 0 | 1 ? T : never;
// 测试
type Test0 = GetSelf<0>; // 0
type Test1 = GetSelf<1>; // 1
type Test2 = GetSelf<2>; // 2

第二个问题：某个数等于前两个数相加

这部分较为复杂，因为TypeScript类型系统中没有内置的加法运算，即TypeScript无法直接计算1 + 2的结果，因此需要列出待办事项。

第三个问题：推算一个数需要循环或者递归得到前两个值

TypeScript中确实支持递归，例如实现链表类型。

type Node<T> = {
    val: T;
    next: Node<T>;
}

然而，如何跳出循环是一个问题，且我们需要的是一个具体的值，而非返回一个对象，因此这也被列为待办事项。

第四个问题

输入必须为数字，且不能是负数。

限制数字类型很容易，通过extends number即可判断，但如何判断负数呢？

负数和正数有什么区别呢？

负数在字符串表示中多出一个符号，导致其字符串长度与正数不等，我们可以尝试利用这一点。

type len1 = '123'['length']; // number
type len2 = number[]['length']; // number;
type len3 = [1, 2, 3]['length']; // 3
type len4 = [number, string]['length']; // 3

字符串和未定义数组的长度无法直接推算，看起来只有元组可以获取长度。

负数比0小，但TypeScript中没有比较大小的操作，再次列出待办事项。

结论

我们可以解决第一个问题，同时得知可以通过length属性获取元组长度，待办事项如下：

加法运算
循环或者递归计算，并有跳出条件
判断非负数

解决待办事项

+1操作

虽然上一轮大部分功能没有推算出来，但是得到一个有用的结论，元组是可以得到length的值。

那 +1操作是不是可以理解成 PUSH操作后拿出 length 了？尝试

type Push<T extends Array<number>, P extends number> = [...T, P];

type arr1 = [1, 2];
type arr2 = Push<arr1, 3>; // [1, 2, 3]
type len1 = arr1['length'] // 2
type len2 = arr2['length']; // 3

确实实现了 +1操作，加法应该是可以解决了，+n 就是循环n次，结束条件就是结果为n

所以加法运算最后可以转成元祖后计算长度，类似 JavaScript的Array(n).fill(0)，第一步实现数字转array

数字转array

type ArrOf<T extends number, P extends Array<0> = []> = {
    ['loop']: ArrOf<T, [...P, 0]>;
    ['result']: P;
}[P['length'] extends T ? 'result' : 'loop'];

type arrof1 = ArrOf<5>; // [0, 0, 0, 0, 0]

因为我们需要递归后再跳出条件，最后返回值，所以可以构造一个对象后获取key，而key就是跳出循环的关键，跳出循环的判断就是元祖的长度等于输入的数

基于以上实现，我们可以得到add的完整实现了

type ADD<A extends number, B extends number> = [...ArrOf<A>, ...ArrOf<B>]['length'];

type add1 = ADD<3, 4>; // 7

虽然可以推算出结果，但是给我报了一个warning

A rest element type must be an array type.

我觉得可能他推算不出来返回的是array，所以需要我们声明ArrOf返回的数都是array，类似 Array.from

type ArrFrom<T> = T extends Array<T> ? T : T;

type ADD<A extends number, B extends number> = [...ArrFrom<ArrOf<A>>, ...ArrFrom<ArrOf<B>>]['length'];

加法和递归都被搞定了，接下来看看非负数的问题

非负数判断

再重新看看之前的分析，负数有什么特殊的地方，负数多个符号显示，且符号固定是第一位

type str11 = 'abcde';
type str12 = str11[0]; // string

看来并不能通过下标来取巧，那我们只能上 infer 了

type getFirst<T extends string> = T extends `${infer P}${string}` ? P : T;

type str11 = 'abcde';
type str12 = getFirst<str11>; // a

所以我们可以把数字转换字符串后求得符号，然后得出负数的判断

type FirstStr<T extends number> = `${T}` extends `${infer P}${string}` ? P : T;

type isFu<T extends number> = FirstStr<T> extends '-' ? true : false;

type isFu1 = isFu<0>; // false
type isFu2 = isFu<12>; // false
type isFu3 = isFu<-6>; // true
type isFu4 = isFu<-0>; // true

实现斐波那契

所有的部分都就绪了，实现一下斐波那契

type ArrOf<T extends number, P extends Array<0> = []> = {
    ['loop']: ArrOf<T, [...P, 0]>;
    ['result']: P;
}[P['length'] extends T ? 'result' : 'loop'];
// 第8行提示结果可能不是array
type ArrFrom<T> = T extends Array<T> ? T : T;

type ADD<A extends number, B extends number> = [...ArrFrom<ArrOf<A>>, ...ArrFrom<ArrOf<B>>]['length'];
// 第23行提示结果可能不是number
type NumberFrom<T> = T extends number ? T : T & number;

type ADD2<A extends number, B extends number> = NumberFrom<ADD<A, B>>;

type FirstStr<T extends number> = `${T}` extends `${infer P}${string}` ? P : T;
// 添加负数判断
type isFu<T extends number> = FirstStr<T> extends '-' ? true : false;

type FIB<T extends number, A extends number = 0, B extends number = 1, N extends number = 0> = isFu<T> extends true
    ? never
    : T extends 0 | 1
? T
: {
    ['loop']: FIB<T, B, ADD2<A, B>, ADD2<N, 1>>;
    ['result']: B;
}[T extends ADD2<N, 1> ? 'result' : 'loop'];

type FIFU1 = FIB<-6> // never
type FI0 = FIB<0> // 0
type FI1 = FIB<1>; // 1
type FI2 = FIB<2>; // 1
type FI3 = FIB<3>; // 2
type FI4 = FIB<4>; // 3
type FI5 = FIB<5>; // 5
type FI6 = FIB<6>; // 8
type FI7 = FIB<7>; // 13
type FI8 = FIB<8>; // 21
type FI9 = FIB<9>; // 34