type && interface

//联合类型
let num:number|string
num = 8
num = '123'
num = 90
num.length //如果直接访问 length 属性，string 类型上有，number 类型上没有，就报错了，

// 交叉类型
// 比如 Person 有 name 和 age 的属性，而 Student 在 name 和 age 的基础上还有 grade 属性，就可以这么写，
interface Person{
name:string
age:number
}
type Student=Person&{grade:number} //这和类的继承是一模一样的，这样 Student 就继承了 Person 上的属性，

const s1:Student={
name:'zx',
age:12,
grade:12
}
// 联合类型 | 是指可以取几种类型中的任意一种，而交叉类型 & 是指把几种类型合并起来。

// 类型别名
// type name=string
// type nameResolve=()=>string
// type nameorResolve = name | nameResolve
// function getName(n:nameorResolve):name{
// if(typeof n === 'string'){
// return n
// }else{
// return n()
// }
// }

// getName('lin')
// getName(()=>'lin')

// type Name = string
// type arrItem = number | string
// const arr:arrItem[]=['123',23,'vvv']

// type Persons={
// name:Name
// }
// type Students=Persons & {grade:number} // 联合类型
// type Teacher=Persons&{major:string}
// type studentAndteacher = [Students,Teacher]//元组类型
// const list:studentAndteacher=[
// {name:'zx',grade:123},
// {name:'zz',major:'ddd'}
// ]

// type 和 interface 的区别
// interface Person{
// name:string
// age:number
// }
// const person:Person={
// name:"lin",
// age:124
// }
// type Person={
// name:string
// age:number
// }
// const person:Person={
// name:'lin',
// age:123
// }

// 两者相同点：都可以定义一个对象或函数、都允许继承;都可以定义一个函数
// 定义函数
// type addType=(num1:number,num2:number)=>number
// interface addTypes{
// (num1:number,num2:number):number
// }
// const add:addTypes=(num1,num2)=>{
// return num1+num2
// }

// 都允许继承
// interface Person{
// name:string
// }
// interface Students extends Person{
// grade:number
// }
// const person:Students={
// name:'lin',
// grade:123
// }

// type Person={
// name:string
// }
// type Students=Person&{grade:123}

// interface（接口） 是 TS 设计出来用于定义对象类型的，可以对对象的形状进行描述。

// type 是类型别名，用于给各种类型定义别名，让 TS 写起来更简洁、清晰。

// type 可以声明基本类型、联合类型、交叉类型、元组，interface 不行

// interface可以合并重复声明，type 不行

// 这两者的区别说了这么多，其实本不该把这两个东西拿来做对比，他们俩是完全不同的概念。
// interface 是接口，用于描述一个对象。
// type 是类型别名，用于给各种类型定义别名，让 TS 写起来更简洁、清晰。
// 只是有时候两者都能实现同样的功能，才会经常被混淆
// 平时开发中，一般使用组合或者交叉类型的时候，用 type。
// 一般要用类的 extends 或 implements 时，用 interface。
// 其他情况，比如定义一个对象或者函数，就看你心情了。

// 类型断言
// function getLength(arg:number|string):number{
// return arg.length //从上文可知，这么写会报错，因为 number 类型上没有 length 属性。
// }

// 这个时候，类型保护（Type Guards）出现了，可以使用 typeof 关键字判断变量的类型。
// function getLength(arg:number|string):number{
// if(typeof arg === 'string'){
// return arg.length
// }else{
// return arg.toString().length
// }
// }

function getLength(arg:number|string):number{
const str=arg as string
if(str.length){
return str.length
}else{
const number = arg as number
return number.toString().length
}
}
// 注意，类型断言不是类型转换，把一个类型断言成联合类型中不存在的类型会报错。
// function getLengths(arg:number|string):number{
// return (arg as number[]).length
// }

// 字面量类型
type ButtonSize='mini'|'small'|'normal'
type sex = '男' | '女'
// const sex:sex='不难'

// 作者：前端阿林
// 链接：https://juejin.cn/post/7068081327857205261
// 来源：稀土掘金
// 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。