登录Typescript之类型总结大全
TypeScript 中的基本类型
TypeScript 的基本类型涵盖了 JavaScript 的原始类型，并添加了一些 TypeScript 特有的类型。
1. JavaScript 原始类型（Primitive Types）
这些是 JavaScript 原有的基本数据类型，TypeScript 为它们提供了类型注解。
boolean - 布尔值
let isDone: boolean = true;
let isLoading: boolean = false;
number - 数字
TypeScript 中的所有数字都是浮点数，支持十进制、十六进制、二进制和八进制。
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 notANumber: number = NaN;
string - 字符串
let name: string = "张三";
let sentence: string = `你好，${name}！`; // 模板字符串
bigint - 大整数（ES2020+）
表示大于 2^53 - 1 的整数。
let big: bigint = 9007199254740991n;
let big2: bigint = BigInt(9007199254740991);
symbol - 符号（ES2015+）
创建唯一的标识符。
typescript
let sym1: symbol = Symbol();
let sym2: symbol = Symbol("description");
2. 特殊原始类型
null - 空值
let n: null = null;
undefined - 未定义
let u: undefined = undefined;
注意：在 strictNullChecks 模式下，null 和 undefined 只能赋值给它们自己或 any 类型。
3. TypeScript 特有类型
any - 任意类型
关闭类型检查，兼容所有类型。
let notSure: any = 4;
notSure = "可能是字符串";
notSure = false; // 没问题
unknown - 未知类型
比 any 更安全的类型，使用时需要类型检查或断言。
let value: unknown;
// 需要类型检查后才能使用
if (typeof value === "string") {
console.log(value.length);
}
// 或使用类型断言
let str: string = (value as string);
void - 空类型
表示函数没有返回值。
function warnUser(): void {
console.log("警告信息");
// 没有 return 语句
}
never - 永不存在的值
表示永远不会发生的类型，用于总是抛出异常或无限循环的函数。
// 抛出错误
function error(message: string): never {
throw new Error(message);
}
// 无限循环
function infiniteLoop(): never {
while (true) {}
}
object - 非原始类型
表示非原始类型的值（不是 number, string, boolean, symbol, null, undefined）。
let obj: object = {};
let arr: object = [];
let func: object = function() {};
4. 数组类型
有两种表示方式：
类型 + 方括号
let list: number[] = [1, 2, 3];
let strings: string[] = ["a", "b", "c"];
泛型 Array<类型>
let list: Array<number> = [1, 2, 3];
let strings: Array<string> = ["a", "b", "c"];
只读数组
let readonlyArr: ReadonlyArray<number> = [1, 2, 3];
// readonlyArr.push(4); // ❌ 错误：只读数组不能修改
5. 元组（Tuple）
表示已知元素数量和类型的数组。
// 定义元组类型
let tuple: [string, number];
tuple = ["hello", 10]; // ✅ 正确
// tuple = [10, "hello"]; // ❌ 错误：类型不匹配
// 访问元组元素
console.log(tuple[0].substring(1)); // "ello"
console.log(tuple[1].toFixed(2)); // "10.00"
// 可选元素（3.0+）
let optionalTuple: [string, number?];
optionalTuple = ["hello"]; // ✅ 正确
optionalTuple = ["hello", 42]; // ✅ 正确
// 剩余元素
let restTuple: [string, ...number[]];
restTuple = ["hello", 1, 2, 3]; // ✅ 正确
6. 枚举（Enum）
数字枚举
enum Direction {
Up = 1, // 从 1 开始
Down, // 自动递增为 2
Left, // 3
Right // 4
}
let dir: Direction = Direction.Up;
字符串枚举
enum Direction {
Up = "UP",
Down = "DOWN",
Left = "LEFT",
Right = "RIGHT"
}
常量枚举（编译时完全删除）
const enum Colors {
Red,
Green,
Blue
}
let color = Colors.Red; // 编译后：let color = 0;
7. 字面量类型
字符串字面量
type EventType = "click" | "scroll" | "mousemove";
let event: EventType = "click"; // ✅
// event = "hover"; // ❌ 错误
数字字面量
type DiceRoll = 1 | 2 | 3 | 4 | 5 | 6;
let roll: DiceRoll = 3; // ✅
// roll = 7; // ❌ 错误
布尔字面量
type Truthy = true;
let isTrue: Truthy = true;
// isTrue = false; // ❌ 错误
8. 类型推断与联合类型
类型推断
let x = 3; // x 被推断为 number
let y = "hello"; // y 被推断为 string
联合类型
let id: string | number;
id = "abc123"; // ✅
id = 123; // ✅
// id = true; // ❌ 错误
// 类型守卫
if (typeof id === "string") {
console.log(id.toUpperCase());
} else {
console.log(id.toFixed(2));
}
9. 类型别名
// 基本类型别名
type ID = string | number;
type Point = {
x: number;
y: number;
};
let userId: ID = "user-123";
let position: Point = { x: 10, y: 20 };
类型总结表
| 类型 | 示例 | 描述 |
|---|---|---|
boolean |
let isDone: boolean = true; |
布尔值 |
number |
let count: number = 10; |
所有数字类型 |
string |
let name: string = "John"; |
字符串 |
bigint |
let big: bigint = 100n; |
大整数 |
symbol |
let sym: symbol = Symbol(); |
唯一标识符 |
null |
let n: null = null; |
空值 |
undefined |
let u: undefined = undefined; |
未定义 |
any |
let anything: any = 4; |
任意类型 |
unknown |
let unsure: unknown = 30; |
未知类型 |
void |
function(): void {} |
无返回值 |
never |
function error(): never {} |
永不存在的值 |
object |
let obj: object = {}; |
非原始类型 |
Array<T> |
let list: number[] = [1, 2, 3]; |
数组 |
[T1, T2] |
let tuple: [string, number]; |
元组 |
enum |
enum Color { Red, Green } |
枚举 |
实用示例
// 完整示例
function processInput(input: string | number | boolean): string {
if (typeof input === "string") {
return `字符串: ${input.toUpperCase()}`;
} else if (typeof input === "number") {
return `数字: ${input.toFixed(2)}`;
} else {
return `布尔值: ${input}`;
}
}
// 严格空值检查
function greet(name: string | null): string {
if (name === null) {
return "你好，访客！";
}
return `你好，${name}！`;
}
// 使用 never 进行穷尽检查
type Shape = "circle" | "square" | "triangle";
function getArea(shape: Shape): number {
switch (shape) {
case "circle":
return Math.PI;
case "square":
return 1;
case "triangle":
return 0.5;
default:
// 确保处理了所有情况
const _exhaustiveCheck: never = shape;
return _exhaustiveCheck;
}
}
TypeScript 的基本类型系统提供了强大的类型安全保证，帮助开发者在编译时捕获错误，提高代码质量。
