【HarmonyOS应用开发】TypeScript 复习笔记简单的类型直接跳过了，泛型概念:泛型(Generics)

简单的类型直接跳过了，

泛型

概念:泛型(Generics)是指在定义接口、函数等类型的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性,使用泛型可以复用类型并且让类型更加灵活

泛型
interface User{
    name: string
    age: number
    }
interface UserData {
    code: number
    msg: string
    data:User
}
interface Goods {
    id: number
    goodsName: string
}
interface GoodsData {
    code: number
    msg: string
    data: Goods
}

接口interface

语法:在接口类型的名称后面使用即可声明一个泛型参数，接口里的其他成员都能使用该参数的类型 interface ResData<T>

通用思路:

找到可变的类型部分通过泛型抽象为泛型参数(定义参数)
在使用泛型的时候，把具体类型传入到泛型参数位置(传参)

     //定义泛型
    interface ResData<T> ={
        msg:string
        code: number
        data:T
     }
    
    // 定义具体类型
    interface User ={
        name: string
        age: number
     }
    // 使用泛型并传入具体类型
    let userData: ResData<User>={
        code: 200,
        msg: 'success',
        data: {
            name: 'jack',
            age:18,
        }
     }
    
    // 定义具体类型
    interface Goods={
        id: number
        goodsName: string
    }

    // 使用泛型并传入具体类型
    let goodsData: ResData<Goods>={
        code:200,
        msg: 'success',
        data: {
            id:1001,
            goodsName:'衬衫'，
        }
    }

类型别名

语法:在类型别名type的后面使用即可声明一个泛型参数，接口里的其他成员都能使用该参数的类型 type ResData<T>={}

    //定义泛型
    type ResData<T> ={
        msg:string
        code: number
        data:T
     }
    
    // 定义具体类型
type User ={
    name: string
    age: number
    }
// 使用泛型并传入具体类型
let userData: ResData<User>={
    code: 200,
    msg: 'success',
    data: {
        name: 'jack',
        age:18,
    }
   }
    
    // 定义具体类型
type Goods={
    id: number
    goodsName: string
  }

// 使用泛型并传入具体类型
let goodsData: ResData<Goods>={
    code:200,
    msg: 'success',
    data: {
        id:1001,
        goodsName:'衬衫'，
    }
}

interface 对比 type

相同点

都能描述对象类型
都能实现继承，interface使用extends, type配合交叉类型

不同点

type除了能描述对象还可以用来自定义其他类型
同名的interface会合并(属性取并集，不能出现类型冲突)，同名type会报错

接口继承

    //接口继承
//父接口
interface GoodsType {
    id: string
    price: number
}
// 子接口继承
interface DisGoodsType extends GoodsType {
    disPrice: number
 }
let goods: DisGoodsType ={
    id:'1001'，
    price: 200,
    disPrice:180,
  }

type模拟继承(交叉类型&)

    // type模拟继承(交叉类型&)
//父接口
type GoodsType ={
    id: string
    price: number
}
//子接口
type DisGoodsType = GoodsType & {
    disPrice: number
}

let goods: DisGoodsType ={
    id:'1001'，
    price: 200,
    disPrice: 180,
}

泛型函数

语法: 在函数名称的后面使用即可声明一个泛型参数，整个函数中(参数、返回值、函数体)的变量都可以使用该参数的类型 function fn<T>()

    function createArray<T>(length: number,value: T): Array<T>{
    let res: T[] = [];
    for(let i=0; i<length; i++){
        res[i] = value
    }
    return res
}

泛型约束

泛型约束：在函数内部使用泛型变量的时候，由于事先不知道它是那种类型，所以不能随意操作它的属性或方法这时候我们可以对泛型进行约束
作用: 泛型的特点就是灵活不确定，有些时候泛型函数的内部需要 访问一些特定类型的数据才有的属性，此时会有类型错误，需要通过泛型约束解决

interface Lengthwise {
    length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
    console.log(arg.length);
    return arg;
}

类型工具 Record

语法：Record<K,T> Keys 表示对象的属性键、Type 表示对象的属性值，

使用： type proxyKType = Record<K,T>

理解为：将 K 的每一个值都定义为 T 类型