TypeScript 基础类型

TypeScript 是 JavaScript 的超集，它引入了静态类型系统。类型检查在编译时进行，能有效减少运行时错误。

布尔值 (Boolean)

最基本的数据类型就是简单的 true/false 值。

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

数字 (Number)

和 JavaScript 一样，TypeScript 里的所有数字都是浮点数。支持十进制、十六进制、二进制和八进制字面量。

let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;
let binaryLiteral: number = 0b1010;
let octalLiteral: number = 0o744;
let bigLiteral: bigint = 100n; // ES2020 引入的大整数

字符串 (String)

可以使用双引号 " 或单引号 ' 表示字符串，也可以使用模板字符串 ``。

let name: string = "bob";
name = "smith";

let age: number = 37;
let sentence: string = `Hello, my name is ${name}.
I'll be ${age + 1} years old next month.`;

数组 (Array)

有两种方式定义数组：

// 1. 元素类型后面接上 []
let list: number[] = [1, 2, 3];

// 2. 使用数组泛型 Array<元素类型>
let list2: Array<number> = [1, 2, 3];

// 混合类型数组
let mixList: (number | string)[] = [1, "2", 3];

元组 (Tuple)

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

let x: [string, number];
x = ['hello', 10]; // OK
// x = [10, 'hello']; // Error: 类型不匹配

// 访问越界元素（旧版本行为，新版本通常禁止）
// x[3] = 'world'; 

// 可选元素元组
let optionalTuple: [string, number?] = ["hello"];

枚举 (Enum)

枚举类型是对 JavaScript 标准数据类型的一个补充。

数字枚举

默认情况下，从 0 开始为元素编号。

enum Color {Red, Green, Blue}
let c: Color = Color.Green; // 1

也可以手动赋值：

enum Color2 {Red = 1, Green, Blue}
let colorName: string = Color2[2]; // 'Green'

字符串枚举

字符串枚举没有自增长的行为，每个成员都必须用字符串字面量初始化。

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

常量枚举

使用 const enum 定义，编译阶段会被删除，减少代码体积。

const enum Enum {
    A = 1,
    B = A * 2
}

Any

any 类型表示允许赋值为任意类型。在迁移旧代码或使用第三方库时很有用，但应尽量避免过度使用。

let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

let list: any[] = [1, true, "free"];
list[1] = 100;

Unknown

unknown 是类型安全的 any。我们可以将任何值赋给 unknown，但在进行类型检查或类型断言之前，不能对 unknown 变量执行任何操作。

let value: unknown;

value = true;             // OK
value = 42;               // OK
value = "Hello World";    // OK

// let value1: boolean = value; // Error
// value.foo.bar;  // Error
// value();        // Error

// 必须进行类型收窄
if (typeof value === "string") {
    console.log(value.toUpperCase()); // OK
}

Void

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

function warnUser(): void {
    console.log("This is my warning message");
}

// 声明一个 void 类型的变量没有什么大用，因为你只能将它赋值为 undefined 或 null
let unusable: void = undefined;

Null 和 Undefined

TypeScript 里，undefined 和 null 两者各自有自己的类型。

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

默认情况下 null 和 undefined 是所有类型的子类型。 就是说你可以把 null 和 undefined 赋值给 number 类型的变量。 然而，当你指定了 --strictNullChecks 标记（推荐），null 和 undefined 只能赋值给 void 和它们各自。

Never

never 类型表示的是那些永不存在的值的类型。例如，never 类型是那些总是会抛出异常或根本就不会有返回值的函数表达式的返回值类型。

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
    throw new Error(message);
}

// 推断的返回值类型为never
function fail() {
    return error("Something failed");
}

// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
    while (true) {
    }
}

Object

object 表示非原始类型，也就是除 number，string，boolean，symbol，null or undefined 之外的类型。

declare function create(o: object | null): void;

create({ prop: 0 }); // OK
create(null); // OK

// create(42); // Error
// create("string"); // Error

类型断言 (Type Assertions)

有时候你会比 TypeScript 更了解某个值的详细信息。

let someValue: any = "this is a string";

// 方式一：尖括号语法
let strLength: number = (<string>someValue).length;

// 方式二：as 语法（在 JSX 中推荐使用）
let strLength2: number = (someValue as string).length;