TS：解決大型項(xiàng)目，項(xiàng)目小不建議用ts；

????可以在編譯期間發(fā)現(xiàn)并糾正錯(cuò)誤【靜態(tài)檢查】

????強(qiáng)類型、支持靜態(tài)和動(dòng)態(tài)類型

????最終編譯成js代碼，使瀏覽器可以理解

JS：一種腳本語(yǔ)言，用于創(chuàng)建動(dòng)態(tài)網(wǎng)頁(yè)

????一種解釋型語(yǔ)言，只能在運(yùn)行時(shí)發(fā)現(xiàn)錯(cuò)誤

????弱類型，沒(méi)有靜態(tài)類型

????可以直接在瀏覽器中使用

ts它是不能直接在瀏覽器或nodejs環(huán)境中來(lái)運(yùn)行的，它是需要編譯成js才能被運(yùn)行

xxx.ts => tsc?命令來(lái)編譯?===> xxx.js

類型

內(nèi)置類型全小寫

let/const/var 變量名：類型 = 值

注：如果你在聲明變量時(shí)就給值，則可以不指定類型，ts可以自動(dòng)來(lái)推斷出來(lái)變量的類型

=字符串=

let arg = '張三'?arg不需要指定，自動(dòng)識(shí)別出是字符串類型

let arg：string

arg = '字符串'

=bigint=

let oneHundred:bigint = BigInt（100）；

=symbol類型=

let?s:symbol = Symbol（）;

let s:symbol

s = Symbol('key')

=數(shù)組=

字符串?dāng)?shù)組：數(shù)組里面的元素它的類型只能是字符串，不能是別的類型 （arr = [這里面只能寫字符串]）

let arr:string[ ]

arr = ['aaa','bbb']

通過(guò)泛型類定義數(shù)組元素值類型

let arr: Array<string>

arr = ['aaa','bbb']

ts接口interface兩個(gè)作用：一個(gè)為類所實(shí)現(xiàn)，一個(gè)定義類型

元素值是數(shù)字

let arr:number[ ]

arr = [1,2,3]

=元組tuple=

元組是數(shù)組的一種特殊形式，一個(gè)數(shù)組如果知道它的長(zhǎng)度且它里面每個(gè)元素的類型是已知的，則它就為元組 （一般定義成元組之后不能改變長(zhǎng)度和類型）

let tuple：[ string，number，boolean ]

tuple = [ ' a ', 1, true ]

=Any 與 Unknown=

都是可以賦值任意類型值，any沒(méi)有類型檢查，而unknown它是會(huì)有類型檢查，在使用時(shí)會(huì)進(jìn)行類型檢查

unknown還可以進(jìn)行類型轉(zhuǎn)換，而any不具備，定義成any就相當(dāng)于在ts中寫js了

????????????????===any

let arg1：any

arg1 = 1

arg1 = 'aaa'

arg1 = true

arg1 = { id:1 }

any在賦值和調(diào)用時(shí)，都不會(huì)進(jìn)行類型的檢查，相當(dāng)于寫js

console.log（arg1 +1）

?===unknown

let arg2：unknown

arg2 = 1

arg2 = 'aaa'

arg2 = true

arg2 = { id:1 }

unknown在賦值時(shí)可以給值，但在使用變量時(shí)，會(huì)進(jìn)行類型的檢查

所以就需要你在使用時(shí)，給unknown指定明確的類型?方法：斷言 as

console.log（arg2 +1）×

console.log（（arg2 as number） +1）√

;(arg2 as { id:number }).id??;的作用？

let age:string = '10'

let aa:number

// unknown 用來(lái)轉(zhuǎn)換類型，先將age轉(zhuǎn)成大范圍的類型，再轉(zhuǎn)成具體的類型

aa = age as unknown as number

==函數(shù)

定義一個(gè)沒(méi)有參數(shù)也沒(méi)有返回值的函數(shù)

1、沒(méi)有寫return??function?fn()?{?}

2、寫了return但只有return??function?fn()?{?return; }

3、寫了return但后面是 undefined

如果函數(shù)沒(méi)有返回值，可以給這個(gè)函數(shù)指定它沒(méi)有返回值?void

function fn(): void {

??return?undefined

??return;

}

定義一個(gè)函數(shù)它有參數(shù)，參數(shù)類型是指定的，且有返回值

function fn( id: number, name: string) :string {

??return?id + name?//字符串和數(shù)字相加一定會(huì)轉(zhuǎn)成字符串

}

//可選參數(shù) 給參數(shù)前面加一個(gè)? 表示當(dāng)前參數(shù)它是可選的，可以有也可以沒(méi)有

function fn( id: number, name ？: string) :string {

??// 類型斷言

??return?id + （ name as string ）?

??// 非空斷言，name值它一定有值，一定不會(huì)為undefined

??return?id + name ！

??// 類型收縮?typeof??instanceof in extends

??if （ typeof name === 'string' ）{

????return id + name

??return `編號(hào): ${ id } `

}

自動(dòng)類型

function?fn () {

??return?1

}

const fn = ()?=> 1

==對(duì)象類型

聲明了一個(gè)user變量，它的類型是一個(gè)對(duì)象，其中必須要有的屬性為id和name分類對(duì)象類型的number和string，二age屬性它是一個(gè)可選的，可以有也可以沒(méi)有有的話，類型一定要有number

let user:{ id:number; name:string; age?:number }

user = { id: 1, name: ' aaaa', age: 20 }

user = { id: 1, name: ' aaaa' }

數(shù)組對(duì)象，數(shù)組的元素它是一個(gè)對(duì)象

let users: { id: number; name: string; age?: number } [ ]

let users : Array<{ id: number; name: string; age?: number }>

users = [ { id : 1, name: 'aaaa', age: 20 }]

動(dòng)態(tài)屬性，此對(duì)象它必須要有id和name屬性，還可以有更多的其他屬性，其他屬性必須要滿足key是string類型，值是any任意類型

下面用any還是unknown取決對(duì)于類型的要求嚴(yán)不嚴(yán)格

let user: { id: number; name: string; [ key: string ]: any }

let user: { id: number; name: string; [ key: string ]: unknown }

user = { id: 1, name: 'aa', a: 2,b: { other: 'bbb' }, c: 'aaa' }

索引類型

let user: { id: number; name: string; [ key: string ]: any }

typeof user => 得到user變量它的類型

let id: ( typeof user ) [ ' id ' ]

==定義類型 type[ 類型別名 ] / interface

type定義類型方式，它可以定義任意類型情況

type userType =?{ id: string; name: string;?}

type userType =?{ id: string; name: string; age ?: number }

let user1：userType

let user2：userType

let id：userType[ ' id ' ]

let user = { id: 1, name: ' aa ' }

根據(jù)變量的值，來(lái)聲明一個(gè)類型

type userType = typeof user

把原來(lái)的string，相當(dāng)于起了一個(gè)別名，叫urlType

type urlType = string

type urlType = number

let url：urlType

url = ' aa '

給函數(shù)[ 賦值定義的函數(shù) ]的參數(shù)及返回值來(lái)限制類型?函數(shù)簽名

聲明一個(gè)函數(shù)類型，它必須要有兩個(gè)參數(shù)，參數(shù)1類型必須是number，參數(shù)2類型必須是string，返回值類型必須為string

注：參數(shù)的名稱，可以任意去起名稱，不重要

一流人才定義規(guī)則，二流去實(shí)現(xiàn)

type fnType = （ id：number， name：string） => string???// id 和 name 只是占位，名字可以隨便寫；重要的是類型

const??fn: fnType = （ id： string，name：string）=>?' aa '

type聲明的類型，名稱不能重復(fù)

type?t1?=?{ id：number }

typet?t1?=?{ name：string }

聯(lián)合類型

一個(gè)變量它可以擁有多個(gè)類型

type?idType = number | string?// 既可以傳數(shù)字也可以傳字符串

let?id: idType

id = ' a '

id = 1

type idType = number | string | boolean | null

// 根據(jù)上面已有的聯(lián)合類型，派生出一個(gè)新的類型

type newIdType = Exclude<idType, string | null> // 在指定的聯(lián)合類型中，排除掉不要的類型，生成一個(gè)新類型?【黑名單】

type newIdType = Extract<idType, string | null>?// 保留要的聯(lián)合類型，生成一個(gè)新類型?【白名單】

any 和 unknown在聯(lián)合類型時(shí)它的最終類型

返回的還是any和unknown

任何類型和any或unknown聯(lián)合時(shí)，最終類型都是any或unknown

type a = string | number | any

type b = string | number | unknown

*交叉類型

聯(lián)合類型的交叉，它只會(huì)取交集

type?t1 = number | string | boolean

type?t2 = boolean | string | boolean

type?t3 = t1 & t2 // 對(duì)于聯(lián)合類型的交叉，t3取 t1 和 t2的交集

對(duì)象類型，取的是并集

交叉類型，可以用它來(lái)完成對(duì)已有類型屬性的擴(kuò)展

如果在合并時(shí)，有相同的字段，則類型最好是一致的；如果不一致，則前面的類型一定要比后面的類型范圍要大

協(xié)變和逆變：讓類型可用

字面量類型

type lessonType = 'css' | 0 | 1 | true | { id: 1 } | ' hahaha '

let lesson: lessonType

lesson = 'css'??// 寫成上面的那些值任意的一個(gè)就不會(huì)報(bào)錯(cuò)，不是上面的就會(huì)報(bào)錯(cuò)

lesson = { id: 1 }

let objType = { id: number, name: string?}

let obj: objType = { id: 1, name: 'aaa' }

obj.id //不會(huì)報(bào)錯(cuò)

function getValue( obj: objType, key:?string ) {

???// key它可能不在你定義這個(gè)類型中?

???return obj [ key ]???// 會(huì)報(bào)錯(cuò)

}

let objType = { id: number, name: string ；age：number }

let obj: objType = { id: 1, name: 'aaa' ，age: 10 }

// 綠色的就是字面量類型

function getValue( obj: objType, key:?' id ' | ' name ') {

???// key它可能不在你定義這個(gè)類型中?

???return obj [ key ]???

}

never ts特有

此類型，一般你用不到，除非你寫ts很底層的方案

返回 never 的函數(shù)必須存在無(wú)法達(dá)到的終點(diǎn)