TS基本用法与高级用法（持续更新。。。）

基本数据类型

数字

const a: number = 3;

字符串

const b: string = "1"

数组

const c: number[] = [1, 2, 3];
const d: Array<number> = [1, 3];
const arr: any[] = [1, "33", true];

元组 可以为数组中的每个参数定义相对应的类型

const e: [number, string] = [1, "ww"];

枚举

enum error {
  blue = 3,
  "orange",
}
const f: error = error.orange;
console.log(f); //输出4

布尔类型

const g: boolean = true;

对象

const i: object = {};

undefined 常用于组合类型

let j: number | undefined;

null

let k: null;

void 指定方法类型，表示没有返回值,方法体中不能return

const aa = (): void => {
    console.log(1);
}
aa()


//如果方法有返回值，可以加上返回值的类型
const BB = (): number => {
    return 1;
}
BB()

never 其他类型 (包括null和undefined)的子类型，代表从不会出现的值

let l: never;

//匿名函数并抛出异常
l = (() => {
  throw new Error("111");
})();

任意类型 让参数可以是任何一种类型 any

let h: any = 1;
h = true;
h = "st";

函数声明

const a = (): void => { 
    
}

方法传参

const info = (name: string, age?: number, school: string = '清华') => {
    return `name:${name}--age:${age}--school:${school}`;
}

剩余参数 传递多个时，如果用了剩余参数，就可以把未定义的形参转换为数组。

const sum = (a: number, b: number, ...arr: number[]): number => {
    let sum: number = a + b;
    arr.forEach((element) => {
        sum += element;
    });
    console.log(arr);

    return sum;
}
console.log(sum(1, 2, 3, 4)); // 输出：10
console.log(sum(1, 2, 3, 4, 5)); // 输出：15

函数重载 可以根据参数的类型走其中一个方法并判断参数，但如果传入的参数类型不是任何被重载方法的参数类型就不允许通过。

const reload = (name: any): any => {
    return typeof name === "string" ? `我是:${name}` : `我的年龄:${name}`;
}
console.log(reload(222));

类

// 定义一个类
class Person {
    // 私有变量
    private name: string

    // 构造函数
    constructor(name: string) {
        this.name = name
    }

    // 获取名字
    getName(): string {
        return this.name
    }

    // 设置名字
    setName(name: string): void {
        this.name = name
    }
}
let p = new Person("老虎")

p.setName("历史")
console.log(p);

继承

// 定义一个类
class Person {
    // 私有变量
    private name: string

    // 构造函数
    constructor(name: string) {
        this.name = name
    }

    // 获取名字
    getName(): string {
        return this.name
    }

    // 设置名字
    setName(name: string): void {
        this.name = name
    }
}
let p = new Person("老虎")

p.setName("历史")
console.log(p);

// 继承
class Son extends Person {
    // 静态属性
    public static age: number = 18

    // 学校
    public school: string

    // 构造函数
    constructor(name: string, school: string) {
        // 访问构造函数中的this前，必须先调用super() 初始化父类构造函数，把参数传给父类
        super(name)
        this.school = school
    }
    // 静态方法
    static run(name: string): string {
        return `${name}跑步，年龄才${this.age}`
    }
}

let son = new Son("小胡", "北京")
console.log(son);  // {name:"小胡",school:"北京"}

son.setName("强")
console.log(son);  // {name:"强",school:"北京"}

console.log(Son.run('胡强'));  // 胡强跑步，年龄才18

console.log(Son.age)  // 18