TypeScript 的基础语法

**一、数据类型**

1. 基本数据类型：
   - `number`：数字类型，包括整数和浮点数。
   - `string`：字符串类型。
   - `boolean`：布尔类型，只有 `true` 和 `false` 两个值。
   - `null` 和 `undefined`：分别表示空值和未定义。
   - `symbol`：唯一的不可变的数据类型。
   - `bigint`：用于表示任意大的整数。

2. 复杂数据类型：
   - `array`：数组类型，可以使用两种方式定义，例如 `let arr: number[] = [1, 2, 3]` 或者 `let arr: Array<number> = [1, 2, 3]`。也可以使用联合类型定义数组，如 `let arr: (number | string)[] = [1, 2, "three"]`。
   - `tuple`：元组类型，允许存储固定数量不同类型的元素，例如 `let tuple: [string, number] = ['hello', 42]`。
   - `enum`：枚举类型，用于定义一组命名的常量，例如 `enum Color { Red, Green, Blue }`。
   - `object`：对象类型，可以定义具有特定属性和方法的对象。

**二、变量声明**

1. 使用 `let` 和 `const` 声明变量：
   - `let` 声明的变量可以被重新赋值，具有块级作用域。
   - `const` 声明的变量是常量，不能被重新赋值，也具有块级作用域。

2. 类型注解：
   - 可以在变量声明时添加类型注解，明确变量的类型，例如 `let num: number = 10`。如果没有显式指定类型，TypeScript 会根据初始值进行类型推断。

**三、函数**

1. 函数声明：
   - `function add(a: number, b: number): number { return a + b; }`，明确参数类型和返回值类型。
   - 可选参数使用 `?` 表示，例如 `function greet(name: string, age?: number) {... }`。
   - 默认参数可以直接在参数后面赋值，例如 `function greet(name: string, age = 20) {... }`。

2. 箭头函数：
   - `const add = (a: number, b: number): number => a + b;`。箭头函数具有更简洁的语法和词法作用域特性。

**四、接口（interface）**

1. 定义接口：
   - `interface Person { name: string; age: number; }`，用于描述对象的结构。接口可以包含属性、方法和索引签名等。
   - 接口可以扩展其他接口，例如 `interface Student extends Person { grade: number; }`。

2. 实现接口：
   - `class Student implements Person { name: string; age: number; constructor(name: string, age: number) { this.name = name; this.age = age; } }`。一个类可以实现多个接口。

**五、类（class）**

1. 类的定义：
   - `class Animal { name: string; constructor(name: string) { this.name = name; } }`。类可以包含属性、构造函数和方法等。
   - 类可以使用访问修饰符 `public`、`private` 和 `protected` 来控制成员的可见性。

2. 继承：
   - `class Dog extends Animal { bark() { console.log('Woof!'); } }`。子类可以继承父类的属性和方法，并可以添加自己的特性。

3. 静态成员：
   - 类可以拥有静态属性和方法，通过 `类名.静态成员名` 来访问，例如 `class MathUtils { static add(a: number, b: number): number { return a + b; } }`。

**六、泛型（generics）**

1. 泛型函数：
   - `function identity<T>(arg: T): T { return arg; }`。泛型函数可以接受不同类型的参数，并返回相同类型的值。
   - 可以为泛型函数添加多个类型参数，例如 `function swap<T, U>(a: T, b: U): [U, T] { return [b, a]; }`。

2. 泛型类：
   - `class GenericClass<T> { value: T; constructor(value: T) { this.value = value; } }`。泛型类可以根据不同的类型参数进行实例化。

3. 泛型接口：
   - `interface GenericInterface<T> { doSomething(value: T): void; }`。泛型接口定义了具有通用类型参数的接口结构。

**七、模块（modules）**

1. 使用 `import` 和 `export` 进行模块导入和导出：
   - `export function add(a: number, b: number): number { return a + b; }`，在另一个文件中使用 `import { add } from './moduleName';` 导入。
   - 可以使用默认导出和命名导出的组合，例如 `export default class MyClass {... }` 和 `export function myFunction() {... }`。

**八、联合类型（Union Types）**

联合类型允许一个变量可以是多种类型中的一种。例如：

let value: number | string = 10;
value = "hello";

function printValue(val: number | string) {
    if (typeof val === 'number') {
        console.log(`The number is ${val}`);
    } else {
        console.log(`The string is ${val}`);
    }
}

**九、交叉类型（Intersection Types）**

交叉类型是将多个类型合并为一个类型，这个新类型具有所有原始类型的特性。例如：

interface Person {
    name: string;
}

interface Employee {
    company: string;
}

type PersonEmployee = Person & Employee;

let personEmployee: PersonEmployee = {
    name: "John",
    company: "ABC Inc."
};

交叉类型可以用于扩展现有类型，或者组合多个接口的特性。

**十、类型断言**

类型断言是一种告诉编译器你比它更了解某个值的类型的方式。有两种形式：`<类型>值` 和 `值 as 类型`。例如：

let someValue: any = "hello";
let strLength: number = (<string>someValue).length;
// 或者
let strLength: number = (someValue as string).length;

**十一、字面量类型**

字面量类型是指具体的值作为类型，例如 `let color: "red" | "blue" | "green" = "red";`。字面量类型可以与联合类型和类型守卫一起使用，以实现更严格的类型控制。

**十二、类型别名**

可以使用 `type` 关键字创建类型别名，以便更好地组织和重用复杂的类型定义。例如：

type Point = { x: number; y: number };

let p: Point = { x: 10, y: 20 };