TypeScript类型

泛型

1.泛型的基本使用

export default{}
//泛型可以理解为宽泛的类型，通常用于类和函数。使用的时候我们再指定类型
//泛型不仅可以让我们的代码变得更加健壮,还能让我们的代码在变得健壮的同时保持灵活性和可重用性
//通过用<T>来表示,放在参数的前面
let getArray=<T>(value:T,items:number):T[]=>{
    return new Array(items).fill(value);
}
let res1=getArray<string>("或许",18);
let res2=getArray<number>(21,10);

console.log(res1);
console.log(res2);

2.泛型约束

export default{}
//在TS中，我们需要严格的设置各种类型，我们使用泛型之后，将会变得更加灵活，但同时也将会存在一些问题
//我们需要对泛型进行约束来解决这些问题
//通用的方法
// function getLength<T>(arr : Array<T>): Array<T> {
//     console.log(arr .length);
//     return arr;
// }

interface Ilength{
    length:number
}
function   getLength<T extends Ilength>(arr:T):number{
    return arr.length;
}

getLength([1,2,3,4])
getLength(["郭旭","虢胥"])
getLength("拉文")

3.泛型接口

export default{}
//将泛型与接口结合起来使用，可以大大简化我们的代码，增加我们的代码可读性
//泛型也可以使用默认值
interface IPerson<T1=string,T2=number>{
    name:T1
    sex:T2
}
let p:IPerson={
    name:"扎克拉文",
    sex:0
}

4.泛型类

export default{}
//泛型类看上去与泛型接口差不多，泛型类使用（<>）括起泛型类型，跟在类名后面
class Person<T1,T2>{
name:T1
age:T2
sex:T1

constructor(name:T1,age:T2,sex:T1){
    this.name=name;
    this.age =age;
    this.sex=sex;
}
}
let p =new Person<string,number>("布克",26,"男")
console.log(p);

其他补充类型

1.unknown

export default{}

//unknown类型代表任何值。这与any类型类似，但更安全，因为对未知unknown值做任何事情都是不合法的。
//unknown类型被称作安全的any
//类型断言
// num =val as number;

// //类型缩小
// if (typeof val=="number") {
//     num=val;
// }
//3.unknown与其它类型组成的交叉类型最后都是其它类型
type myTypel=number & unknown;
type myType2=unknown & number;

let a:myTypel=18;

// let b:myType2=false;

//4.unknown除了与any以外，与其它类型组成的联合类型最后都是unknown类型
type myType3=unknown | any
type myType4=unknown | string
type myType5=unknown | number | string

//5.never类型都是unknown类型的子类型
type myType6=never extends unknown?true:false

2.map类型

export default{}
let  nameMap=new Map()
//设置Map对象
nameMap.set("郭旭",1)
nameMap.set("虢胥",2)
nameMap.set("蝈煦",3)

//获取键对应的值

// console.log(nameMap.get("蝈煦11"))
//判断Map中是否包含键对应的值
console.log(nameMap.has("郭旭"));
console.log(nameMap.has("蝈煦"));

//返回Map对象键/值对的数量
console.log(nameMap.size);

//删除 Runoob
console.log(nameMap.delete("Runoob"));
console.log(nameMap);

//移除Map对象的所有值
nameMap.clear()
console.log(nameMap);

//迭代Map中的key
for(let key of nameMap.keys()){
console.log(key);

}
//迭代Map中的value
for(let value of nameMap.values()){
    console.log(value);
    
    }
//迭代Map中的key => value
for(let entry of nameMap.entries()){
    console.log(entry[0],entry[1]);
    
    }
    //使用对象解析
    for(let [key,value] of nameMap){
        console.log(key,value);
        
        }
    

3.条件类型

export default {}

// 三元运算符
// let f = 60
// let j =""
// j=f>=60?"及格":"不及格"
// console.log(j)


interface IName{
    name:string
}
interface IAge{
    age:number
}

// 条件类型
type Condition<T>=T extends string?IName:IAge
function reload<T extends string|number>(idOrname:T):Condition<T>{
    throw ""
}
reload("赵丽颖")
reload(18)

4.映射类型

export default {}

// Record映射类型
// 他会将一个类型的所有属性值都映射到另一个类型上并创造一个新的类型
type Name="person"|"animal"
type Person={
    name:string
    age:number
}

type NewType=Record<Name,Person>
let res:NewType={
    person:{
        name:"富兰克林",
        age:18
    },
    animal:{
        name:"小查",
        age:3
    }
}
console.log(res)


// Pick映射类型
// 将原有类型中的部分内容映射到新类型中
interface IPerson{
    name:string
    age:number
}
type MyType=Pick<IPerson,"name">
let res2:MyType={
    name:"崔弗"
}
console.log(res2)