TypeScript

一、基本类型

类型	例子	描述
number	1,22,3,5	任意数字
string	'hi'	任意字符串
boolean	true,false	布尔值true/false
any	*	任意类型
unknow	*	类型安全的any
void	空置（undefined）	没有值/undefined
array	[1,2,3]	任意Js数组
tuple	[4.5]	固定长度数组
enum	enum{A,B}	枚举，Ts新增类型

注意：一个变量设置类型any后相当于对该变量关闭Ts类型检测，不建议使用any类型，建议使用unknow

1、在属性后面加上?，表示属性是可选的

let a:{name:string,age?:number};
a = {name:'奥特曼'}

2、任意类型属性

let b={name:string,[propName]:string:any};
b = {name:'奥特曼',type:'正义',age:22}

三、数组类型断言

1、字符串数组

let c:string[];
c = ['a','b','c']

2、数值数组

// 类型一
let d=number[];
d = [1,2,3]

//类型二
let e:Array<number>;
e = [1,2,3]

3、组合数组

let arr3:(string|number|boolean)[]=['a','b',123,false]

四、元祖类型断言

1、元祖就是固定长度的数组

let f:[string,string];
f =['123','456']

五、类

1、直接定义属性是实例属性，需要通过对象的实例去访问

例：const per = new Person();    console.log(per.name)

2、static：使用static开头的属性是静态属性，可以直接通过类去访问

例：Person.name

3、readonly：开头的属性表示只读属性不可以修改 

例：readonly name:string='奥特曼'

5、private：类的私有成员，只能在内部访问，在外部访问不到，无法被继承

例：private name:string='奥特曼'

class Dog{
    name:string;
    age:number;

    // constructor被称为构造函数，会在对象创建时调用
    constructor(name:string,age:number){

        //在实例方法中，this就是表示当前实例
        this.name = name;
        this.age = age;
    }
    
    back(){
        console.log('汪汪叫')
    }
}

const dog1=new Dog('小小'，2)；

六、类继承

//定义一个Animal类
class Animal{

    name:string
    age:number

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

    sayHello(){
        console.log('动物在叫')
    }
}

// 狗继承动物类
class Dog extends Animal{

    like:string

    constructor(name:string,age:number,like:string){
        // 在子类构造函数中必须对父类构造函数调用
        super();
        this.like=like
    }
    
    run(){
        console.log(this.name + '在跑！！！')
    }

}
// 猫继承动物类
class Cat extends Animal{

    sayHello(){
        //类方法中，super就表示当前类的父类
        super.sayHello();    
    }

}

const dog = new Dog('旺财'，2)
const cat = new Cat('鲁鲁'，2)

七、接口

//描述一个对象类型 方法一 类型
type objType = {
    name:string,
    age:number,
}

//描述一个对象类型 方法二 接口
interface objType{
    name:string,
    age:number,
}

const obj:objType:{
    name:'jake',
    age:22,
}

八、泛型

泛型：是指在定义函数、接口或类的时候，不预先指定具体的类型，而是在使用的时候在指定类型

1、函数泛型

//单个泛型
function fun1<T>(arg:T):T{
        return arg
}

fun1<string>('123')
fun1<number>(123)

//多个泛型
function fun2<T,U>(arg1:T.arg2:U):T{
        return arg
}

fun2<string,number>('123',123)
fun2<number,boolean>(123,false)

//泛型 需要length属性
interface Iarg{
    length:number
}

function fun3<T extends Iarg>(arg:T):number{
    return arg.length
}
fun3<string>('123')
fun1<string[]>(['123','123'])
fun1<number>(123)
fun3<number[]>([123,123])

类型断言

当返回ts类型声明为string||null的时候，返回值可能是undefined可以使用类型断言

(result.data.token as string) ==> 语意话就是保证result.data.token务必是字符串的时候再给予赋值