// 定义元组：第一个元素是string，第二个是number，长度固定为2
let user: [string, number] = ["张三", 18];

// 可选元素
let userInfo: [string, number?] = ["李四"]; // 第二个元素可选

// 剩余元素
let list: [string, ...number[]] = ["a", 1, 2, 3];

// 只读元组
const readonlyTuple: readonly [string, number] = ["a", 1];

// 1. 数字枚举（默认，从0开始自增，可手动赋值）
enum Direction {
  Up, // 0
  Down, // 1
  Left = 10, // 手动赋值10
  Right, // 11（基于上一个值自增）
}
console.log(Direction.Up); // 0
console.log(Direction[0]); // 反向映射：Up

// 2. 字符串枚举（无反向映射）
enum Msg {
  Success = "操作成功",
  Fail = "操作失败",
}

// 3. 常量枚举 const enum（编译后会被内联，减少代码体积）
const enum Status {
  Enable = 1,
  Disable = 0,
}
const code = Status.Enable; // 编译后直接变为 const code = 1;

type Person = { name: string; age: number };
type Employee = { id: number; department: string };

// 合并两个类型，Staff 同时拥有 name、age、id、department 属性
type Staff = Person & Employee;

const staff: Staff = {
  name: "张三",
  age: 25,
  id: 1001,
  department: "技术部",
};

// 定义Person接口，约束对象必须包含name、age属性
interface Person {
  name: string;
  age: number;
}

// 实现接口：必须严格匹配结构，不能缺少/多传未定义的属性
const user: Person = {
  name: "张三",
  age: 18,
};

interface User {
  readonly id: number; // 只读属性：声明时/构造函数中赋值后，不可修改
  name: string;
  age?: number; // 可选属性：该属性可以不存在
  [key: string]: any; // 索引签名：支持任意数量的额外属性，key为string，值为any
}

const user: User = {
  id: 1,
  name: "李四",
  gender: "男", // 索引签名支持的额外属性
};
user.id = 2; // 报错，只读属性不可修改

interface Animal {
  name: string;
  eat(): void;
}

// 单继承
interface Dog extends Animal {
  bark(): void;
}

// 多继承
interface Cat extends Animal, Pet {
  miao(): void;
}

const husky: Dog = {
  name: "哈士奇",
  eat() { console.log("吃狗粮"); },
  bark() { console.log("汪汪叫"); },
};

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

// 合并后，User接口同时拥有name和age属性
const user: User = {
  name: "张三",
  age: 18,
};

// 给原始类型起别名
type Username = string;

// 给对象类型起别名
type User = {
  readonly id: number;
  name: string;
  age?: number;
};

// 给联合类型起别名
type Status = "pending" | "success" | "fail";

// 给函数类型起别名
type AddFunc = (a: number, b: number) => number;

// 命名函数：参数注解 + 返回值注解
function add(a: number, b: number): number {
  return a + b;
}

// 函数表达式
const add2: (a: number, b: number) => number = (a, b) => {
  return a + b;
};

// 无返回值函数：void
function log(msg: string): void {
  console.log(msg);
}

// 永远不返回的函数：never
function throwError(msg: string): never {
  throw new Error(msg);
}

// 1. 可选参数：? ，必须放在必选参数之后
function greet(name: string, prefix?: string) {
  return prefix ? `${prefix} ${name}` : name;
}

// 2. 默认参数
function add(a: number, b: number = 0) {
  return a + b;
}

// 3. 剩余参数 ...rest
function sum(...nums: number[]): number {
  return nums.reduce((total, num) => total + num, 0);
}

// 重载签名：定义不同的入参和返回值
function getInfo(id: number): { id: number; name: string };
function getInfo(name: string): { id: number; name: string };

// 实现签名：必须兼容所有重载签名
function getInfo(value: number | string) {
  if (typeof value === "number") {
    return { id: value, name: "用户" + value };
  } else {
    return { id: 1, name: value };
  }
}

// 调用时，会根据入参类型匹配对应的重载签名
getInfo(1001);
getInfo("张三");

interface User {
  name: string;
  sayHi: () => void;
}

const user: User = {
  name: "张三",
  sayHi() {
    console.log(`Hi, ${this.name}`);
  },
};

// 显式指定this类型
function sayHi(this: User) {
  console.log(`Hi, ${this.name}`);
}

class Person {
  // 属性类型注解
  name: string;
  age: number;

  // 构造函数参数注解
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 方法参数与返回值注解
  sayHi(): void {
    console.log(`Hi, 我是${this.name}，今年${this.age}岁`);
  }
}

const user = new Person("张三", 18);

class User {
  public name: string;
  private password: string;
  protected id: number;

  constructor(name: string, password: string, id: number) {
    this.name = name;
    this.password = password;
    this.id = id;
  }
}

class VipUser extends User {
  showId() {
    console.log(this.id); // 合法，protected子类可访问
    console.log(this.password); // 报错，private子类不可访问
  }
}

const user = new User("张三", "123456", 1001);
console.log(user.name); // 合法
console.log(user.password); // 报错，private外部不可访问
console.log(user.id); // 报错，protected外部不可访问

class User {
  readonly id: number; // 只读属性：仅声明时/构造函数中可赋值
  static platform: string = "WEB"; // 静态属性：属于类本身，而非实例
  static getPlatform(): string { // 静态方法
    return User.platform;
  }

  constructor(id: number) {
    this.id = id;
  }
}

console.log(User.platform); // 静态成员通过类名访问
console.log(User.getPlatform());

// 简化前
class User {
  public name: string;
  private age: number;
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}

// 简化后（参数属性）
class User {
  constructor(
    public name: string,
    private age: number
  ) {}
}

// 定义抽象类
abstract class Animal {
  abstract name: string; // 抽象属性：子类必须实现
  abstract eat(): void; // 抽象方法：子类必须实现，不能有方法体

  // 普通方法：可直接复用
  sleep(): void {
    console.log("睡觉");
  }
}

// 子类继承抽象类，必须实现所有抽象属性和方法
class Dog extends Animal {
  name: string = "狗";
  eat(): void {
    console.log("吃狗粮");
  }
}

const dog = new Dog();
dog.eat();
dog.sleep();

interface Fly {
  fly(): void;
}
interface Run {
  run(): void;
}

// 实现多个接口
class Bird implements Fly, Run {
  fly() {
    console.log("飞翔");
  }
  run() {
    console.log("奔跑");
  }
}

// 泛型函数：T 是类型参数，调用时指定具体类型
function identity<T>(value: T): T {
  return value;
}

// 1. 手动指定类型
const str = identity<string>("hello");
const num = identity<number>(123);

// 2. 类型推断：TS自动根据入参推断类型参数
const bool = identity(true); // 自动推断 T 为 boolean

// 约束：传入的参数必须有 length 属性
interface HasLength {
  length: number;
}

function getLength<T extends HasLength>(value: T): number {
  return value.length;
}

getLength("hello"); // 合法，字符串有length
getLength([1, 2, 3]); // 合法，数组有length
getLength(123); // 报错，数字没有length

// 泛型接口
interface ApiResponse<T> {
  code: number;
  msg: string;
  data: T; // 泛型数据，由调用方指定类型
}

// 使用：指定data为用户对象类型
const userRes: ApiResponse<{ name: string; id: number }> = {
  code: 200,
  msg: "success",
  data: { name: "张三", id: 1001 },
};

// 泛型类
class Container<T> {
  value: T;
  constructor(value: T) {
    this.value = value;
  }
  getValue(): T {
    return this.value;
  }
}

const numberContainer = new Container<number>(123);

interface ApiResponse<T = any> {
  code: number;
  msg: string;
  data: T;
}

// 未指定类型，默认使用 any
const res: ApiResponse = {
  code: 200,
  msg: "success",
  data: {},
};

// 1. typeof 守卫：用于原始类型
function print(value: string | number) {
  if (typeof value === "string") {
    console.log(value.length); // 缩小为string类型
  } else {
    console.log(value.toFixed(2)); // 缩小为number类型
  }
}

// 2. instanceof 守卫：用于类实例
class Dog { bark() {} }
class Cat { miao() {} }
function animalAction(animal: Dog | Cat) {
  if (animal instanceof Dog) {
    animal.bark();
  } else {
    animal.miao();
  }
}

// 3. in 操作符守卫：判断对象是否包含指定属性
interface User { name: string }
interface Admin { name: string; permission: string[] }
function checkAuth(account: User | Admin) {
  if ("permission" in account) {
    console.log(account.permission); // 缩小为Admin类型
  }
}

// 4. 等值判断守卫：=== / !==
function getValue(value: string | null | undefined) {
  if (value !== null && value !== undefined) {
    console.log(value.length); // 缩小为string类型
  }
}

// 5. 真值判断守卫：if() 排除 falsy 值
function printMsg(msg: string | undefined | null) {
  if (msg) {
    console.log(msg.toUpperCase()); // 缩小为string类型
  }
}

// 自定义守卫：判断值是否为string类型
function isString(value: unknown): value is string {
  return typeof value === "string";
}

// 自定义守卫：判断值是否为合法的用户对象
interface User {
  name: string;
  id: number;
}
function isUser(value: unknown): value is User {
  return (
    typeof value === "object" &&
    value !== null &&
    "name" in value &&
    "id" in value
  );
}

// 使用
function handleValue(value: unknown) {
  if (isString(value)) {
    console.log(value.length);
  }
  if (isUser(value)) {
    console.log(value.name);
  }
}

// 定义可辨识联合：每个类型都有共同的type属性
interface Circle {
  type: "circle"; // 可辨识标签
  radius: number;
}
interface Square {
  type: "square"; // 可辨识标签
  sideLength: number;
}
type Shape = Circle | Square;

// 通过type标签缩小类型
function getArea(shape: Shape): number {
  switch (shape.type) {
    case "circle":
      return Math.PI * shape.radius ** 2; // 缩小为Circle类型
    case "square":
      return shape.sideLength ** 2; // 缩小为Square类型
  }
}

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

// keyof 获取所有属性名联合类型
type UserKeys = keyof User; // "name" | "age" | "id"

// 索引访问类型
type UserNameType = User["name"]; // string
type UserIdType = User["id"]; // number

// 1. 可选链操作符 ?.：安全访问嵌套属性，避免Cannot read properties of undefined
const userName = user?.info?.name;

// 2. 空值合并操作符 ??：仅当左侧为null/undefined时，返回右侧值
const pageSize = query.pageSize ?? 10;

// 3. satisfies 操作符：验证值是否符合类型，同时保留值的字面量类型
type Config = Record<string, string | number>;
const config = {
  host: "localhost",
  port: 3000,
} satisfies Config;
config.port.toFixed(2); // 保留了port的number类型，不会被拓宽为string|number

// 给第三方JS模块声明类型
declare module "untyped-js-lib" {
  export function add(a: number, b: number): number;
  export const version: string;
}

// 全局类型声明
declare global {
  interface Window {
    $: JQuery; // 给window扩展$属性
  }
}

// 1. 类装饰器：作用于类，参数是类的构造函数
function ClassDecorator(target: Function) {
  console.log("类装饰器", target);
}

// 2. 方法装饰器：作用于类的方法
function MethodDecorator(
  target: any,
  propertyKey: string,
  descriptor: PropertyDescriptor
) {
  console.log("方法装饰器", propertyKey);
}

// 3. 属性装饰器：作用于类的属性
function PropertyDecorator(target: any, propertyKey: string) {
  console.log("属性装饰器", propertyKey);
}

// 4. 参数装饰器：作用于方法的参数
function ParamDecorator(target: any, propertyKey: string, parameterIndex: number) {
  console.log("参数装饰器", parameterIndex);
}

// 使用装饰器
@ClassDecorator
class User {
  @PropertyDecorator
  name: string;

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

  @MethodDecorator
  sayHi(@ParamDecorator msg: string) {
    console.log(msg);
  }
}

{
  "compilerOptions": {
    // 编译目标JS版本
    "target": "ES2020",
    // 模块系统
    "module": "ESNext",
    // 模块解析策略
    "moduleResolution": "NodeNext",
    // 开启严格模式（包含以下所有严格检查子项）
    "strict": true,
    // 严格空值检查，禁止null/undefined赋值给非空类型
    "strictNullChecks": true,
    // 禁止隐式any类型
    "noImplicitAny": true,
    // 严格检查函数的this类型
    "strictFunctionTypes": true,
    // 严格检查类的属性初始化
    "strictPropertyInitialization": true,
    // 兼容ES模块和CommonJS
    "esModuleInterop": true,
    // 跳过库文件类型检查
    "skipLibCheck": true,
    // 生成类型声明文件
    "declaration": true
  },
  // 编译包含的文件
  "include": ["src/**/*"],
  // 编译排除的文件
  "exclude": ["node_modules"]
}