// 声明字符串
const a1:string = "test";
// 声明数字
const a2:number = 1;
// 声明数组
let a3:Array<number> = [];
let a4:string[] = [];
let a5:object[] = [];
a3.push(2);
a4.push('1');
a5.push({});
// 声明对象
interface user {
  name:string,
  age:number,
  birth:string,
  isMale?:boolean, // 可选标记
}
let user:user = {
  name:"",
  age:0,
  birth:""
}
// 声明数组配合对象
let a6:user[] = [];
a6.push({
  name:"",
  age:0,
  birth:""
})

// 枚举
const generate = ():number => {
  return Math.random()
}
enum Status {
  Error = 404,
  NotFound, // 405 (枚举能够自动累加值)
  Visiter = 1001,
  Admin, // 1002
  Mixed = "Mix",
  Random = generate()
}
let code = {
  err:Status.Error
}
// Set 和 Map 数据结构
let a7 = new Set<number>();
let a8 = new Map<number,string>();

// 声明式函数类型标注
function add(x:number,y:number):void{

}
// 表达式函数类型标注
type Sub = (x:number,y:number) => number
const sub:Sub = (x,y)=>{
  return x-y
}

// 函数重载 (TypeScript 中的函数重载还是属于伪重载，它只能在类型层面帮你实现重载的效果，而实际的逻辑运行，由于 JavaScript 不支持，它也就束手无策了)
function sum(base: number, incre: number): number;
function sum(baseArray: number[], incre: number): number[];
function sum(incre: number, baseArray: number[]): number[];
function sum(baseArray: number[], increArray: number[]): number[];

function sum(x: number | number[], y: number | number[]): number | number[] { 
  if (typeof x === 'number' && typeof y === 'number') {
    return x + y;
  } else if (Array.isArray(x) && typeof y === 'number') {
    return x.map((num) => num + y);
  } else if (typeof x === 'number' && Array.isArray(y)) {
    return y.map((num) => num + x);
  } else if (Array.isArray(x) && Array.isArray(y)) {
    if (x.length !== y.length) {
      throw new Error('Arrays must have the same length');
    }
    return x.map((num, index) => num + y[index]);
  } else {
    throw new Error('Invalid arguments');
  }
}


// Class 类型标注
class Person {
  private name:string;
  private age:number;
  private address:string;

  constructor(name:string,age:number,address:string){
    this.name = name;
    this.age = age;
    this.address = address;
  }
  getInfo():string{
    return `name:${this.name},age:${this.age}`
  }
  generateAddress(province: number | string,city: number | string):string; // class的函数重载
  
  generateAddress(province:number | string,city:number | string):string{
    return `province:${province + this.address},city:${city}`
  }
}

// Class static 妙用
export class Tool { 
  static getUrlParams(){

  }
}
Tool.getUrlParams() // 可以直接使用，不用实例化对象

const util:Tool = new Tool() // 对象类型赋值,使该变量只能为Tool的实例化对象

// any & unknown & 类型断言as
let x: any; // any类型代表当下不知道的情况下未来补充
const myArray: any[] = [1, "hello", true]; // 使用了 any 类型，就意味着告诉类型检查系统，这个变量开白名单了


function myFun (params:unknown):void{
  // params.forEach( v => v )  // 这样会报错因为unknown要求我们先为这个变量提供一个具体的类型后才能使用
}

function myFun2 (params:unknown):void{
  (params as unknown[]).forEach( v => {
    v = (v as number) +1
  })   // 类型断言as:随着后续的一步步使用，我们通过类型断言慢慢地完善这个类型的轮廓，最后完成对初始类型的定义
}



// 类型别名、联合类型、交叉类型

type user2 = { // 使用类型别名代替接口
  name:string,
  age:number,
  birth:string
}
type user3 = { // 使用类型别名代替接口
  sex:boolean
}
type Code = 200 | 404 | 502; // 字面量联合类型
type PossibleTypes = string | number | boolean // 原始类型联合类型


interface UserBasicInfo {}
interface UserJobInfo {}
interface UserFamilyInfo {}
type UserInfo = UserBasicInfo & UserJobInfo & UserFamilyInfo; // 交叉类型：需要满足 UserBasicInfo、UserJobInfo、UserFamilyInfo 这三个对象类型的所有属性
const user4: UserInfo = {}

type Test = string & number; // never 类型


// 泛型
type code<T> = 1 | 2 | T
let a:code<3> = 3

function sum2<T> (num:T):T{ // 参数与返回值类型的关联时，才使用泛型
  return num
}

// 内置工具类型

type student = {
  name:string,
  age:number,
  male:boolean,
  address?:string
}

type PartialStudent = Partial<student>;   // 将student的类型全部变为可选
const student1:PartialStudent = {
  name:"C"
}

type RequiredStudent = Required <student>; // 将student的类型全部变为必选
const student2:RequiredStudent = {
  name:"B",
  age:2,
  male:true,
  address:"NewYork"
}

type ReadonlyStudent = Readonly<student>; // 将student的类型全部变为只读
const studnet3:ReadonlyStudent = {
  name:"A",
  age:1,
  male:true,
}
// studnet3.name = "B"; // 只读属性报错

type UserProps  = "name" | "job" | "email"
type User = Record<UserProps,string>; // Record批量生成string
const user6:User = {
  name:"1",
  job:"2",
  email:"3"
}

type Teacher = {
  name:string,
  age:string,
  email: string;
  phone: string;
}
type TeacherPick = Pick<Teacher, 'name' | 'age'> // 只提取其中的 name 与 age 信息
const teacher1:TeacherPick = {
  name:"1",
  age:"2"
}

type TeacherOmit = Omit<Teacher, 'name'> // 只排除name信息
const teacher2:TeacherOmit = {
  age:"1",
  email: "2",
  phone: "3"
}

type UserProps2 = 'name' | 'age' | 'email' | 'phone' | 'address';
type RequiredUserProps = 'name' | 'email';

type OptionalUserProps = Exclude<UserProps2, RequiredUserProps>; // 差集
type RequiredUserPropsOnly = Extract<UserProps2, RequiredUserProps>; // 交集

const optionalUserProps: OptionalUserProps = 'age';
const requiredUserPropsOnly: RequiredUserPropsOnly = 'name'; // name 或 email 都可

type Add = (x: number, y: number) => number;
type AddParams = Parameters<Add>; // [number, number] 类型
type AddResult = ReturnType<Add>; // number 类型

const addParams: AddParams = [1, 2];
const addResult: AddResult = 3;

const addHandler = (x: number, y: number) => x + y;
type Add2 = typeof addHandler;
type AddParams2 = Parameters<Add2>; // [number, number] 类型
type AddResult2 = ReturnType<Add2>; 
const addParams2: AddParams2 = [1, 2];
const addResult2: AddResult2 = 3;


const promise = new Promise<string>((resolve) => {
  setTimeout(() => {
    resolve("Hello, World!");
  }, 1000);
});

type PromiseInput = Promise<string>;
type AwaitedPromiseInput = Awaited<PromiseInput>; // string

// 定义一个函数，该函数返回一个 Promise 对象
async function getPromise() {
  return new Promise<string>((resolve) => {
    setTimeout(() => {
      resolve("Hello, World!");
    }, 1000);
  });
}

type Result = Awaited<ReturnType<typeof getPromise>>; // string 类型