typescript

类型推断（Type Inference）:

TypeScript 会自动尝试根据上下文推断变量的类型。如果变量的声明和初始化是在同一行进行的，TypeScript 通常能推断出变量的类型。

let message = "Hello, TypeScript!";
// 这里 TypeScript 会推断出 message 的类型是 string

类型注解（Type Annotations）:

当类型推断不起作用或者我们需要明确指定变量的类型时，可以使用类型注解。

let age: number;
age = 25;
// 这里我们明确指定了 age 的类型是 number

类型断言（Type Assertions）:

类型断言可以用来手动指定一个值的类型。这通常在处理可能比 TypeScript 更了解某个值的类型时使用。
有两种方式来使用类型断言：

• angle-bracket 语法（尖括号语法）:

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

• as 语法:

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

在这三个示例中，你可以看到 TypeScript 如何通过不同的方式来处理类型。类型推断让开发者不必总是显式地声明类型，而类型注解和类型断言则提供了更多的控制和明确性。

联合类型

联合类型允许你指定一个变量可以是多个类型中的一个。在这个例子中，变量 v4 被声明为可以是 string 类型或者 number 类型。这意味着 v4 可以被赋值为一个字符串或者一个数字，但不能是其他类型。
例如：

let v4: string | number = 10; // 正确，v4 是一个 number
v4 = "Hello"; // 也正确，现在 v4 是一个 string
v4 = true; // 错误，v4 不能是 boolean 类型

联合类型是 TypeScript 中非常有用的特性，它允许你创建更加灵活和可重用的代码。
元组（Tuple）是一种特殊类型的数组，它允许你存储不同类型的元素。与普通数组不同，元组中的每个元素都有一个预期的类型，且数量是固定的。这使得元组在处理固定数量和类型的元素时非常有用。

元组（Tuple）

元组的特点
固定长度：一旦定义了元组的长度和每个位置的类型，就不能添加或删除元素。
类型明确：每个位置的类型在创建元组时就已经确定。
示例代码

// 定义一个元组，包含一个 string 和一个 number
let tuple: [string, number] = ["hello", 10];
// 访问元组中的元素
console.log(tuple[0]); // 输出 "hello"
console.log(tuple[1]); // 输出 10
// 错误的赋值
// tuple[2] = true; // 错误，因为元组只有两个元素
// 正确的赋值
tuple = ["world", 20]; // 正确，两个元素的类型分别是 string 和 number




// 定义一个元组，包含一个 string 和一个可选的 number
let tuple: [string, number?] = ["hello"];
// 访问元组中的元素
console.log(tuple[0]); // 输出 "hello"
// console.log(tuple[1]); // 可能会输出 undefined，因为它是可选的
// 正确的赋值
tuple = ["world", 20]; // 正确，两个元素的类型分别是 string 和 number
tuple = ["another string"]; // 也正确，因为 number 是可选的
// 错误的赋值
// tuple = [20, "hello"]; // 错误，第一个元素必须是 string

枚举

枚举（Enum）是 TypeScript 中的一种数据类型，允许我们为一组数值赋予友好的名字。

enum Direction {
    Up = 1,
    Down,
    Left,
    Right
}

在这个 Direction 枚举中，Up 的初始值为 1，其余的成员会从 1 开始自动增长。也就是说 Down 的值为 2，Left 的值为 3，Right 的值为 4。
你可以像这样访问枚举的值：

let dir: Direction = Direction.Up;

你也可以根据枚举的值获取其对应的名字：

let dirName: string = Direction[1]; // "Up"

函数

函数是 TypeScript 中的基本组成部分，用于执行特定任务或计算值。以下是一个简单的 TypeScript 函数示例：

function buildName(firstName: string, lastName?: string, ...extras: string[]): string {
    let fullName = firstName;

    if (lastName) {
        fullName += " " + lastName;
    }

    if (extras.length > 0) {
        fullName += " " + extras.join(" ");
    }

    return fullName;
}

console.log(buildName("John", "Doe", "Sr.", "PhD")); // 输出 "John Doe Sr. PhD"
//firstName 是一个必需参数，lastName 是一个可选参数，extras 是一个 ...rest 参数，
//可以接受任意数量的额外参数。函数的返回值类型为 string。

接口（Interface）

接口（Interface）是 TypeScript 中的一个重要概念，它是一种强大的方式来定义代码中的结构，使得开发更加灵活和安全。
下面是一个简单的 TypeScript 接口示例：

interface Person {
    firstName: string;
    lastName: string;
    age?: number; // 这是一个可选属性
}

function greet(person: Person) {
    let greeting = "Hello, " + person.firstName + " " + person.lastName;

    if (person.age) {
        greeting += ". You are " + person.age + " years old.";
    }

    return greeting;
}

let user = {firstName: "John", lastName: "Doe", age: 25};

console.log(greet(user)); // 输出 "Hello, John Doe. You are 25 years old."

在这个示例中，Person 是一个接口，它定义了一个对象应该有哪些属性，以及这些属性的类型。greet 函数的参数 person 的类型就是 Person 接口，这意味着我们传递给 greet 函数的参数必须符合 Person 接口的结构。Person 接口有一个 age 属性，它是可选的。这意味着如果一个对象符合 Person 接口，那么它可以有也可以没有 age 属性。

类型别名（Type Aliases）

类型别名（Type Aliases）是 TypeScript 中的一个重要概念，它允许我们为任何类型创建一个新名字。
下面是一个简单的 TypeScript 类型别名示例：

type StringOrNumber = string | number;

function print(input: StringOrNumber) {
    console.log(input);
}

print("Hello"); // 输出 "Hello"
print(123);     // 输出 123

在这个示例中，StringOrNumber 是一个类型别名，它表示一个值可以是 string 类型或者 number 类型。print 函数的参数 input 的类型就是 StringOrNumber 类型别名，这意味着我们传递给 print 函数的参数可以是字符串或者数字。

泛型（Generics）

泛型（Generics）是 TypeScript 中的一个重要概念，它允许我们创建可重用的组件，这些组件可以在多种类型上工作，而不仅仅是单一的类型。
下面是一个简单的 TypeScript 泛型示例：

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

let output1 = identity<string>("myString");  // 类型为 'string'
let output2 = identity(100);  // 类型为 'number'，可以省略的原因是类型推断

在这个示例中，identity 是一个泛型函数，T 是一个类型变量，它代表任何类型。你可以像这样调用 identity 函数，并为 T 提供具体的类型：