TypeScript 基础类型

TypeScript 提供了丰富的类型系统，包括基础类型和高级类型。本章节将介绍 TypeScript 的基础类型。

布尔类型 boolean

布尔类型表示真或假的值，只有两个值：true 和 false。

示例：

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

数字类型 number

TypeScript 中的数字类型包括整数、浮点数、十六进制、八进制、二进制等。

示例：

let decimal: number = 6;
let hex: number = 0xf00d; // 十六进制
let binary: number = 0b1010; // 二进制
let octal: number = 0o744; // 八进制
let float: number = 3.14;

字符串类型 string

字符串类型表示文本数据，可以使用单引号、双引号或模板字符串。

示例：

let name: string = "TypeScript";
let message: string = 'Hello, TypeScript!';
let template: string = `Hello, ${name}!`; // 模板字符串

数组类型

TypeScript 提供了两种方式来定义数组类型：

方式 1：类型[]

let numbers: number[] = [1, 2, 3, 4, 5];
let strings: string[] = ["a", "b", "c"];

方式 2：Array<类型>

let numbers: Array<number> = [1, 2, 3, 4, 5];
let strings: Array<string> = ["a", "b", "c"];

元组 Tuple

元组类型允许表示一个已知元素数量和类型的数组，各元素的类型可以不同。

示例：

// 定义一个元组类型，第一个元素是字符串，第二个元素是数字
let person: [string, number] = ["John", 30];

// 访问元组元素
console.log(person[0]); // John
console.log(person[1]); // 30

// 元组越界访问会报错
// person[2] = "Doe"; // 错误：Tuple type '[string, number]' of length '2' has no element at index '2'

枚举 Enum

枚举类型用于定义一组命名的常量，默认从 0 开始编号。

示例：

// 基本枚举
enum Color {
  Red,
  Green,
  Blue
}

let c: Color = Color.Green;
console.log(c); // 1

// 自定义枚举值
enum Direction {
  Up = 1,
  Down,
  Left,
  Right
}

let d: Direction = Direction.Down;
console.log(d); // 2

// 字符串枚举
enum Status {
  Success = "SUCCESS",
  Error = "ERROR",
  Pending = "PENDING"
}

let s: Status = Status.Success;
console.log(s); // SUCCESS

任意类型 any

any 类型表示任意类型，它会关闭 TypeScript 的类型检查。应谨慎使用 any 类型，因为它会失去 TypeScript 的类型安全优势。

示例：

let notSure: any = 4;
notSure = "maybe a string";
notSure = false;

// any 类型的变量可以访问任何属性或方法
let anyValue: any = "hello";
console.log(anyValue.length); // 5
anyValue.toUpperCase(); // HELLO

空类型 undefined / null

undefined 和 null 是 TypeScript 中的两种特殊类型，分别表示未定义和空值。

示例：

let u: undefined = undefined;
let n: null = null;

// 在 strictNullChecks 模式下，undefined 和 null 只能赋值给自身或 any 类型
// let num: number = null; // 错误：Type 'null' is not assignable to type 'number'

// 非 strictNullChecks 模式下，undefined 和 null 可以赋值给任何类型

无返回值 void

void 类型表示函数没有返回值。

示例：

function sayHello(): void {
  console.log("Hello!");
  // 没有 return 语句或 return undefined
}

function doNothing(): void {
  return undefined; // 可以返回 undefined
}

// void 类型的变量只能赋值为 undefined 或 null
let unusable: void = undefined;
// unusable = 4; // 错误：Type 'number' is not assignable to type 'void'

永不存在 never

never 类型表示永远不会发生的值，通常用于函数抛出异常或无限循环的情况。

示例：

// 抛出异常的函数
function error(message: string): never {
  throw new Error(message);
}

// 无限循环的函数
function infiniteLoop(): never {
  while (true) {
    // 无限循环
  }
}

// never 类型可以赋值给任何类型
let num: number = error("Error"); // 虽然会抛出异常，但类型检查通过

// 任何类型都不能赋值给 never 类型
// let neverValue: never = 4; // 错误：Type 'number' is not assignable to type 'never'

类型断言

类型断言允许你告诉 TypeScript 编译器，你知道某个值的类型比它推断的类型更具体。

方式 1：as 语法

let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;

方式 2：尖括号语法

let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;

注意： 在 JSX 中，只能使用 as 语法进行类型断言。

实战：给变量、函数加基础类型

示例 1：给变量添加类型

// 布尔类型
const isActive: boolean = true;

// 数字类型
const age: number = 25;
const price: number = 99.99;

// 字符串类型
const name: string = "John";
const message: string = `Hello, ${name}!`;

// 数组类型
const numbers: number[] = [1, 2, 3, 4, 5];
const fruits: Array<string> = ["apple", "banana", "orange"];

// 元组类型
const person: [string, number] = ["John", 30];

// 枚举类型
enum Gender {
  Male,
  Female
}
const gender: Gender = Gender.Male;

// 任意类型（尽量避免使用）
const dynamicValue: any = "Hello";

// 空类型
const nothing: undefined = undefined;
const empty: null = null;

示例 2：给函数添加类型

// 函数参数和返回值类型
function add(a: number, b: number): number {
  return a + b;
}

// 无返回值函数
function logMessage(message: string): void {
  console.log(message);
}

// 可选参数（使用 ? 标记）
function greet(name: string, greeting?: string): string {
  if (greeting) {
    return `${greeting}, ${name}!`;
  }
  return `Hello, ${name}!`;
}

// 默认参数
function calculateTotal(price: number, tax: number = 0.08): number {
  return price + price * tax;
}

// 剩余参数
function sum(...numbers: number[]): number {
  return numbers.reduce((acc, curr) => acc + curr, 0);
}

小结

本章节介绍了 TypeScript 的基础类型，包括：

• 布尔类型 boolean
• 数字类型 number
• 字符串类型 string
• 数组类型 number[] / Array<number>
• 元组类型 Tuple
• 枚举类型 Enum
• 任意类型 any
• 空类型 undefined / null
• 无返回值 void
• 永不存在 never
• 类型断言

掌握这些基础类型是学习 TypeScript 的第一步，它们是构建更复杂类型的基础。在实际开发中，应该尽量使用具体的类型，而不是 any 类型，以充分利用 TypeScript 的类型安全优势。