Typscript学习笔记第一天（原始类型和对象类型）

一、基础类型

string：类型

写法：

let str：string='TypeScript'

支持ES6的模板字符串`web{$str}`

number:类型

写法：

let num：number=124

可以是nan可以是16进制数，也可以是infinity（无穷大）

boolean：类型

写法：

let boo:boolean=fales (true)

void：类型（空）

写法：

let vo:void=null(undefined)

function voidFun():void{

        return()//会报错

}

这一块比较灵活，可以是，但不建议这样写，注意代码规范

let vode：undefined=undefined

let unde：null=undefined

let unde：undefined=null

这里注意一点，void不能给子类赋值，但undefined可以

let vod:vode=null
let nul:null=null

let a=vod //这里会报错
let a=nul //这里不会报错

二、顶级类型（any和umknown）

1.any类型可以任意赋值不做限制，例如

let Any:any(unkonwn)=12

any='string'

any=fales

any=boolean

any=[]

说一下他们的区别，any比unknown更安全，当他们同时为一个对象的时候，any可以访问其内部元素。unknown不可以

let obj:any={a:1}

console.log(a); //报错

let obj:unknown={a:1}

console.log(a); //正确

unknown不能调用属性和方法，还有unknown类型只能作为父类型，不能二次赋值，如果非要赋值的话，可以把类型改为unknown

let data:any='我月薪一个W',

let str：string='你可能没睡醒'

let known：unknown='我月入二千七，天天笑嘻嘻'

any=str  //这样是不会报错的

konwn=str  //这里会报错

三、Object、object、{}的区别

Object与原型链有关，他可以接收任何的原始数据类型和对象数据类型

let a:Object=1
let a1:Object="1"
let a2:Object=[]
let a3:Object=fales

object一般用于泛型约束，代表非原始类型的类型，比如string，unmber，boolean这些都是原始类型，可以是数组，对象，函数

let a:object='字符串' //会报错

let a1:object=[] //正确的

let a2:object={} //正确的

let a3:object=()=>{} //正确的

{}可以理解为new object，他也是支持所有的数据类型

let a:{}=1
let a1:{}="1"
let a2:{}=[]
let a3:{}=fales

四、interface 定义对象关键字

当我们需要在ts里定义一个对象时，需要用interface做一个类型约束

interface A={
    num:number
    //根据返回值定义类型
    fun():number{}
}

let obj=A{
    //因为A里面有一个key时数字类型，所以obj这个对象里就必须有
    num:12
    fun(){
        return:12
    }
}

也可以是组合式的引入两个interface，默认是必须存在,需要用到extends，用法是在interface 名称后加一个extends 再跟上另一个interface的名称

interface A={
    num:number
}

interface A={
    str:string
}

interface B extends A={
    boo：boolean
}

let obj=B{
    //因为A里面有number类型和string类型，所以这个obj里面也必须要有
    str:'何时月入W'
    num:12
    boo:fales
}

但在实际开发中，可能会出现那种选填的情况，这时候就需要用到可选试操作符 ？ ,写在：的前面

interface A={
    num:number
    //str选填(在冒号前写一个?)
    str?:string
}

let obj=A{
    //因为A里面有number类型和string类型，所以这个obj里面也必须要有
    str:
    num:12
}

[propName:String]:any还有一种情况是，不知道后端返回什么类型的数据，这时候就需要用到这个内置属性,后边这any就代表这个对象里的属性可以是任意类型，如果是striing，那么这个对象里就必须都是string。但开发需要既是string又是number的话，可以用|连接

interface A={
    num:number
    //str选填(在冒号前写一个?)
    str?:string
    [propName:String]:any
}

let obj=A{
    //因为A里面有number类型和string类型，所以这个obj里面也必须要有
    str:
    num:12
    //在A中没有定义布尔这个属性，但不会报错
    bool:true
}


//--------------------------------------------------------------------------//
interface A={
    num:number
    //str选填(在冒号前写一个?)
    str?:string
    //对象里只能是string和number
    [propName:String]:string|number
}

let obj=A{
    //因为A里面有number类型和string类型，所以这个obj里面也必须要有
    str:
    num:12
    //在A中没有定义布尔这个属性，但不会报错
    bool:true
}

readonly ：设置只读属性。在对象后边加上这属性后，属性的值就不能修改了

interface A={
    num:number
    str:string
}

let obj:readonly=A{
    num:1
    str:'月入W'
    
}

obj.num=2 //这里会报错