TypeScript复合类型与高级语法详解

// 方式一：类型[]
let 变量名: 类型[] = [值1, 值2, ...];

// 方式二：Array<类型>
let 变量名: Array<类型> = [值1, 值2, ...];

// 数字数组
let numbers: number[] = [1, 2, 3, 4, 5];
let scores: Array<number> = [85, 90, 95, 100];

// 字符串数组
let names: string[] = ["John", "Jane", "Bob"];
let fruits: Array<string> = ["apple", "banana", "orange"];

// 布尔数组
let flags: boolean[] = [true, false, true, true];

// 对象数组
interface Person {
    name: string;
    age: number;
}

let people: Person[] = [
    { name: "John", age: 30 },
    { name: "Jane", age: 25 },
    { name: "Bob", age: 35 }
];

// 数组操作
numbers.push(6); // 添加元素
numbers.pop(); // 删除最后一个元素
numbers.unshift(0); // 在开头添加元素
numbers.shift(); // 删除第一个元素

// 数组方法
const doubledNumbers = numbers.map(num => num * 2);
const evenNumbers = numbers.filter(num => num % 2 === 0);
const sum = numbers.reduce((total, num) => total + num, 0);

console.log(numbers); // 输出: [1, 2, 3, 4, 5]
console.log(doubledNumbers); // 输出: [2, 4, 6, 8, 10]
console.log(evenNumbers); // 输出: [2, 4]
console.log(sum); // 输出: 15

// 使用接口定义对象类型
interface 接口名 {
    属性名1: 类型;
    属性名2?: 类型; // 可选属性
    readonly 属性名3: 类型; // 只读属性
    [key: string]: 类型; // 索引签名（允许任意属性）
}

// 使用类型别名定义对象类型
type 类型名 = {
    属性名1: 类型;
    属性名2?: 类型;
    readonly 属性名3: 类型;
    [key: string]: 类型;
};

// 使用对象字面量创建对象
let 变量名: 类型 = {
    属性名1: 值1,
    属性名3: 值3,
    // 可选属性可以省略
};

// 使用接口定义对象类型
interface User {
    id: number;
    name: string;
    email: string;
    age?: number; // 可选属性
    readonly createdAt: Date; // 只读属性
}

// 创建User类型的对象
const user: User = {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com",
    createdAt: new Date()
};

console.log(user.name); // 输出: John Doe
user.age = 30; // 可以设置可选属性
// user.id = 2; // 编译错误：无法修改只读属性

// 使用索引签名允许任意属性
interface Config {
    timeout: number;
    retries: number;
    [key: string]: any; // 允许任意其他属性
}

const appConfig: Config = {
    timeout: 3000,
    retries: 3,
    debug: true, // 额外属性
    baseUrl: "https://api.example.com" // 额外属性
};

// 使用类型别名定义对象类型
type Point = {
    x: number;
    y: number;
    z?: number;
};

const point2D: Point = { x: 10, y: 20 };
const point3D: Point = { x: 10, y: 20, z: 30 };

let 变量名: 类型1 | 类型2 | ... = 值;

// 基本联合类型
let value: string | number | boolean;

value = "hello";
value = 42;
value = true;

// 联合类型的实际应用
function printId(id: number | string) {
    console.log(`ID: ${id}`);
}

printId(123); // 输出: ID: 123
printId("ABC123"); // 输出: ID: ABC123

// 联合类型与数组
let mixedArray: (string | number)[] = [1, "two", 3, "four"];

// 联合类型与对象
interface Dog {
    type: "dog";
    name: string;
    breed: string;
}

interface Cat {
    type: "cat";
    name: string;
    color: string;
}

type Pet = Dog | Cat;

function feedPet(pet: Pet) {
    if (pet.type === "dog") {
        console.log(`Feeding ${pet.name} the ${pet.breed} dog.`);
    } else {
        console.log(`Feeding ${pet.name} the ${pet.color} cat.`);
    }
}

const rover: Dog = { type: "dog", name: "Rover", breed: "Golden Retriever" };
const whiskers: Cat = { type: "cat", name: "Whiskers", color: "Gray" };

feedPet(rover); // 输出: Feeding Rover the Golden Retriever dog.
feedPet(whiskers); // 输出: Feeding Whiskers the Gray cat.

let 变量名: 类型1 & 类型2 & ... = 值;

// 定义两个接口
interface Person {
    name: string;
    age: number;
}

interface Employee {
    employeeId: number;
    department: string;
}

// 交叉类型：EmployeePerson同时具有Person和Employee的特性
type EmployeePerson = Person & Employee;

let employee: EmployeePerson = {
    name: "Jane Smith",
    age: 30,
    employeeId: 12345,
    department: "Engineering"
};

// 交叉类型与类型别名
type Logger = {
    log: (message: string) => void;
};

type Validator = {
    validate: (data: any) => boolean;
};

type LoggingValidator = Logger & Validator;

const loggingValidator: LoggingValidator = {
    log: (message) => console.log(`[LOG]: ${message}`),
    validate: (data) => {
        const isValid = data !== undefined && data !== null;
        if (!isValid) {
            this.log("Data validation failed");
        }
        return isValid;
    }
};

loggingValidator.log("Starting validation");
const isValid = loggingValidator.validate(42);
console.log(`Is data valid? ${isValid}`);

// 方式一：使用尖括号语法（在JSX中不适用）
let 变量名 = <类型>值;

// 方式二：使用as语法（推荐使用）
let 变量名 = 值 as 类型;

// 基本类型断言
let value: any = "hello";
let length1: number = (<string>value).length;
let length2: number = (value as string).length;

console.log(length1); // 输出: 5
console.log(length2); // 输出: 5

// 对象类型断言
interface Person {
    name: string;
    age: number;
}

let obj: any = { name: "John", age: 30 };
let person1 = <Person>obj;
let person2 = obj as Person;

console.log(person1.name); // 输出: John
console.log(person2.age); // 输出: 30

// 类型断言与联合类型
function getLength(value: string | number): number {
    // 类型断言告诉TypeScript编译器，这里的value是string类型
    if ((value as string).length !== undefined) {
        return (value as string).length;
    } else {
        return value.toString().length;
    }
}

console.log(getLength("hello")); // 输出: 5
console.log(getLength(12345)); // 输出: 5

// 非空断言（!操作符）
function printMessage(message?: string) {
    // 非空断言告诉TypeScript编译器，message一定不是undefined或null
    console.log(message!.toUpperCase());
}

printMessage("hello"); // 输出: HELLO
// printMessage(); // 运行时错误：Cannot read property 'toUpperCase' of undefined

function processValue(value: string | number | boolean) {
    if (typeof value === "string") {
        // 在这个代码块中，TypeScript知道value是string类型
        console.log(`String value: ${value.toUpperCase()}`);
    } else if (typeof value === "number") {
        // 在这个代码块中，TypeScript知道value是number类型
        console.log(`Number value: ${value.toFixed(2)}`);
    } else {
        // 在这个代码块中，TypeScript知道value是boolean类型
        console.log(`Boolean value: ${value ? "true" : "false"}`);
    }
}

processValue("hello"); // 输出: String value: HELLO
processValue(42); // 输出: Number value: 42.00
processValue(true); // 输出: Boolean value: true

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}

class Dog extends Animal {
    breed: string;
    constructor(name: string, breed: string) {
        super(name);
        this.breed = breed;
    }
}

class Cat extends Animal {
    color: string;
    constructor(name: string, color: string) {
        super(name);
        this.color = color;
    }
}

function describeAnimal(animal: Animal) {
    if (animal instanceof Dog) {
        // 在这个代码块中，TypeScript知道animal是Dog类型
        console.log(`Dog: ${animal.name}, Breed: ${animal.breed}`);
    } else if (animal instanceof Cat) {
        // 在这个代码块中，TypeScript知道animal是Cat类型
        console.log(`Cat: ${animal.name}, Color: ${animal.color}`);
    } else {
        console.log(`Animal: ${animal.name}`);
    }
}

const rover = new Dog("Rover", "Golden Retriever");
const whiskers = new Cat("Whiskers", "Gray");
const genericAnimal = new Animal("Generic Animal");

describeAnimal(rover); // 输出: Dog: Rover, Breed: Golden Retriever
describeAnimal(whiskers); // 输出: Cat: Whiskers, Color: Gray
describeAnimal(genericAnimal); // 输出: Animal: Generic Animal

interface Dog {
    type: "dog";
    name: string;
    breed: string;
}

interface Cat {
    type: "cat";
    name: string;
    color: string;
}

type Pet = Dog | Cat;

function describePet(pet: Pet) {
    if ("breed" in pet) {
        // 在这个代码块中，TypeScript知道pet是Dog类型
        console.log(`Dog: ${pet.name}, Breed: ${pet.breed}`);
    } else {
        // 在这个代码块中，TypeScript知道pet是Cat类型
        console.log(`Cat: ${pet.name}, Color: ${pet.color}`);
    }
}

const rover: Dog = { type: "dog", name: "Rover", breed: "Golden Retriever" };
const whiskers: Cat = { type: "cat", name: "Whiskers", color: "Gray" };

describePet(rover); // 输出: Dog: Rover, Breed: Golden Retriever
describePet(whiskers); // 输出: Cat: Whiskers, Color: Gray

interface User {
    id: number;
    name: string;
    email: string;
}

interface Admin {
    id: number;
    name: string;
    role: string;
}

type UserOrAdmin = User | Admin;

// 自定义类型守卫函数
function isAdmin(user: UserOrAdmin): user is Admin {
    return "role" in user;
}

function handleUser(user: UserOrAdmin) {
    if (isAdmin(user)) {
        // 在这个代码块中，TypeScript知道user是Admin类型
        console.log(`Admin user: ${user.name}, Role: ${user.role}`);
    } else {
        // 在这个代码块中，TypeScript知道user是User类型
        console.log(`Regular user: ${user.name}, Email: ${user.email}`);
    }
}

const regularUser: User = { id: 1, name: "John Doe", email: "john.doe@example.com" };
const adminUser: Admin = { id: 2, name: "Jane Smith", role: "Administrator" };

handleUser(regularUser); // 输出: Regular user: John Doe, Email: john.doe@example.com
handleUser(adminUser); // 输出: Admin user: Jane Smith, Role: Administrator

function 函数名<T>(参数: T): T {
    // 函数体
}

// 简单的泛型函数
function identity<T>(arg: T): T {
    return arg;
}

// 调用泛型函数，显式指定类型参数
const result1 = identity<string>("hello");
console.log(result1); // 输出: hello

// 调用泛型函数，TypeScript会自动推断类型参数
const result2 = identity(42);
console.log(result2); // 输出: 42

// 泛型函数的实际应用：创建一个数组
function createArray<T>(length: number, value: T): T[] {
    return Array(length).fill(value);
}

const stringArray = createArray<string>(3, "hello");
console.log(stringArray); // 输出: ["hello", "hello", "hello"]

const numberArray = createArray<number>(5, 0);
console.log(numberArray); // 输出: [0, 0, 0, 0, 0]

// 多个类型参数的泛型函数
function pair<T, U>(first: T, second: U): [T, U] {
    return [first, second];
}

const mixedPair = pair("hello", 42);
console.log(mixedPair); // 输出: ["hello", 42]

interface 接口名<T> {
    属性: T;
    方法: (参数: T) => T;
}

// 简单的泛型接口
interface Box<T> {
    content: T;
}

const stringBox: Box<string> = { content: "hello" };
const numberBox: Box<number> = { content: 42 };

// 泛型接口的实际应用：定义一个容器接口
interface Container<T> {
    getItem: () => T;
    setItem: (item: T) => void;
    hasItem: () => boolean;
}

class SimpleContainer<T> implements Container<T> {
    private item: T | null = null;
    
    getItem(): T {
        if (!this.hasItem()) {
            throw new Error("No item in container");
        }
        return this.item as T;
    }
    
    setItem(item: T): void {
        this.item = item;
    }
    
    hasItem(): boolean {
        return this.item !== null;
    }
}

const stringContainer = new SimpleContainer<string>();
stringContainer.setItem("hello");
console.log(stringContainer.getItem()); // 输出: hello
console.log(stringContainer.hasItem()); // 输出: true

const numberContainer = new SimpleContainer<number>();
console.log(numberContainer.hasItem()); // 输出: false

class 类名<T> {
    属性: T;
    
    constructor(参数: T) {
        this.属性 = 参数;
    }
    
    方法(): T {
        return this.属性;
    }
}

// 简单的泛型类
class Box<T> {
    private content: T;
    
    constructor(content: T) {
        this.content = content;
    }
    
    getContent(): T {
        return this.content;
    }
    
    setContent(content: T): void {
        this.content = content;
    }
}

const stringBox = new Box<string>("hello");
console.log(stringBox.getContent()); // 输出: hello
stringBox.setContent("world");
console.log(stringBox.getContent()); // 输出: world

const numberBox = new Box<number>(42);
console.log(numberBox.getContent()); // 输出: 42

// 泛型类的实际应用：定义一个队列
class Queue<T> {
    private items: T[] = [];
    
    enqueue(item: T): void {
        this.items.push(item);
    }
    
    dequeue(): T | undefined {
        return this.items.shift();
    }
    
    peek(): T | undefined {
        return this.items[0];
    }
    
    size(): number {
        return this.items.length;
    }
    
    isEmpty(): boolean {
        return this.items.length === 0;
    }
}

const queue = new Queue<string>();
queue.enqueue("first");
queue.enqueue("second");
queue.enqueue("third");

console.log(queue.size()); // 输出: 3
console.log(queue.peek()); // 输出: first
console.log(queue.dequeue()); // 输出: first
console.log(queue.size()); // 输出: 2

interface 约束接口 {
    属性: 类型;
    方法: () => 类型;
}

function 函数名<T extends 约束接口>(参数: T): T {
    // 函数体
}

// 定义一个约束接口
interface Lengthwise {
    length: number;
}

// 使用泛型约束
function logLength<T extends Lengthwise>(arg: T): void {
    console.log(`Length: ${arg.length}`);
}

logLength("hello"); // 输出: Length: 5
logLength([1, 2, 3]); // 输出: Length: 3
logLength({ length: 10 }); // 输出: Length: 10
// logLength(42); // 编译错误：number类型没有length属性

// 多个泛型约束
function compare<T extends { name: string }, U extends T>(a: T, b: U): void {
    console.log(`${a.name} vs ${b.name}`);
}

interface Person { name: string; age: number; }
interface Employee extends Person { employeeId: number; }

const person: Person = { name: "John", age: 30 };
const employee: Employee = { name: "Jane", age: 25, employeeId: 12345 };

compare(person, employee); // 输出: John vs Jane
compare(employee, employee); // 输出: Jane vs Jane

// 泛型约束与keyof操作符
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user = {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com"
};

console.log(getProperty(user, "name")); // 输出: John Doe
console.log(getProperty(user, "email")); // 输出: john.doe@example.com
// console.log(getProperty(user, "age")); // 编译错误：'age'不是user的属性

// 定义一个基本接口
interface User {
    id: number;
    name: string;
    email: string;
    age?: number;
}

// Readonly<T>：将所有属性设为只读
const readonlyUser: Readonly<User> = {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com"
};
// readonlyUser.name = "Jane Doe"; // 编译错误：属性只读

// Partial<T>：将所有属性设为可选
const partialUser: Partial<User> = {
    name: "John Doe"
};

// Required<T>：将所有可选属性设为必填
const requiredUser: Required<User> = {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com",
    age: 30 // age现在是必填属性
};

// Pick<T, K>：从T中选择指定的属性K
const pickedUser: Pick<User, "id" | "name"> = {
    id: 1,
    name: "John Doe"
};

// Record<K, T>：创建一个以K为键、T为值的类型
const userRoles: Record<string, "admin" | "user" | "guest"> = {
    "john.doe@example.com": "admin",
    "jane.smith@example.com": "user",
    "guest@example.com": "guest"
};

// Exclude<T, U>：从T中排除可以赋值给U的类型
type Primitive = string | number | boolean;
type NonStringPrimitive = Exclude<Primitive, string>; // number | boolean

// Extract<T, U>：从T中提取可以赋值给U的类型
type StringOrNumber = string | number | boolean;
type StringOrNumberOnly = Extract<StringOrNumber, string | number>; // string | number

// Omit<T, K>：从T中排除指定的属性K
const omittedUser: Omit<User, "age"> = {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com"
};

type 映射类型名<T> = {
    [P in keyof T]: 转换后的类型;
};

// 定义一个基本接口
interface User {
    id: number;
    name: string;
    email: string;
}

// 自定义映射类型：将所有属性的类型设为string
type Stringify<T> = {
    [P in keyof T]: string;
};

const stringifiedUser: Stringify<User> = {
    id: "1", // 注意：这里的id类型是string
    name: "John Doe",
    email: "john.doe@example.com"
};

// 自定义映射类型：将所有属性设为只读并可选
type ReadonlyPartial<T> = {
    readonly [P in keyof T]?: T[P];
};

const readonlyPartialUser: ReadonlyPartial<User> = {
    name: "John Doe"
};
// readonlyPartialUser.name = "Jane Doe"; // 编译错误：属性只读

// 自定义映射类型：为每个属性添加getter和setter
type Accessor<T> = {
    [P in keyof T]: {
        get: () => T[P];
        set: (value: T[P]) => void;
    };
};

// 这个类型会生成类似以下的结构
// interface UserAccessor {
//     id: { get: () => number; set: (value: number) => void; };
//     name: { get: () => string; set: (value: string) => void; };
//     email: { get: () => string; set: (value: string) => void; };
// }

type 条件类型名<T> = T extends U ? X : Y;

// 简单的条件类型
type IsString<T> = T extends string ? true : false;

type A = IsString<string>; // true

// 条件类型的实际应用：根据输入类型选择返回类型
function process<T>(input: T): T extends string ? string[] : number[] {
    if (typeof input === "string") {
        return input.split("") as any; // 类型断言是必要的
    } else {
        return [input as any] as any; // 类型断言是必要的
    }
}

const result1 = process("hello"); // string[]类型
console.log(result1); // 输出: ["h", "e", "l", "l", "o"]

const result2 = process(42); // number[]类型
console.log(result2); // 输出: [42]

// 条件类型与泛型约束
interface Animal { name: string; }
interface Dog extends Animal { breed: string; }
interface Cat extends Animal { color: string; }

type GetBreed<T> = T extends Dog ? T["breed"] : never;
type GetColor<T> = T extends Cat ? T["color"] : never;

const dog: Dog = { name: "Rover", breed: "Golden Retriever" };
const cat: Cat = { name: "Whiskers", color: "Gray" };

function getBreed<T extends Animal>(animal: T): GetBreed<T> {
    return (animal as Dog).breed as any;
}

function getColor<T extends Animal>(animal: T): GetColor<T> {
    return (animal as Cat).color as any;
}

// 条件类型的分配特性
// 当条件类型的类型参数是联合类型时，条件类型会对联合类型的每个成员应用，然后将结果联合起来

type ToArray<T> = T extends any ? T[] : never;

type StringArray = ToArray<string>; // string[]
type NumberArray = ToArray<number>; // number[]
type StringOrNumberArray = ToArray<string | number>; // string[] | number[]

// 使用never和infer实现类型提取
type Flatten<T> = T extends Array<infer U> ? U : T;

type FlattenedStringArray = Flatten<string[]>; // string
type FlattenedNumber = Flatten<number>; // number

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

function add(a: number, b: number): number {
    return a + b;
}

function greet(name: string): string {
    return `Hello, ${name}!`;
}

type AddReturnType = ReturnType<typeof add>; // number
type GreetReturnType = ReturnType<typeof greet>; // string

interface User {
    id: number;
    name: string;
    email: string;
}

type UserKeys = keyof User; // "id" | "name" | "email"

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user: User = {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com"
};

console.log(getProperty(user, "name")); // 输出: John Doe
console.log(getProperty(user, "email")); // 输出: john.doe@example.com
// console.log(getProperty(user, "age")); // 编译错误：'age'不是User的属性

interface User {
    id: number;
    name: string;
    email: string;
    address: {
        street: string;
        city: string;
        country: string;
    };
    roles: string[];
}

// 获取单个属性的类型
type UserIdType = User["id"]; // number
type UserNameType = User["name"]; // string

// 获取嵌套属性的类型
type UserStreetType = User["address"]["street"]; // string

// 获取数组元素的类型
type UserRoleType = User["roles"][number]; // string

// 使用联合类型获取多个属性的类型
type UserNameOrEmailType = User["name" | "email"]; // string

// 使用keyof获取所有属性的类型
type UserPropertyType = User[keyof User]; // number | string | { street: string; city: string; country: string; } | string[]

interface User {
    id: number;
    name: string;
    email: string;
}

// 将对象类型的所有属性转换为可空类型
type Nullable<T> = {
    [P in keyof T]: T[P] | null;
};

const nullableUser: Nullable<User> = {
    id: 1,
    name: null,
    email: "john.doe@example.com"
};

// 将对象类型的所有属性转换为Promise类型
type Promiseify<T> = {
    [P in keyof T]: Promise<T[P]>;
};

const promiseUser: Promiseify<User> = {
    id: Promise.resolve(1),
    name: Promise.resolve("John Doe"),
    email: Promise.resolve("john.doe@example.com")
};

// 使用条件类型和索引类型创建类型选择器
type SelectProps<T, U> = {
    [P in keyof T]: T[P] extends U ? P : never;
}[keyof T];

// SelectProps<User, string> 会返回 "name" | "email"
const stringProps: SelectProps<User, string>[] = ["name", "email"];

// 使用SelectProps创建只包含特定类型属性的新类型
type FilterByType<T, U> = Pick<T, SelectProps<T, U>>;

// FilterByType<User, string> 会返回 { name: string; email: string; }
const stringOnlyUser: FilterByType<User, string> = {
    name: "John Doe",
    email: "john.doe@example.com"
};

// 导出单个声明
export const 变量名 = 值;
export function 函数名() {};
export class 类名 {};
export interface 接口名 {};

export type 类型名 = {};

// 导出多个声明
export {
    变量名1,
    函数名1,
    类名1,
    接口名1,
    类型名1
};

// 导出默认值
export default 表达式;

// math.ts

// 导出单个函数
export function add(a: number, b: number): number {
    return a + b;
}

export function subtract(a: number, b: number): number {
    return a - b;
}

// 导出变量
export const PI = 3.14159;

// 导出接口
export interface Calculator {
    calculate(x: number, y: number): number;
}

// 导出类
export class BasicCalculator implements Calculator {
    calculate(x: number, y: number): number {
        return x + y;
    }
}

// 导出类型别名
export type MathOperation = (a: number, b: number) => number;

// 导出多个声明
const multiply: MathOperation = (a, b) => a * b;
const divide: MathOperation = (a, b) => a / b;

export { multiply, divide };

// 导出默认值
export default {
    add,
    subtract,
    multiply,
    divide,
    PI
};

// 导入单个声明
import { 声明名 } from "模块路径";

// 导入多个声明
import { 声明名1, 声明名2, ... } from "模块路径";

// 使用别名导入
import { 声明名 as 别名 } from "模块路径";

// 导入所有内容
import * as 模块名 from "模块路径";

// 导入默认值
import 默认导入名 from "模块路径";

// 混合导入
import 默认导入名, { 声明名1, 声明名2, ... } from "模块路径";

// app.ts

// 导入单个函数
import { add } from "./math";
console.log(add(10, 20)); // 输出: 30

// 导入多个声明
import { subtract, multiply, PI } from "./math";
console.log(subtract(20, 10)); // 输出: 10
console.log(multiply(5, 4)); // 输出: 20
console.log(PI); // 输出: 3.14159

// 使用别名导入
import { divide as div } from "./math";
console.log(div(20, 5)); // 输出: 4

// 导入接口和类
import { Calculator, BasicCalculator } from "./math";
const calculator: Calculator = new BasicCalculator();
console.log(calculator.calculate(10, 20)); // 输出: 30

// 导入类型别名
import { MathOperation } from "./math";
const power: MathOperation = (a, b) => Math.pow(a, b);
console.log(power(2, 3)); // 输出: 8

// 导入所有内容
import * as math from "./math";
console.log(math.add(10, 20)); // 输出: 30
console.log(math.PI); // 输出: 3.14159

// 导入默认值
import mathLib from "./math";
console.log(mathLib.add(10, 20)); // 输出: 30
console.log(mathLib.PI); // 输出: 3.14159

namespace 命名空间名 {
    // 命名空间内的代码
    export 声明名;
}

// shapes.ts

namespace Shapes {
    // 内部类型，不导出则无法在命名空间外部访问
    interface Point {
        x: number;
        y: number;
    }
    
    // 导出的接口
    export interface Circle {
        center: Point;
        radius: number;
    }
    
    export interface Rectangle {
        topLeft: Point;
        width: number;
        height: number;
    }
    
    // 导出的函数
    export function calculateCircleArea(circle: Circle): number {
        return Math.PI * circle.radius * circle.radius;
    }
    
    export function calculateRectangleArea(rectangle: Rectangle): number {
        return rectangle.width * rectangle.height;
    }
}

// 使用命名空间
const circle: Shapes.Circle = {
    center: { x: 0, y: 0 },
    radius: 5
};

const rectangle: Shapes.Rectangle = {
    topLeft: { x: 0, y: 0 },
    width: 10,
    height: 5
};

console.log(Shapes.calculateCircleArea(circle)); // 输出: 78.53981633974483
console.log(Shapes.calculateRectangleArea(rectangle)); // 输出: 50

// 嵌套命名空间
namespace Geometry {
    export namespace Shapes {
        export interface Triangle {
            a: { x: number; y: number };
            b: { x: number; y: number };
            c: { x: number; y: number };
        }
        
        export function calculateTriangleArea(triangle: Triangle): number {
            // 使用鞋带公式计算三角形面积
            const { a, b, c } = triangle;
            return Math.abs((a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2);
        }
    }
}

const triangle: Geometry.Shapes.Triangle = {
    a: { x: 0, y: 0 },
    b: { x: 10, y: 0 },
    c: { x: 5, y: 10 }
};

console.log(Geometry.Shapes.calculateTriangleArea(triangle)); // 输出: 50

// 导入相对路径模块
import { add } from "./math";

// 导入绝对路径模块（相对于项目根目录）
import { User } from "src/models/user";

// 导入Node.js内置模块
import * as fs from "fs";
import * as path from "path";

// 导入第三方模块
import * as _ from "lodash";
import axios from "axios";

{
    "compilerOptions": {
        "module": "commonjs", // 模块系统，可选值：commonjs, amd, umd, es2015, esnext等
        "moduleResolution": "node", // 模块解析策略，可选值：node, classic
        "baseUrl": ".", // 解析非相对模块导入的基础目录
        "paths": { // 模块路径映射
            "@models/*": ["src/models/*"],
            "@utils/*": ["src/utils/*"]
        }
    }
}

import { User } from "@models/user";
import { logger } from "@utils/logger";

type DeepReadonly<T> = T extends Function
    ? T
    : T extends object
    ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
    : T;

interface ComplexObject {
    name: string;
    age: number;
    address: {
        street: string;
        city: string;
        zipCode: number;
    };
    hobbies: string[];
    callback: () => void;
}

type ReadonlyComplexObject = DeepReadonly<ComplexObject>;

// src/types.ts

// 定义图书接口
export interface Book {
    id: string;
    title: string;
    author: string;
    publisher: string;
    publicationYear: number;
    pages: number;
    genre: string;
    isAvailable: boolean;
}

// 定义图书创建请求接口
export interface CreateBookRequest {
    title: string;
    author: string;
    publisher: string;
    publicationYear: number;
    pages: number;
    genre: string;
}

// 定义图书更新请求接口（使用Partial类型使所有属性变为可选）
export type UpdateBookRequest = Partial<Book>;

// 定义图书查询条件接口
export interface BookQuery {
    title?: string;
    author?: string;
    genre?: string;
    isAvailable?: boolean;
}

// 定义图书服务接口
export interface BookService {
    createBook(data: CreateBookRequest): Book;
    getBookById(id: string): Book | undefined;
    getAllBooks(query?: BookQuery): Book[];
    updateBook(id: string, data: UpdateBookRequest): Book | undefined;
    deleteBook(id: string): boolean;
    toggleAvailability(id: string): Book | undefined;
}

// src/bookService.ts

import { Book, CreateBookRequest, UpdateBookRequest, BookQuery, BookService } from './types';

// 实现图书服务
class BookServiceImpl implements BookService {
    private books: Book[] = [];
    
    // 生成唯一ID
    private generateId(): string {
        return Date.now().toString(36) + Math.random().toString(36).substr(2);
    }
    
    // 创建图书
    createBook(data: CreateBookRequest): Book {
        const book: Book = {
            ...data,
            id: this.generateId(),
            isAvailable: true
        };
        this.books.push(book);
        return book;
    }
    
    // 根据ID获取图书
    getBookById(id: string): Book | undefined {
        return this.books.find(book => book.id === id);
    }
    
    // 获取所有图书（支持查询条件）
    getAllBooks(query?: BookQuery): Book[] {
        if (!query) {
            return [...this.books];
        }
        
        return this.books.filter(book => {
            // 使用映射类型和索引类型检查每个查询条件
            return Object.entries(query).every(([key, value]) => {
                // 使用类型断言处理动态属性访问
                return book[key as keyof Book] === value;
            });
        });
    }
    
    // 更新图书
    updateBook(id: string, data: UpdateBookRequest): Book | undefined {
        const bookIndex = this.books.findIndex(book => book.id === id);
        if (bookIndex === -1) {
            return undefined;
        }
        
        // 创建更新后的图书对象（不允许更新ID）
        const updatedBook: Book = {
            ...this.books[bookIndex],
            ...data,
            id: this.books[bookIndex].id // 保留原始ID
        };
        
        this.books[bookIndex] = updatedBook;
        return updatedBook;
    }
    
    // 删除图书
    deleteBook(id: string): boolean {
        const initialLength = this.books.length;
        this.books = this.books.filter(book => book.id !== id);
        return this.books.length < initialLength;
    }
    
    // 切换图书可用性
    toggleAvailability(id: string): Book | undefined {
        const book = this.getBookById(id);
        if (!book) {
            return undefined;
        }
        
        return this.updateBook(id, { isAvailable: !book.isAvailable });
    }
}

// 导出图书服务实例
export const bookService: BookService = new BookServiceImpl();

// src/index.ts

import * as readline from 'readline';
import { bookService } from './bookService';
import { CreateBookRequest } from './types';

// 创建readline接口
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 显示帮助信息的函数
function displayHelp(): void {
    console.log("\n图书管理系统使用说明:");
    console.log("1. 添加图书: add <标题>,<作者>,<出版社>,<出版年份>,<页数>,<类型>");
    console.log("   例如: add 三体,刘慈欣,重庆出版社,2008,302,科幻");
    console.log("2. 查找图书: find <ID>");
    console.log("3. 列出所有图书: list");
    console.log("4. 按条件查询图书: query <条件>");
    console.log("   例如: query 类型=科幻");
    console.log("         query 作者=刘慈欣,可用=true");
    console.log("5. 更新图书: update <ID> <属性=值>");
    console.log("   例如: update abc123 页数=305");
    console.log("6. 删除图书: delete <ID>");
    console.log("7. 切换图书可用性: toggle <ID>");
    console.log("8. 显示帮助信息: help");
    console.log("9. 退出应用: exit\n");
}

// 格式化显示图书信息的函数
function formatBook(book: any): string {
    return `ID: ${book.id}\n` +
           `标题: ${book.title}\n` +
           `作者: ${book.author}\n` +
           `出版社: ${book.publisher}\n` +
           `出版年份: ${book.publicationYear}\n` +
           `页数: ${book.pages}\n` +
           `类型: ${book.genre}\n` +
           `可用状态: ${book.isAvailable ? '可借阅' : '已借出'}\n`;
}

// 处理用户输入的函数
function handleInput(input: string): void {
    const [command, ...args] = input.trim().split(' ');
    
    switch (command.toLowerCase()) {
        case 'add':
            if (args.length === 0) {
                console.log("请输入图书信息");
                break;
            }
            
            const bookInfo = args[0].split(',');
            if (bookInfo.length !== 6) {
                console.log("图书信息格式不正确，请按照: <标题>,<作者>,<出版社>,<出版年份>,<页数>,<类型> 的格式输入");
                break;
            }
            
            const [title, author, publisher, publicationYearStr, pagesStr, genre] = bookInfo;
            const publicationYear = parseInt(publicationYearStr);
            const pages = parseInt(pagesStr);
            
            if (isNaN(publicationYear) || isNaN(pages)) {
                console.log("出版年份和页数必须是数字");
                break;
            }
            
            const bookData: CreateBookRequest = {
                title,
                author,
                publisher,
                publicationYear,
                pages,
                genre
            };
            
            const newBook = bookService.createBook(bookData);
            console.log("\n成功添加图书:");
            console.log(formatBook(newBook));
            break;
        
        case 'find':
            if (args.length === 0) {
                console.log("请输入图书ID");
                break;
            }
            
            const book = bookService.getBookById(args[0]);
            if (book) {
                console.log("\n找到图书:");
                console.log(formatBook(book));
            } else {
                console.log(`未找到ID为${args[0]}的图书`);
            }
            break;
        
        case 'list':
            const allBooks = bookService.getAllBooks();
            if (allBooks.length === 0) {
                console.log("暂无图书");
            } else {
                console.log("\n图书列表:");
                allBooks.forEach((book, index) => {
                    console.log(`${index + 1}. ${book.title} - ${book.author}`);
                });
                console.log(`\n共找到${allBooks.length}本图书`);
            }
            break;
        
        case 'query':
            if (args.length === 0) {
                console.log("请输入查询条件");
                break;
            }
            
            const queryParams = args[0].split(',');
            const query: any = {};
            
            queryParams.forEach(param => {
                const [key, value] = param.split('=');
                if (key && value) {
                    // 转换布尔值
                    if (value === 'true' || value === 'false') {
                        query[key] = value === 'true';
                    } else {
                        query[key] = value;
                    }
                }
            });
            
            const queryResults = bookService.getAllBooks(query);
            if (queryResults.length === 0) {
                console.log("未找到符合条件的图书");
            } else {
                console.log("\n查询结果:");
                queryResults.forEach((book, index) => {
                    console.log(`${index + 1}. ${book.title} - ${book.author} - ${book.isAvailable ? '可借阅' : '已借出'}`);
                });
                console.log(`\n共找到${queryResults.length}本符合条件的图书`);
            }
            break;
        
        case 'update':
            if (args.length < 2) {
                console.log("请输入图书ID和要更新的属性");
                break;
            }
            
            const bookId = args[0];
            const updateParams = args[1].split('=');
            
            if (updateParams.length !== 2) {
                console.log("更新属性格式不正确，请按照: <属性名>=<属性值> 的格式输入");
                break;
            }
            
            const [updateKey, updateValue] = updateParams;
            const updateData: any = {};
            
            // 转换数字和布尔值
            if (!isNaN(parseInt(updateValue))) {
                updateData[updateKey] = parseInt(updateValue);
            } else if (updateValue === 'true' || updateValue === 'false') {
                updateData[updateKey] = updateValue === 'true';
            } else {
                updateData[updateKey] = updateValue;
            }
            
            const updatedBook = bookService.updateBook(bookId, updateData);
            if (updatedBook) {
                console.log("\n成功更新图书:");
                console.log(formatBook(updatedBook));
            } else {
                console.log(`未找到ID为${bookId}的图书`);
            }
            break;
        
        case 'delete':
            if (args.length === 0) {
                console.log("请输入图书ID");
                break;
            }
            
            const deleted = bookService.deleteBook(args[0]);
            if (deleted) {
                console.log(`成功删除ID为${args[0]}的图书`);
            } else {
                console.log(`未找到ID为${args[0]}的图书`);
            }
            break;
        
        case 'toggle':
            if (args.length === 0) {
                console.log("请输入图书ID");
                break;
            }
            
            const toggledBook = bookService.toggleAvailability(args[0]);
            if (toggledBook) {
                console.log("\n成功更新图书可用性:");
                console.log(formatBook(toggledBook));
            } else {
                console.log(`未找到ID为${args[0]}的图书`);
            }
            break;
        
        case 'help':
            displayHelp();
            break;
        
        case 'exit':
            console.log("感谢使用图书管理系统，再见！");
            rl.close();
            return;
        
        default:
            console.log("未知命令，请输入'help'查看使用说明");
    }
    
    // 继续等待用户输入
    rl.prompt();
}

// 启动应用
console.log("欢迎使用TypeScript图书管理系统！");
displayHelp();

// 监听用户输入
rl.on('line', handleInput);
rl.prompt();

// 监听应用关闭
rl.on('close', () => {
    process.exit(0);
});

npm install

{
    "compilerOptions": {
        "target": "es6",
        "module": "commonjs",
        "outDir": "dist",
        "strict": true,
        "esModuleInterop": true
    },
    "include": ["src/**/*"],
    "exclude": ["node_modules"]
}

tsc

node dist/index.js