本文介绍了 Typescript 类型教程，涵盖了基本类型、函数类型、接口与类型、类型推论与类型断言等内容，旨在帮助开发者理解并使用 Typescript 的类型系统。文章详细解释了不同类型的特点和用法，并提供了示例代码和练习题以加深理解。

Typescript 是由 Microsoft 开发的开源编程语言，它是 JavaScript 的超集，可以在任何支持 JavaScript 的地方运行。TypeScript 的主要特点是提供了静态类型检查，这使得开发人员可以在编码阶段发现类型错误，从而提高代码质量和维护性。TypeScript 代码会被编译成标准的 JavaScript 代码，因此可以在任何兼容 ECMAScript 的环境中运行。

1. 类型检查：最显著的区别在于 TypeScript 引入了类型系统，可以为变量、函数参数、返回值等指定类型。这使得开发者可以在编译时得到类型错误的反馈，而 JavaScript 是一种动态类型语言，它在运行时执行类型检查。

2. 接口和类型定义：在 TypeScript 中，可以定义接口（Interfaces）和类型（Types）来描述对象的结构。这有助于确保代码的一致性和可预测性。

3. 更好的工具支持：因为 TypeScript 代码会被编译成 JavaScript，所以它支持更高级的开发工具，如代码补全、重构等。这些工具在纯 JavaScript 开发中不容易实现。

4. 类和继承：TypeScript 支持类和继承，这使得面向对象的编程更加方便。JavaScript 也支持类似的概念，但其实现更复杂，需要使用构造函数、原型等。

5. 模块化：TypeScript 支持 ES2015 模块语法，这使得编写模块化代码变得更加容易。

要使用 Typescript，首先需要安装 Node.js（如果还没有安装的话），然后使用 npm（Node.js 的包管理器）来安装 TypeScript 编译器。

npm install -g typescript

安装完成后，可以通过创建一个名为 tsconfig.json 的文件来配置 Typescript 的编译选项，例如：

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "outDir": "./dist"
  }
}

tsconfig.json 文件中的配置项定义了编译器的行为，如目标 ES 版本、模块系统、输出目录等。编译时可以通过命令行工具 tsc 来编译 TypeScript 代码，例如：

tsc

编译后，编译器会根据配置文件将 .ts 文件编译成 .js 文件。

• string：字符串类型。可以使用单引号、双引号或反引号定义。

let name: string = "Alice";
let greeting: string = `Hello, ${name}!`;

• number：数字类型。可以是整数或浮点数。

let age: number = 25;
let decimal: number = 3.14;

• boolean：布尔类型。可以是 true 或 false。

let isStudent: boolean = true;
let isActive: boolean = false;

• null 和 undefined：这两个类型表示空值和未定义值。

let empty: null = null;
let notDefined: undefined = undefined;

• any：任何类型。通常在无法确定类型时使用。

let anyValue: any = "Hello";
anyValue = 123; // 也可以是数字或其他类型

联合类型允许变量同时拥有多种类型。

let value: string | number;
value = "Alice"; // 字符串类型
value = 123;     // 数字类型
// value = true; // 错误：布尔类型不匹配

元组类型允许定义固定长度的数组，并指定每个位置的数据类型。

let person: [string, number, boolean];
person = ["Alice", 25, true];
// person = ["Bob", 30]; // 错误：长度不匹配且类型不匹配

在 TypeScript 中，可以为函数定义类型，包括参数类型和返回类型。

function add(a: number, b: number): number {
  return a + b;
}

let result: number = add(3, 5);

• 可选参数：使用 ? 标记参数为可选。

function sendMessage(to: string, message: string, subject?: string): void {
  console.log(`To: ${to}`);
  console.log(`Message: ${message}`);
  if (subject) {
    console.log(`Subject: ${subject}`);
  }
}

sendMessage("alice@example.com", "Hello!");
sendMessage("bob@example.com", "Hi!", "Greeting");

• 默认参数：在函数定义中为参数提供默认值。

function greet(name: string, greeting: string = "Hello") {
  console.log(`${greeting}, ${name}!`);
}

greet("Alice"); // 输出 "Hello, Alice!"
greet("Bob", "Hi"); // 输出 "Hi, Bob!"

函数重载允许函数在不同情况下接受不同类型的参数并返回不同类型的结果。

function format(value: string): string;
function format(value: number): number;
function format(value: string | number) {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else if (typeof value === "number") {
    return value * 10;
  }
}

console.log(format("hello")); // 输出 "HELLO"
console.log(format(10));      // 输出 100

接口用于定义对象的结构，通常用于描述对象的形状。

interface Person {
  name: string;
  age: number;
  greet(): void;
}

let alice: Person = {
  name: "Alice",
  age: 25,
  greet() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

alice.greet(); // 输出 "Hello, my name is Alice"

类型与接口类似，但接口更适合描述对象的结构，类型更适合定义单一的数据结构。

type Point = {
  x: number;
  y: number;
};

let origin: Point = { x: 0, y: 0 };
let point: Point = { x: 10, y: 20 };

• 定义方式：接口使用 interface 关键字定义，而类型使用 type 关键字定义。
• 灵活性：接口可以多次定义，可以逐步扩展，而类型一旦定义就不能修改。
• 继承：接口支持继承，类型不支持。

interface Animal {
  name: string;
}

interface Bird extends Animal {
  fly(): void;
}

let bird: Bird = {
  name: "Eagle",
  fly() {
    console.log(`${this.name} is flying`);
  }
};

bird.fly(); // 输出 "Eagle is flying"

类型推论是 TypeScript 自动推断变量类型的特性，通常在未明确指定类型时使用。

let message = "Hello, World!";
// message 的类型被推断为 string
console.log(message.toUpperCase()); // 输出 "HELLO, WORLD!"

let numberValue = 10;
// numberValue 的类型被推断为 number
console.log(numberValue + 5); // 输出 15

类型断言用于告诉编译器某个值的类型，通常在需要明确类型但类型推论不准确时使用。

let unknownValue: any = "Hello";
let stringValue = unknownValue as string;
console.log(stringValue.toUpperCase()); // 输出 "HELLO"

let maybeNull: number | null = 10;
let maybeNotNull = maybeNull as number;
console.log(maybeNotNull + 5); // 输出 15

假设我们要构建一个简单的图书管理系统。首先定义图书的结构。

interface Book {
  title: string;
  author: string;
  year: number;
}

let book1: Book = {
  title: "The Great Gatsby",
  author: "F. Scott Fitzgerald",
  year: 1925
};

let book2: Book = {
  title: "1984",
  author: "George Orwell",
  year: 1949
};

接下来定义一个图书馆类，包含添加和查找图书的方法。

class Library {
  private books: Book[] = [];

  addBook(book: Book) {
    this.books.push(book);
  }

  findBook(title: string): Book | undefined {
    return this.books.find(book => book.title === title);
  }
}

let library = new Library();
library.addBook(book1);
library.addBook(book2);

let foundBook = library.findBook("The Great Gatsby");
console.log(foundBook?.title ?? "Not found"); // 输出 "The Great Gatsby"

练习题 1

定义一个 User 接口，包含 name、email 和 age 属性。创建一个用户对象，并使用 console.log 输出用户信息。

答案

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

let user: User = {
  name: "Alice",
  email: "alice@example.com",
  age: 25
};

console.log(`Name: ${user.name}, Email: ${user.email}, Age: ${user.age}`);

练习题 2

定义一个 Rectangle 类，包含 width 和 height 属性，并提供计算面积的方法。创建一个矩形对象并计算面积。

答案

class Rectangle {
  width: number;
  height: number;

  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }

  getArea(): number {
    return this.width * this.height;
  }
}

let rectangle = new Rectangle(10, 5);
console.log(rectangle.getArea()); // 输出 50

练习题 3

定义一个 Calculator 类，包含 add 和 subtract 方法。创建一个计算器对象，并使用这两个方法进行计算。

答案

class Calculator {
  add(a: number, b: number): number {
    return a + b;
  }

  subtract(a: number, b: number): number {
    return a - b;
  }
}

let calculator = new Calculator();

console.log(calculator.add(5, 3));  // 输出 8
console.log(calculator.subtract(10, 5)); // 输出 5