基础类型

概述

TypeScript 提供了丰富的基础类型系统，这些类型是构建复杂类型的基础。理解基础类型是掌握 TypeScript 的第一步，它们为变量、函数参数和返回值提供了类型约束，帮助我们在编译时发现错误。

基本类型

string 类型

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

// 字符串类型声明
let name: string = "TypeScript";
let message: string = 'Hello, World!';
let template: string = `Hello, ${name}!`;

// 字符串方法
let text: string = "hello";
let upper: string = text.toUpperCase(); // "HELLO"
let length: number = text.length; // 5

number 类型

number 类型表示所有数字，包括整数和浮点数。TypeScript 不区分整数和浮点数，统一使用 number 类型。

// 数字类型声明
let count: number = 42;
let price: number = 99.99;
let hex: number = 0xf00d; // 十六进制
let binary: number = 0b1010; // 二进制
let octal: number = 0o744; // 八进制

// 数字运算
let sum: number = count + price;
let result: number = Math.sqrt(16); // 4

boolean 类型

boolean 类型表示逻辑值，只有两个值：true 和 false。

// 布尔类型声明
let isActive: boolean = true;
let isCompleted: boolean = false;

// 布尔运算
let isValid: boolean = count > 0;
let hasPermission: boolean = isActive && isCompleted;

特殊类型

null 和 undefined

null 和 undefined 是 TypeScript 中的两个特殊类型，它们各自只有一个值。

// null 类型：表示空值
let data: null = null;

// undefined 类型：表示未定义
let value: undefined = undefined;

// 在严格模式下，null 和 undefined 不能赋值给其他类型
let name: string = null; // 错误（严格模式下）
let age: number = undefined; // 错误（严格模式下）

提示

在 TypeScript 的严格模式下（strictNullChecks: true），null 和 undefined 不能赋值给其他类型。如果需要允许这些值，可以使用联合类型：string | null | undefined。

void 类型

void 类型表示没有任何返回值，通常用于函数的返回类型。

// void 类型：表示函数没有返回值
function logMessage(message: string): void {
  console.log(message);
  // 没有 return 语句，或 return; 不返回值
}

// void 类型的变量只能赋值为 undefined
let result: void = undefined;
// let result: void = null; // 错误（严格模式下）

never 类型

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

1. 抛出异常的函数
2. 永远不会返回的函数（如无限循环）
3. 类型守卫中排除不可能的情况

// never 类型：表示永远不会返回
function throwError(message: string): never {
  throw new Error(message);
  // 函数永远不会正常返回
}

function infiniteLoop(): never {
  while (true) {
    // 无限循环，永远不会返回
  }
}

// 类型守卫中使用 never
function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`);
}

// 在联合类型中，never 会被自动排除
type Status = 'pending' | 'completed' | 'cancelled';

function handleStatus(status: Status) {
  switch (status) {
    case 'pending':
      // 处理 pending
      break;
    case 'completed':
      // 处理 completed
      break;
    case 'cancelled':
      // 处理 cancelled
      break;
    default:
      // 如果所有情况都处理了，这里 value 的类型是 never
      assertNever(status);
  }
}

类型推断

TypeScript 具有强大的类型推断能力，即使不显式声明类型，TypeScript 也能根据值推断出类型。

// TypeScript 自动推断类型
let name = "TypeScript"; // 推断为 string
let count = 42; // 推断为 number
let isActive = true; // 推断为 boolean

// 函数返回类型推断
function add(a: number, b: number) {
  return a + b; // 推断返回类型为 number
}

// 数组类型推断
let numbers = [1, 2, 3]; // 推断为 number[]
let mixed = [1, "hello", true]; // 推断为 (number | string | boolean)[]

实际应用示例

示例 1：用户信息处理

// 定义用户信息类型
let userName: string = "John Doe";
let userAge: number = 30;
let isVip: boolean = true;

// 处理用户信息
function displayUserInfo(name: string, age: number, vip: boolean): void {
  console.log(`Name: ${name}`);
  console.log(`Age: ${age}`);
  console.log(`VIP: ${vip ? "Yes" : "No"}`);
}

displayUserInfo(userName, userAge, isVip);

示例 2：数据验证

// 验证函数
function validateInput(value: string | null | undefined): boolean {
  // 类型守卫：检查值是否存在
  if (value === null || value === undefined) {
    return false;
  }
  
  // 此时 TypeScript 知道 value 是 string 类型
  return value.length > 0;
}

// 使用示例
let input1: string | null = "hello";
let input2: string | null = null;

console.log(validateInput(input1)); // true
console.log(validateInput(input2)); // false

示例 3：错误处理

// 使用 never 类型处理错误
function processData(data: string): string {
  if (!data) {
    throw new Error("Data cannot be empty"); // 返回 never
  }
  
  return data.toUpperCase();
}

// 使用 void 类型表示副作用
function logError(error: string): void {
  console.error(`Error: ${error}`);
  // 没有返回值
}

// 组合使用
try {
  const result = processData("hello");
  console.log(result);
} catch (error) {
  logError(error instanceof Error ? error.message : "Unknown error");
}

类型检查示例

常见错误

// ❌ 错误：类型不匹配
let count: number = "42"; // Error: Type 'string' is not assignable to type 'number'

// ❌ 错误：缺少必需属性
function greet(name: string): string {
  return `Hello, ${name}!`;
}
greet(); // Error: Expected 1 arguments, but got 0

// ❌ 错误：void 类型不能返回值
function logMessage(msg: string): void {
  return msg; // Error: Type 'string' is not assignable to type 'void'
}

正确写法

// ✅ 正确：类型匹配
let count: number = 42;

// ✅ 正确：提供所有参数
function greet(name: string): string {
  return `Hello, ${name}!`;
}
greet("TypeScript");

// ✅ 正确：void 函数不返回值
function logMessage(msg: string): void {
  console.log(msg);
  // 没有 return 语句
}

注意事项

提示

虽然 TypeScript 支持类型推断，但显式声明类型可以让代码更清晰，特别是在函数参数和返回值中。

注意

在严格模式下，null 和 undefined 需要显式处理。使用联合类型 string | null | undefined 或可选属性 name?: string 来表示可能为空的值。

重要

never 类型不应该被显式赋值给变量（除了在类型守卫中）。如果看到 never 类型，通常意味着代码逻辑有问题或类型系统发现了不可能的情况。

信息

void 和 undefined 的区别：

• void 表示"没有返回值"，用于函数返回类型
• undefined 是一个实际的值，可以赋值给变量
• 在严格模式下，void 类型的变量只能赋值为 undefined

类型总结

类型	说明	示例值
string	字符串类型	"hello", 'world', `template`
number	数字类型	42, 3.14, 0xf00d
boolean	布尔类型	true, false
null	空值	null
undefined	未定义	undefined
void	无返回值	仅用于函数返回类型
never	永不发生	用于异常或无限循环

相关链接

• 对象类型
• 数组和元组
• 类型推断和兼容性
• TypeScript 官方文档 - 基础类型