typescript5学习工具类

//

//ts5

// 类型保护 更明确的判断某个分支作用域的类型

// 判断类型 调用不同类型的方法

//boolean valueof 是boolean的方法

 

// 引用类型的

class Animal8{

public name:string

}

class Bird8 extends Animal{

public age:string

}

class Dogs extends Animal{

public legs:number

}

function getName(animal:Animal8){

if(animal instanceof Animal){

 

}else if(animal instanceof Bird){

 

}else if(animal instanceof Dog){

 

}

}

getName(new Animal())

getName(new Bird())

let obj &＃61; {name:"guozimo",age:10}

getName(obj)

 

// null 保护 如果说开启了strictNullChecks选项

// 我们就不能直接调用可能为null上的方法了

// 改成false就不检查了

// 1 加&＃xff01;

function getFirstLetter(str:string|null){

return str!.charAt(0);

}

// || &＃39;&＃39;

function getFirstLetter(str:string|null){

str &＃61; str || &＃39;&＃39;

return str.charAt(0);

}

//

let a &＃61; null

let b

//?.// 运算符

a?.b

// 暂时用不了;

interface WarningButton{

class:&＃39;warning&＃39;;

text1:&＃39;修改&＃39;

}

interface DangerButton{

class:&＃39;danger&＃39;;

text2:&＃39;删除&＃39;

}

 

type Button &＃61; WarningButton | DangerButton

 

function getText(button:Button){

if(button.class&＃61;&＃61;&＃61;&＃39;warning&＃39;){

console.log(button.text1)

}else if(button.class&＃61;&＃61;&＃61;&＃39;danger&＃39;){

console.log(button.text2)

}

}

 

// in操作符用作参数的判断

interface Bird{

swing:number;

fly():void;

 

}

interface Dog{

leg:number;

run():void

}

function getNumber(animal:Bird|Dog){

if(&＃39;swing&＃39; in animal){

animal.fly()

} else {

animal.run()

}

}

 

// 有些时候 两个类型 没有共同属性 不同的取值

//自定义类型保护

interface Bird2{

leg:number

}

interface Dog2{

leg:number

}

function isBird2(x:Bird2|Dog2):x is Bird2{

// return x.leg &＃61;&＃61;&＃61;2

return x.leg &＃61;&＃61;&＃61;4

}

function getAnimal(x:Bird2|Dog2):string{

if(isBird2(x)){

return &＃39;我是一只鸟&＃39;;

}else {

return &＃39;我是一只狗&＃39;;

}

}

// 类型保护是为了让你更具体的调用参数上的属性和方法

// 类型变换

//交叉类型

// 多类型合并为一个类型 交叉类型

interface Bird9{

name:string;

fly():void

}

interface Person {

age:number;

talk():void

}

// 交叉类型 把多个类型 合并成一个大的类型

let birdMan &＃61; Bird & Person;

let bm:birdMan &＃61; {

name:&＃39;zimo&＃39;,

fly(){},

talk(){},

age:10

}

 

// typeof 用来获取一个变量的类型;

type Person2{

name:string;

age:number;

gender:number

}

// let p2:Person2 &＃61; {

// name:&＃39;&＃39;,

// age:10,

// gender:0

// }

// 先拿到一个对象&＃xff0c;然后通过对象反推这个对象的类型

let p2 &＃61; {name:&＃39;zimo&＃39;,age:20,gender:0}

type Person2 &＃61; typeof p2;

// 拿到一个变量的类型 再来约束其他的变量

let p22:Person2 &＃61;{name:&＃39;zimo&＃39;,age:10,gender:0}

// 索引访问操作符

interface Person3{

name:string;

age:number;

job:{

name:string

};

interests:{name:string,level:number}

 

}

let FrontEndJob:Person3[&＃39;job&＃39;] &＃61; {name:&＃39;frontEnd&＃39;}

 

let interests:Person3[&＃39;interests&＃39;]&＃61;[{name:&＃39;打篮球&＃39;,level:1},{name:&＃39;唱歌&＃39;,level:2}]

 

// 索引类型查询操作符 keyof获取xxx的key

interface Person4{

name:string;

age:number;

gender:number

}

// Object.keys({name:&＃39;zimo&＃39;,age:10,gender:1})

type PersonKey &＃61; keyof Person4;// 三者中的一个

let p1:Person4 &＃61; {name:&＃39;zimo&＃39;,age:10,gender:1}

function getValueByKey(p:Person,key:PersonKey){

return p[key]

}

let val &＃61; getValueByKey(p1,&＃39;name&＃39;)

 

// 映射类型

interface Person5{

name:string;

age:number;

gender:&＃39;male&＃39;|&＃39;female&＃39;

// 变成可选项 可以写这项 也可以不写这项

}

// 批量处理 可选项参数&＃xff1f; 加上问好就是可选项了 可以不填写

type Person5Search &＃61; {

[key in keyof Person5]?:Person5[key]

}

let p5:Person5Search &＃61; {name:&＃39;zimo&＃39;,age:10,gender:&＃39;female&＃39;}

 

// 内置的工具类型批量处理 可选参数

type Partial &＃61; {

[p in keyof T]?:T[p]

}

type Person5Search &＃61; Partial

 

// required 必填项

let p6:Person5 &＃61; {name:&＃39;zimo&＃39;,age:10,gender:&＃39;female&＃39;}

type Required &＃61; {

[p in keyof T]-?:T[p]

}

type Person6Required &＃61; Required

// readOnly

interface Person7{

readonly name:string;// 不能修改

age:number;

gender:&＃39;male&＃39;|&＃39;female&＃39;

}

type ReadOnly &＃61; {

readonly [p in keyof T]:T[p]

}

type Person7ReadOnly &＃61; ReadOnly

// pick 从一个大类型中捡出来若干个小类型

interface Person8{

name:string;

age:number;

gender:&＃39;male&＃39;|&＃39;female&＃39;

}

type Pick &＃61; {[P in K]:T[P]}

type PersonSub &＃61; Pick

let ps:PersonSub &＃61; {name:&＃39;zimo&＃39;,age:10}

// 这样就只能放name 了 把age删除掉

// 拣取一部分类型使用

// 不需要自己定义pick 了 内置的 本来就可以用