//////////////////////////////////////////////
//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 = {name:"guozimo",age:10}
getName(obj)
// null 保护 如果说开启了strictNullChecks选项
// 我们就不能直接调用可能为null上的方法了
// 改成false就不检查了
// 1 加！
function getFirstLetter(str:string|null){
return str!.charAt(0);
}
// || ''
function getFirstLetter(str:string|null){
str = str || ''
return str.charAt(0);
}
//
let a = null
let b
//?.// 运算符
a?.b
// 暂时用不了;
interface WarningButton{
class:'warning';
text1:'修改'
}
interface DangerButton{
class:'danger';
text2:'删除'
}
type Button = WarningButton | DangerButton
function getText(button:Button){
if(button.class==='warning'){
console.log(button.text1)
}else if(button.class==='danger'){
console.log(button.text2)
}
}
// in操作符用作参数的判断
interface Bird{
swing:number;
fly():void;
}
interface Dog{
leg:number;
run():void
}
function getNumber(animal:Bird|Dog){
if('swing' 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 ===2
return x.leg ===4
}
function getAnimal(x:Bird2|Dog2):string{
if(isBird2(x)){
return '我是一只鸟';
}else {
return '我是一只狗';
}
}
// 类型保护是为了让你更具体的调用参数上的属性和方法
// 类型变换
//交叉类型
// 多类型合并为一个类型 交叉类型
interface Bird9{
name:string;
fly():void
}
interface Person {
age:number;
talk():void
}
// 交叉类型 把多个类型 合并成一个大的类型
let birdMan = Bird & Person;
let bm:birdMan = {
name:'zimo',
fly(){},
talk(){},
age:10
}
// typeof 用来获取一个变量的类型;
type Person2{
name:string;
age:number;
gender:number
}
// let p2:Person2 = {
// name:'',
// age:10,
// gender:0
// }
// 先拿到一个对象，然后通过对象反推这个对象的类型
let p2 = {name:'zimo',age:20,gender:0}
type Person2 = typeof p2;
// 拿到一个变量的类型 再来约束其他的变量
let p22:Person2 ={name:'zimo',age:10,gender:0}
// 索引访问操作符
interface Person3{
name:string;
age:number;
job:{
name:string
};
interests:{name:string,level:number}
}
let FrontEndJob:Person3['job'] = {name:'frontEnd'}
let interests:Person3['interests']=[{name:'打篮球',level:1},{name:'唱歌',level:2}]
// 索引类型查询操作符 keyof获取xxx的key
interface Person4{
name:string;
age:number;
gender:number
}
// Object.keys({name:'zimo',age:10,gender:1})
type PersonKey = keyof Person4;// 三者中的一个
let p1:Person4 = {name:'zimo',age:10,gender:1}
function getValueByKey(p:Person,key:PersonKey){
return p[key]
}
let val = getValueByKey(p1,'name')
// 映射类型
interface Person5{
name:string;
age:number;
gender:'male'|'female'
// 变成可选项 可以写这项 也可以不写这项
}
// 批量处理 可选项参数？ 加上问好就是可选项了 可以不填写
type Person5Search = {
[key in keyof Person5]?:Person5[key]
}
let p5:Person5Search = {name:'zimo',age:10,gender:'female'}
// 内置的工具类型批量处理 可选参数
type Partial<T> = {
[p in keyof T]?:T[p]
}
type Person5Search = Partial<Person5>
// required 必填项
let p6:Person5 = {name:'zimo',age:10,gender:'female'}
type Required<T> = {
[p in keyof T]-?:T[p]
}
type Person6Required = Required<Person6>
// readOnly
interface Person7{
readonly name:string;// 不能修改
age:number;
gender:'male'|'female'
}
type ReadOnly<T> = {
readonly [p in keyof T]:T[p]
}
type Person7ReadOnly = ReadOnly<Person7>
// pick 从一个大类型中捡出来若干个小类型
interface Person8{
name:string;
age:number;
gender:'male'|'female'
}
type Pick<T,K extends keyof T> = {[P in K]:T[P]}
type PersonSub = Pick<Person8,'name'|'age'>
let ps:PersonSub = {name:'zimo',age:10}
// 这样就只能放name 了 把age删除掉
// 拣取一部分类型使用
// 不需要自己定义pick 了 内置的 本来就可以用
