TypeScript 基础类型

TypeScript 提供了多种基础数据类型，这些类型是构建更复杂类型的基础。本文将介绍 TypeScript 的基础类型。

1. 布尔类型（boolean）

布尔类型表示逻辑值，只有两个可能的值：true 和 false。

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

// 布尔类型的表达式
let isAdult: boolean = age >= 18;

2. 数字类型（number）

数字类型表示数值，包括整数和浮点数。TypeScript 中的数字类型与 JavaScript 中的数字类型相同，都是 64 位浮点数。

let decimal: number = 6;      // 十进制
let hex: number = 0xf00d;      // 十六进制
let binary: number = 0b1010;   // 二进制
let octal: number = 0o744;     // 八进制
let float: number = 3.14;      // 浮点数
let infinity: number = Infinity; // 无穷大
let nan: number = NaN;         // 非数字

3. 字符串类型（string）

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

let name: string = "John";
let message: string = 'Hello, TypeScript!';

// 模板字符串
let greeting: string = `Hello, ${name}!`;
let multiLine: string = `
This is a
multi-line
string
`;

4. 数组类型（array）

数组类型表示相同类型元素的集合，可以使用两种方式定义：

1. 使用 类型[] 语法
2. 使用 Array<类型> 语法

// 使用类型[] 语法
let numbers: number[] = [1, 2, 3, 4, 5];
let strings: string[] = ["a", "b", "c"];

// 使用 Array<类型> 语法
let numbers2: Array<number> = [1, 2, 3, 4, 5];
let strings2: Array<string> = ["a", "b", "c"];

5. 元组类型（tuple）

元组类型表示固定长度和固定类型的数组，各元素的类型可以不同。

// 定义元组类型
let person: [string, number];

// 初始化元组
person = ["John", 30]; // 正确

// 错误的初始化
// person = [30, "John"]; // 类型不匹配
// person = ["John", 30, "john@example.com"]; // 长度不匹配

// 访问元组元素
let name: string = person[0];
let age: number = person[1];

// 修改元组元素
person[0] = "Jane";
person[1] = 25;

6. 枚举类型（enum）

枚举类型允许你定义一组命名的常量。默认情况下，枚举值从 0 开始递增，但你也可以手动指定值。

数字枚举

enum Color {
  Red,    // 0
  Green,  // 1
  Blue    // 2
}

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

// 手动指定枚举值
enum Direction {
  Up = 1,
  Down,
  Left,
  Right
}

console.log(Direction.Up);    // 1
console.log(Direction.Down);  // 2
console.log(Direction.Left);  // 3
console.log(Direction.Right); // 4

// 完全手动指定枚举值
enum Status {
  Active = 100,
  Inactive = 200,
  Pending = 300
}

console.log(Status.Active);   // 100
console.log(Status.Inactive); // 200
console.log(Status.Pending);  // 300

字符串枚举

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

console.log(Direction.Up);    // "UP"
console.log(Direction.Down);  // "DOWN"
console.log(Direction.Left);  // "LEFT"
console.log(Direction.Right); // "RIGHT"

异构枚举

enum Mixed {
  No = 0,
  Yes = "YES"
}

console.log(Mixed.No);  // 0
console.log(Mixed.Yes); // "YES"

7. 任意类型（any）

任意类型允许你存储任何类型的值，禁用类型检查。当你不确定变量的类型时，可以使用 any 类型。

let notSure: any = 4;
notSure = "string";
notSure = true;
notSure = [1, 2, 3];
notSure = { name: "John" };

// 调用任意方法（不会在编译时检查）
notSure.toFixed(); // 可能会在运行时出错

8. 空类型（void）

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

function logMessage(message: string): void {
  console.log(message);
  // 没有 return 语句，或者 return undefined
}

function doNothing(): void {
  return;
}

// 变量也可以声明为 void 类型，但只能赋值 undefined 或 null（在非严格模式下）
let unusable: void = undefined;
// let unusable: void = null; // 在严格模式下会报错

9. null 和 undefined 类型

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

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

// 在非严格模式下，null 和 undefined 可以赋值给其他类型
let num: number = null; // 非严格模式下允许
let str: string = undefined; // 非严格模式下允许

// 在严格模式下，null 和 undefined 不能赋值给其他类型
// let num: number = null; // 严格模式下会报错
// let str: string = undefined; // 严格模式下会报错

10. never 类型

never 类型表示永远不会发生的值，通常用于以下情况：

• 抛出异常的函数
• 无限循环的函数
• 类型保护中永远不会到达的代码路径

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

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

// 类型保护中永远不会到达的代码路径
function processValue(value: string | number) {
  if (typeof value === "string") {
    // 处理字符串
  } else if (typeof value === "number") {
    // 处理数字
  } else {
    // 这里的类型是 never
    const neverValue: never = value;
  }
}

11. object 类型

object 类型表示非原始类型，即除了 number、string、boolean、bigint、symbol、null 和 undefined 之外的类型。

let obj: object = { name: "John", age: 30 };
let arr: object = [1, 2, 3];
let func: object = function() {};

// 不能将原始类型赋值给 object 类型
// let num: object = 42; // 错误
// let str: object = "string"; // 错误
// let bool: object = true; // 错误

12. 类型推断

TypeScript 具有强大的类型推断能力，即使你不明确指定类型，它也能根据上下文推断出正确的类型。

// TypeScript 会推断出 message 是 string 类型
let message = "Hello, TypeScript!";

// TypeScript 会推断出 numbers 是 number[] 类型
let numbers = [1, 2, 3, 4, 5];

// TypeScript 会推断出 person 是 { name: string; age: number } 类型
let person = { name: "John", age: 30 };

// TypeScript 会推断出 add 函数的参数和返回值类型
function add(a, b) {
  return a + b;
}
// add 函数的类型被推断为 (a: any, b: any) => any

13. 类型断言

类型断言允许你告诉 TypeScript 编译器某个值的类型，当你比编译器更了解某个值的类型时使用。

使用尖括号语法

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

使用 as 语法

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

14. 类型别名

类型别名允许你为复杂的类型定义一个简短的名称。

type UserId = number;
type UserName = string;
type Email = string;

type User = {
  id: UserId;
  name: UserName;
  email: Email;
  age?: number;
};

let user: User = {
  id: 1,
  name: "John",
  email: "john@example.com"
};

15. 联合类型

联合类型允许一个变量可以是多种类型之一。

let value: string | number;
value = "Hello";
value = 42;

// 联合类型与类型保护
function processValue(value: string | number) {
  if (typeof value === "string") {
    console.log(`String value: ${value.toUpperCase()}`);
  } else {
    console.log(`Number value: ${value.toFixed(2)}`);
  }
}

processValue("hello"); // String value: HELLO
processValue(42); // Number value: 42.00

16. 交叉类型

交叉类型允许将多个类型合并为一个类型。

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

interface Employee {
  employeeId: number;
  department: string;
}

type EmployeePerson = Person & Employee;

let emp: EmployeePerson = {
  name: "John",
  age: 30,
  employeeId: 123,
  department: "IT"
};

总结

TypeScript 的基础类型包括：

• 布尔类型（boolean）：表示逻辑值
• 数字类型（number）：表示数值
• 字符串类型（string）：表示文本数据
• 数组类型（array）：表示相同类型元素的集合
• 元组类型（tuple）：表示固定长度和固定类型的数组
• 枚举类型（enum）：定义一组命名的常量
• 任意类型（any）：禁用类型检查
• 空类型（void）：表示没有返回值的函数
• null 和 undefined 类型：表示"空值"和"未定义"
• never 类型：表示永远不会发生的值
• object 类型：表示非原始类型

此外，TypeScript 还提供了类型推断、类型断言、类型别名、联合类型和交叉类型等特性，使你能够更灵活地定义和使用类型。

掌握这些基础类型是学习 TypeScript 的重要基础，它们将帮助你编写更安全、更可维护的代码。