TypeScript 是什么？基础入门教程 – wiki基地

TypeScript 是什么？从入门到精通（基础篇）

1. 什么是 TypeScript？

想象一下，你正在建造一座摩天大楼，JavaScript 就像是提供了砖块、水泥等基础材料，你可以用它们搭建出任何你想要的东西，灵活且强大。然而，随着大楼越来越高、结构越来越复杂，你开始发现一些问题：砖块和水泥的型号是否匹配？承重墙的位置是否正确？管线是否会交叉冲突？在施工过程中，你可能要到后期才能发现这些结构性问题，一旦发现，返工的成本会非常高昂。

TypeScript 的出现，就像是为 JavaScript 这套“建筑材料”引入了详细的“建筑图纸”和严格的“施工规范”。

TypeScript 是 JavaScript 的一个超集（Superset）。 这意味着任何合法的 JavaScript 代码本身就是合法的 TypeScript 代码。TypeScript 在 JavaScript 的基础上增加了静态类型（Static Typing）以及其他一些面向对象的特性（如接口、抽象类等），并最终编译（Compile）成标准的 JavaScript 代码来运行。

它由微软开发和维护，并于2012年首次发布。其核心目标是提高大型 JavaScript 应用的可维护性和开发效率。

简单来说：

超集： 兼容所有 JS 代码。
静态类型： 在代码运行前（编译阶段）检查类型错误。
编译： 将 TypeScript 代码转换回 JavaScript 代码。

2. 为什么需要 TypeScript？

JavaScript 是一门动态类型语言。这意味着你在编写代码时，变量的类型可以在运行时改变。这带来了极大的灵活性，但也带来了潜在的风险：

“`javascript
let data = 10; // data 是一个数字
data = “hello”; // data 变成了一个字符串
data = [1, 2, 3]; // data 变成了一个数组

// 假设我们期望 data 始终是数字，但误将其赋值为字符串，后续对 data 进行数学运算就会出错
let result = data * 2; // 运行时错误，”hello” * 2 结果是 NaN
“`

在小型项目或简单脚本中，这种灵活性通常不是问题。但在大型、复杂的项目，尤其是多人协作的项目中，动态类型的缺点会变得非常突出：

难以发现错误： 很多类型错误只能在代码实际运行时才能暴露出来，这意味着你可能需要编写大量的测试用例来捕捉这些潜在的错误，或者直到用户在使用时才发现问题。
代码可读性差： 不明确的类型使得理解代码变得困难。你不知道一个函数期望接收什么类型的参数，也不知道它会返回什么类型的返回值，除非你仔细阅读函数的实现或者文档（如果存在的话）。
重构困难： 当你需要修改一个函数或接口时，很难确定改动会影响到代码库中的哪些部分，因为没有明确的类型契约来指示依赖关系。
缺乏优秀的工具支持： IDE 和编辑器难以提供智能的代码补全、参数提示、错误检查等高级功能，因为它们无法确定变量的具体类型。

TypeScript 通过引入静态类型解决了这些问题：

更早地发现错误： 在你编写代码时或者在代码编译阶段，TypeScript 编译器就会检查类型是否匹配。大多数类型错误在代码运行前就被发现并报告，大大减少了运行时错误的发生。
增强代码可读性： 显式的类型声明就像是代码的文档，让开发者一眼就能知道变量的用途、函数的功能、对象的结构等信息。
提升重构效率： 类型系统可以帮助你在重构时追踪类型变化的影响范围，编译器会立刻指出哪些地方的代码因为类型不匹配而需要修改。
提供强大的工具支持： 基于类型信息，IDE 和编辑器（如 VS Code）可以提供智能的代码补全（IntelliSense）、精确的错误提示、便捷的代码导航和自动重构功能，极大地提升开发效率和体验。
更好的团队协作： 类型契约使得团队成员之间更容易理解和使用彼此的代码模块，减少沟通成本和因误解接口导致的错误。
更适合大型项目： 随着项目规模的增长，类型系统的好处会指数级增长，它为项目的可维护性和可扩展性提供了坚实的基础。

总而言之，虽然引入类型系统增加了前期的学习和编写成本，但在项目的整个生命周期中，尤其对于中大型项目而言，TypeScript 带来的收益是巨大的。

3. TypeScript 基础入门

本节将介绍 TypeScript 中最核心、最基础的概念——类型。

3.1 安装 TypeScript

首先，你需要安装 Node.js 和 npm（或者 yarn/pnpm），因为 TypeScript 编译器是基于 Node.js 环境运行的。

安装 Node.js 后，你可以通过 npm 全局安装 TypeScript：

bash npm install -g typescript

安装完成后，你可以使用 tsc 命令来调用 TypeScript 编译器。

3.2 编写第一个 TypeScript 文件

创建一个新文件，命名为 hello.ts（TypeScript 文件的后缀是 .ts）。

“`typescript
// hello.ts

function greet(person: string): string {
return “Hello, ” + person;
}

let user = “TypeScript User”;

console.log(greet(user));

// 尝试传入一个数字，TypeScript 会报错
// let age = 10;
// console.log(greet(age)); // 错误：Argument of type ‘number’ is not assignable to parameter of type ‘string’.
“`

在这个简单的例子中：

我们定义了一个函数 greet。
person: string：这叫做类型注解（Type Annotation）。它明确告诉 TypeScript 编译器，person 参数必须是一个字符串类型。
: string（在参数列表后）：这表示函数的返回值类型必须是一个字符串。
let user: string = "TypeScript User";：虽然这里 TypeScript 可以根据赋值推断出 user 的类型是 string，但显式地加上 : string 是一种良好的习惯，特别是在变量声明但未立即赋值时。

当你尝试将一个数字（age）传递给期望字符串的 greet 函数时，TypeScript 编译器会在你运行代码之前就报告一个类型错误。

3.3 编译 TypeScript 代码

TypeScript 代码不能直接在浏览器或 Node.js 环境中运行，它需要先被编译成标准的 JavaScript 代码。使用 tsc 命令来编译 hello.ts：

bash tsc hello.ts

执行这个命令后，TypeScript 编译器会生成一个同名的 JavaScript 文件 hello.js：

“`javascript
// hello.js (由 tsc hello.ts 自动生成)

function greet(person) {
return “Hello, ” + person;
}

let user = “TypeScript User”;

console.log(greet(user));
“`

注意，生成的 JavaScript 代码是符合 ECMAScript 标准的，不包含任何 TypeScript 特有的语法。

3.4 运行编译后的 JavaScript 代码

现在你可以像运行普通 JavaScript 文件一样运行 hello.js：

bash node hello.js

输出将是：

Hello, TypeScript User

这个简单的流程展示了 TypeScript 的核心工作方式：编写 .ts 文件 -> 使用 tsc 编译 -> 运行生成的 .js 文件。

3.5 `tsconfig.json` 文件

对于更复杂的项目，手动编译每个 .ts 文件会非常繁琐。tsconfig.json 文件是 TypeScript 项目的配置文件，它告诉编译器如何编译整个项目。

在项目根目录运行以下命令可以生成一个基础的 tsconfig.json 文件：

bash tsc --init

这会生成一个包含许多选项的 tsconfig.json 文件，大部分被注释掉了。一些重要的选项包括：

"target": 指定编译后的 JavaScript 代码的目标版本（如 “es5”, “es2015”, “esnext”）。
"module": 指定生成代码的模块系统（如 “commonjs”, “es2015″）。
"strict": 启用一系列严格的类型检查选项（强烈建议开启）。
"outDir": 指定编译后的 JavaScript 文件输出目录。
"rootDir": 指定 TypeScript 源文件所在的目录。
"include" 和 "exclude": 指定需要包含或排除的文件夹和文件。

有了 tsconfig.json 文件后，你只需在项目根目录运行 tsc 命令（不带文件名），编译器就会根据配置文件编译整个项目中的 .ts 文件。

3.6 基本类型 (Basic Types)

TypeScript 支持与 JavaScript 相同的基本数据类型，并为其提供了类型注解：

boolean: 布尔值，true 或 false。
typescript let isDone: boolean = false;
number: 数字类型，包括整数和浮点数。
typescript let decimal: number = 6; let hex: number = 0xf00d; let binary: number = 0b1010; let octal: number = 0o744;
string: 字符串类型。
typescript let color: string = "blue"; let fullName: string = `Bob Smith`; // 支持模板字符串 let age: number = 37; let sentence: string = `Hello, my name is ${ fullName }. I'll be ${ age + 1 } years old next month.`;
Array: 数组类型。有两种方式表示：
“`typescript
let list: number[]; // 元素类型 + 方括号
list = [1, 2, 3];

let list2: Array; // 泛型数组类型
list2 = [4, 5, 6];
* **`Tuple`**: 元组类型。表示一个已知元素数量和类型的数组，各元素的类型可以不同。typescript
// Declare a tuple type
let x: [string, number];
// Initialize it
x = [“hello”, 10]; // OK

// Initialize it incorrectly
// x = [10, “hello”]; // Error: Type ‘number’ is not assignable to type ‘string’ at index 0.
* **`Enum`**: 枚举类型。为一组数值赋予更友好的名字。typescript
enum Color {Red, Green, Blue}
let c: Color = Color.Green; // 默认从 0 开始编号

enum Color2 {Red = 1, Green, Blue} // 可以手动设置起始编号
let c2: Color2 = Color2.Green; // c2 的值是 2

enum Color3 {Red = 1, Green = 2, Blue = 4} // 可以手动设置所有值
let c3: Color3 = Color3.Green; // c3 的值是 2

// 可以通过值查找名字
let colorName: string = Color[2]; // colorName 是 “Blue”
* **`Any`**: 任意类型。表示不确定变量类型时使用。**使用 `any` 会禁用类型检查**，应谨慎使用，通常作为类型系统的一种逃逸舱。typescript
let notSure: any = 4;
notSure = “maybe a string instead”;
notSure = false; // okay, definitely a boolean
* **`Void`**: 表示函数没有返回值。通常用于函数返回值类型。typescript
function warnUser(): void {
console.log(“This is my warning message”);
}

let unusable: void = undefined; // 只能赋值 undefined 或 null (如果 strictNullChecks 为 false)
* **`Null` 和 `Undefined`**: 分别表示 `null` 和 `undefined` 值。默认情况下，`null` 和 `undefined` 可以作为任何类型的子类型赋值给其他类型。但如果启用 `--strictNullChecks` 选项，它们只能赋值给 `void`, `any`, `null`, `undefined` 类型自身。typescript
let u: undefined = undefined;
let n: null = null;

// 启用 strictNullChecks 后
// let s: string = null; // Error: Type ‘null’ is not assignable to type ‘string’.
* **`Never`**: 表示永远不会返回的函数的返回值类型，或者总是抛出异常的函数的返回值类型。它是任何类型的子类型，但没有类型是 `never` 的子类型（`never` 本身除外）。typescript
function error(message: string): never {
throw new Error(message);
}

// 推断的返回类型是 never
function fail() {
return error(“Something failed”);
}

// 循环，永远不会结束
function infiniteLoop(): never {
while (true) {
}
}
* **`Object`**: 表示非原始类型，即除了 `number`, `string`, `boolean`, `symbol`, `null`, `undefined` 之外的类型。typescript
declare function create(o: object | null): void;

create({ prop: 0 }); // OK
create(null); // OK

// create(42); // Error
// create(“string”); // Error
// create(false); // Error
// create(undefined); // Error
* **`Unknown`**: 表示未知类型。与 `any` 类似，但更安全。`unknown` 类型变量在被断言或缩小类型之前，不能执行大多数操作。typescript
let value: unknown;

value = “hello”;
value = 123;

// 错误：value 现在是 unknown，不知道它有没有 toUpperCase 方法
// let upper: string = value.toUpperCase();

// 正确：先进行类型检查或断言
if (typeof value === ‘string’) {
let upper: string = value.toUpperCase(); // OK
}

let value2: any = value; // 可以赋值给 any
// let value3: string = value; // Error: Type ‘unknown’ is not assignable to type ‘string’.
“`

3.7 接口 (Interfaces)

接口是 TypeScript 中非常核心的概念，主要用于定义对象的结构（Shape）。它规定了一个对象应该有哪些属性、这些属性的类型是什么，以及可以有哪些方法。

“`typescript
interface Person {
firstName: string;
lastName: string;
age?: number; // age 属性是可选的 (使用 ?)
readonly id: number; // id 属性是只读的 (使用 readonly)
[propName: string]: any; // 允许其他任意数量的属性 (字符串索引签名)
}

function greetPerson(person: Person) {
console.log(Hello, ${person.firstName} ${person.lastName}!);
if (person.age !== undefined) {
console.log(You are ${person.age} years old.);
}
}

let user1: Person = { firstName: “Jane”, lastName: “User”, id: 123 };
let user2: Person = { firstName: “John”, lastName: “Doe”, age: 30, id: 456, occupation: “Engineer” }; // occupation 是通过索引签名允许的额外属性

greetPerson(user1); // OK
greetPerson(user2); // OK

// 尝试修改只读属性会报错
// user1.id = 789; // Error: Cannot assign to ‘id’ because it is a read-only property.

// 尝试传入不符合接口结构的对象会报错
// greetPerson({ firstName: “Alice” }); // Error: Property ‘lastName’ is missing in type ‘{ firstName: string; }’ but required in type ‘Person’.
“`

接口的用途：

约束对象的形状： 确保对象拥有期望的属性和方法，以及正确的类型。
提高代码可读性： 明确了函数或变量期望的数据结构。
更好的代码补全和检查： IDE 可以根据接口定义提供准确的提示和错误检查。

除了用于约束对象字面量，接口还可以用于约束类（Class）实现特定的结构。

3.8 类型别名 (Type Aliases)

类型别名允许你给一个类型起一个新的名字。这对于复杂类型（如联合类型、交叉类型、函数类型）非常有用，可以提高代码的可读性和复用性。

“`typescript
// 为一个联合类型创建别名
type StringOrNumber = string | number;

let value: StringOrNumber;
value = “hello”; // OK
value = 123; // OK
// value = true; // Error: Type ‘boolean’ is not assignable to type ‘StringOrNumber’.

// 为对象类型创建别名 (类似接口，但有一些区别)
type Point = {
x: number;
y: number;
};

function printPoint(p: Point) {
console.log(Point coordinates: (${p.x}, ${p.y}));
}

printPoint({ x: 10, y: 20 }); // OK

// 类型别名也可以引用自身，用于表示链式结构
type Node = {
value: number;
next: Node | null;
};

let head: Node = {
value: 1,
next: {
value: 2,
next: null
}
};
“`

接口 vs. 类型别名：

大多数情况下，你可以根据偏好选择使用接口或类型别名来定义对象类型。
接口可以被实现（implements）和扩展（extends），而类型别名是使用交叉类型（&）来实现类似的效果。
接口会创建可以在错误消息中引用的具名类型，类型别名只是给现有类型起了个新名字。
如果你需要定义联合类型、交叉类型或原始类型（如 type Name = string;），只能使用类型别名。
如果你需要定义元组类型，可以使用类型别名。
如果你需要定义类或函数类型，两者都可以，但接口在描述对象形状或类契约时更惯用。
总的来说，对于定义对象的结构，推荐使用接口；对于定义其他类型的组合或别名，使用类型别名。

3.9 联合类型 (Union Types)

联合类型允许一个变量持有多种类型之一的值。使用 | 符号连接不同的类型。

“`typescript
function printId(id: number | string) {
console.log(“Your ID is: ” + id);

// 在使用联合类型变量时，需要根据具体的类型执行不同的操作
if (typeof id === "string") {
    console.log("ID length:", id.length); // OK，因为在 if 块中 TypeScript 知道 id 是 string
} else {
    console.log("ID squared:", id * id); // OK，因为在 else 块中 TypeScript 知道 id 是 number
}

}

printId(101); // OK
printId(“202”); // OK
// printId(true); // Error: Argument of type ‘boolean’ is not assignable to parameter of type ‘string | number’.
“`

联合类型是 TypeScript 灵活性和类型安全结合的一个重要体现。

3.10 交叉类型 (Intersection Types)

交叉类型将多个类型合并为一个新类型。新类型拥有所有被合并类型的所有成员。使用 & 符号连接不同的类型。

“`typescript
interface LivingBeing {
breathe(): void;
}

interface Mammal {
walk(): void;
}

type Human = LivingBeing & Mammal; // Human 类型同时拥有 breathe() 和 walk() 方法

let person: Human = {
breathe() { console.log(“Breathing…”); },
walk() { console.log(“Walking…”); }
};

person.breathe(); // OK
person.walk(); // OK
“`

交叉类型常用于合并现有的接口或类型别名，创建更复杂的类型。

3.11 函数 (Functions)

在 TypeScript 中，你可以给函数参数和返回值添加类型注解。

“`typescript
// 给参数和返回值添加类型注解
function add(x: number, y: number): number {
return x + y;
}

let mySum: number = add(5, 3); // OK
// let mySumError: number = add(5, “3”); // Error: Argument of type ‘string’ is not assignable to parameter of type ‘number’.

// 匿名函数
let subtract = function(x: number, y: number): number {
return x – y;
};

// 箭头函数
let multiply = (x: number, y: number): number => {
return x * y;
};

// 函数类型表达式
let divide: (x: number, y: number) => number = (x, y) => {
return x / y;
};

// 可选参数 (使用 ?)
function buildName(firstName: string, lastName?: string): string {
if (lastName) {
return firstName + ” ” + lastName;
} else {
return firstName;
}
}

let result1 = buildName(“Bob”); // OK
let result2 = buildName(“Bob”, “Adams”); // OK
// let result3 = buildName(“Bob”, “Adams”, “Sr.”); // Error: Expected 1-2 arguments, but got 3.

// 默认参数 (提供默认值，同时也是可选参数)
function buildNameWithDefault(firstName: string, lastName = “Smith”): string {
return firstName + ” ” + lastName;
}

let result4 = buildNameWithDefault(“Bob”); // OK, uses default “Smith”
let result5 = buildNameWithDefault(“Bob”, “Adams”); // OK, uses “Adams”

// 剩余参数 (Rest Parameters)
function sumAll(firstNumber: number, …restOfNumbers: number[]): number {
let total = firstNumber;
for (let i = 0; i < restOfNumbers.length; i++) {
total += restOfNumbers[i];
}
return total;
}

let totalSum = sumAll(1, 2, 3, 4); // OK, restOfNumbers will be [2, 3, 4]
“`

3.12 类 (Classes)

TypeScript 对 ES6 的类提供了强大的支持，并增加了访问修饰符等特性。

“`typescript
class Greeter {
greeting: string; // 属性

// 构造函数
constructor(message: string) {
    this.greeting = message;
}

// 方法
greet(): string {
    return "Hello, " + this.greeting;
}

}

let greeter = new Greeter(“world”);
console.log(greeter.greet()); // Output: Hello, world

// 继承 (Inheritance)
class Animal {
name: string;
constructor(theName: string) { this.name = theName; }
move(distanceInMeters: number = 0) {
console.log(${this.name} moved ${distanceInMeters}m.);
}
}

class Snake extends Animal {
constructor(name: string) { super(name); } // 调用父类构造函数
move(distanceInMeters = 5) {
console.log(“Slithering…”);
super.move(distanceInMeters); // 调用父类方法
}
}

class Horse extends Animal {
constructor(name: string) { super(name); }
move(distanceInMeters = 45) {
console.log(“Galloping…”);
super.move(distanceInMeters);
}
}

let sam = new Snake(“Sammy the Python”);
let tom: Animal = new Horse(“Tommy the Palomino”); // 可以将子类实例赋值给父类类型的变量

sam.move(); // Output: Slithering… Sammy the Python moved 5m.
tom.move(34); // Output: Galloping… Tommy the Palomino moved 34m.

// 访问修饰符 (Access Modifiers): public, private, protected
class Person {
public name: string; // 默认就是 public，可以在任何地方访问
private age: number; // 只能在类的内部访问
protected jobTitle: string; // 只能在类及其子类内部访问

constructor(name: string, age: number, jobTitle: string) {
    this.name = name;
    this.age = age; // OK
    this.jobTitle = jobTitle; // OK
}

public getAge(): number {
    return this.age; // OK
}

}

class Employee extends Person {
private department: string;

constructor(name: string, age: number, jobTitle: string, department: string) {
    super(name, age, jobTitle);
    this.department = department;
}

public getJobAndDepartment(): string {
    return `${this.name}'s job is ${this.jobTitle} in department ${this.department}.`; // OK, can access protected jobTitle
    // return `${this.name}'s age is ${this.age}`; // Error: Property 'age' is private and only accessible within class 'Person'.
}

}

let john = new Employee(“John”, 30, “Developer”, “IT”);
console.log(john.name); // OK, public
console.log(john.getAge()); // OK, public method accesses private age
// console.log(john.age); // Error: Property ‘age’ is private and only accessible within class ‘Person’.
// console.log(john.jobTitle); // Error: Property ‘jobTitle’ is protected and only accessible within class ‘Person’ and its subclasses.
console.log(john.getJobAndDepartment()); // OK
“`

3.13 泛型 (Generics)

泛型提供了一种编写可重用组件的方式，这些组件可以支持多种类型的数据，同时仍然保持类型安全。它们允许你在定义函数、类或接口时不指定具体的类型，而在使用时再指定。

“`typescript
// 没有使用泛型，这个函数只能处理 numbers 数组
function firstElementOfNumberArray(arr: number[]): number | undefined {
return arr.length > 0 ? arr[0] : undefined;
}

// 没有使用泛型，这个函数只能处理 strings 数组
function firstElementOfStringArray(arr: string[]): string | undefined {
return arr.length > 0 ? arr[0] : undefined;
}

// 使用泛型，T 是一个类型变量
// 这个函数可以处理任何类型的数组，并且返回的类型是数组元素的类型
function firstElement(arr: T[]): T | undefined {
return arr.length > 0 ? arr[0] : undefined;
}

let numbers = [1, 2, 3];
let firstNumber = firstElement(numbers); // TypeScript 推断 T 是 number，firstNumber 的类型是 number | undefined

let strings = [“a”, “b”, “c”];
let firstString = firstElement(strings); // TypeScript 推断 T 是 string，firstString 的类型是 string | undefined

let booleans = [true, false];
let firstBoolean = firstElement(booleans); // TypeScript 推断 T 是 boolean，firstBoolean 的类型是 boolean | undefined

// 也可以显式指定类型参数
let firstElementExplicit = firstElement([“hello”, “world”]); // OK
// let firstElementExplicitError = firstElement([“hello”, “world”]); // Error: Argument of type ‘string[]’ is not assignable to parameter of type ‘number[]’.
“`

泛型在处理集合、异步操作、创建可复用数据结构等场景下非常有用。

4. TypeScript 的生态和工具

TypeScript 的成功还得益于其强大的生态系统和工具支持：

VS Code： 由微软开发的免费代码编辑器，对 TypeScript 提供了内置的、一流的支持，包括智能代码补全、实时错误检查、重构、调试等。
@types： 社区维护的高质量类型定义文件集合。通过 @types，你可以为几乎所有的流行 JavaScript 库（如 React, Lodash, Express 等）添加类型信息，即使这些库本身不是用 TypeScript 编写的。安装方式很简单，例如为 lodash 添加类型定义：npm install @types/lodash。
集成到构建工具： TypeScript 可以轻松地集成到 Webpack, Rollup, Parcel 等现代构建工具中。
框架支持： Angular 完全使用 TypeScript 编写，并强烈推荐使用 TypeScript 开发应用。React 和 Vue 社区也广泛使用 TypeScript，并提供了很好的支持和类型定义。

5. TypeScript 的潜在缺点

虽然 TypeScript 优势明显，但也存在一些潜在的缺点：

学习曲线： 引入了新的语法和概念（类型系统、接口、泛型等），对于刚接触的开发者来说需要一定的学习时间。
编译步骤： 编写的 TypeScript 代码需要通过编译器转换成 JavaScript 才能运行，这增加了一个额外的构建步骤（尽管通常这个步骤很快且自动化）。
代码量增加： 为了添加类型信息，代码量通常会比纯 JavaScript 代码稍微多一些。
配置复杂性： tsconfig.json 文件有许多配置选项，理解和配置它们可能需要一些经验。

然而，对于中大型项目而言，这些缺点所带来的成本通常远低于在运行时发现错误、维护复杂代码和低效协作所付出的代价。

6. 总结

TypeScript 为 JavaScript 带来了静态类型和更强大的面向对象特性，它是一个强大的工具，可以帮助开发者构建更健壮、可维护性更高、更具扩展性的应用。

通过：

静态类型检查，在开发早期捕获错误。
类型注解和接口，增强代码的可读性和可维护性。
和 tsc
强大的工具支持，提升开发效率。

TypeScript 已经成为现代前端和 Node.js 后端开发中越来越流行的选择。

本篇文章仅仅是 TypeScript 的冰山一角，它还有模块、命名空间、装饰器、高级类型（映射类型、条件类型）等更多特性等待你去探索。但掌握了基本类型、接口、类型别名、联合类型和函数类型这些核心概念，你就已经迈出了使用 TypeScript 的坚实一步。

开始在你的新项目中使用 TypeScript 吧，或者尝试将现有的小型项目迁移到 TypeScript，亲身体验它带来的便利和好处。祝你在 TypeScript 的世界里编码愉快！