TS-语法介绍

1. 基本语法

变量声明

TypeScript 中的变量声明方式有 let、const 和 var，推荐使用 let 和 const。

let isDone: boolean = false;
const PI: number = 3.14;

函数

函数声明与 JavaScript 类似，但可以指定参数和返回值类型。

function add(x: number, y: number): number {
    return x + y;
}

解构赋值

解构赋值允许从数组或对象中提取值，分别赋给不同的变量。

let [a, b] = [1, 2];
let { name, age } = { name: "John", age: 30 };

展开运算符

展开运算符可以用于数组和对象。

let arr = [1, 2, 3];
let newArr = [...arr, 4, 5];

let obj = { name: "John", age: 30 };
let newObj = { ...obj, location: "USA" };

2. 类型系统

基本类型

TypeScript 提供了丰富的基本类型，包括 boolean、number、string、array、tuple、enum、any、void、null、undefined 和 never。

let isDone: boolean = false;
let age: number = 30;
let userName: string = "John";
let numbers: number[] = [1, 2, 3];
let tuple: [string, number] = ["John", 30];
enum Color {Red, Green, Blue}
let color: Color = Color.Green;

联合类型

联合类型表示一个值可以是几种类型之一。

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

交叉类型

交叉类型将多个类型合并为一个类型，包含了所需的所有类型特性。

interface Person {
    name: string;
}

interface Employee {
    employeeId: number;
}

type EmployeePerson = Person & Employee;

let emp: EmployeePerson = {
    name: "John",
    employeeId: 1234
};

类型别名

类型别名可以为任意类型创建新名称。

type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;

function getName(n: NameOrResolver): Name {
    if (typeof n === "string") {
        return n;
    } else {
        return n();
    }
}

类型断言

类型断言有两种形式：尖括号语法和 as 语法。

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

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

3. 接口

接口用于定义对象的类型。

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

let john: Person = { name: "John", age: 30 };

接口还可以描述函数类型和可索引类型。

interface SearchFunc {
    (source: string, subString: string): boolean;
}

let mySearch: SearchFunc;
mySearch = function (src: string, sub: string): boolean {
    return src.search(sub) !== -1;
};

4. 类

类是 TypeScript 中的核心概念，用于定义对象的蓝图。

class Person {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    greet() {
        console.log(`Hello, my name is ${this.name}`);
    }
}

let john = new Person("John");
john.greet();

继承

类可以通过继承来复用代码。

class Employee extends Person {
    employeeId: number;
    constructor(name: string, employeeId: number) {
        super(name);
        this.employeeId = employeeId;
    }
    work() {
        console.log(`${this.name} is working`);
    }
}

let emp = new Employee("John", 1234);
emp.greet();
emp.work();

接口与类

类可以实现接口，从而强制类遵循接口的结构。

interface IPerson {
    name: string;
    greet(): void;
}

class Person implements IPerson {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    greet() {
        console.log(`Hello, my name is ${this.name}`);
    }
}

修饰符

TypeScript 支持访问修饰符：public（默认）、private 和 protected。

class Person {
    public name: string;
    private age: number;
    protected gender: string;
    constructor(name: string, age: number, gender: string) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

5. 泛型

泛型使得函数和类可以处理不特定的类型，从而更具复用性。

function identity<T>(arg: T): T {
    return arg;
}

let output1 = identity<string>("myString");
let output2 = identity<number>(100);

泛型类和泛型接口也广泛应用于 TypeScript。

class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function (x, y) {
    return x + y;
};

6. 模块

模块是 TypeScript 中组织代码的主要方式，使用 import 和 export 关键字。

// math.ts
export function add(x: number, y: number): number {
    return x + y;
}

// app.ts
import { add } from './math';
console.log(add(2, 3));

7. 命名空间

命名空间用于在一个文件中组织代码，防止全局作用域污染。

namespace Validation {
    export interface StringValidator {
        isAcceptable(s: string): boolean;
    }

    export const lettersRegexp = /^[A-Za-z]+$/;
}

// 使用命名空间
let validator: Validation.StringValidator;
validator = { isAcceptable: s => Validation.lettersRegexp.test(s) };

8. 装饰器

装饰器是一种特殊的声明，附加在类声明、方法、访问符、属性或参数上。需要在 tsconfig.json 中启用 experimentalDecorators。

function sealed(constructor: Function) {
    Object.seal(constructor);
    Object.seal(constructor.prototype);
}

@sealed
class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return `Hello, ${this.greeting}`;
    }
}