優勢：類型檢查，語言擴展，工具屬性

強類型語言：不允許改變變量的數據類型，除非進行強制類型轉換
弱類型語言：變量可以被賦值不同的數據類型

靜態類型語言：在編譯階段確定所有變量的類型
動態類型語言：在執行階段確定所有變量的類型

(js：動態弱類型語言)
ts是以JavaScript構建的語言，js的超集。

開始步驟
進入項目 初始化 npm init -y
1.全局安裝typescript npm i typescript -g
安裝完后就可以使用ts的編譯器tsc
2.tsc --init
tsc ./src/index.ts
npm i webpack webpack-cli webpack-dev-server -D

ts數據類型有：
boolean，number，string，array，function，object，symbol，null，undefined，viod，any，never，元組，枚舉，高級類型

類型注解(類似強類型語言的類型聲明)：
（變量/函數）：type
基本類型

//原始類型：
let num:number=1
let str:string='hello'
let bool:boolean=true

//數組
let arr:number[]=[1,2,3]
let arr2:Array<number | string>=[4,5,66,'9']


//元組，特殊的數組，限制了數組的類型和數量
let tuple:[number,string]=[1,'iu']

//函數
let sum =(a:number,b:number)=>a+b
console.log(sum(3,4))

//對象
let obj:object={a:1,b:'hello'}
//obj.a=2 //不允許直接改
let obj2:{a:number,b:string}={a:1,b:'hello'}
obj2.a=2


//symbol:每個從Symbol()返回的symbol值都是唯一的。一個symbol值能作為對象屬性的標識符；這是該數據類型僅有的目的
let sym1:symbol=Symbol()
let sym2=Symbol()

//undefined,null
let un:undefined=undefined
let nu:null=null
//如果要將其它數據類型賦值undefined或null毀報錯，解決方法聯合聲明
let num2 :number |undefined |null =9
num2=undefined

//void:運算符 對給定的表達式進行求值，然后返回 undefined
//void 運算符通常只用于獲取 undefined的原始值，一般使用void(0)（等同于void 0）
 function noreturn(){}
 let voo=void 3
console.log(void noreturn(),voo)//undefined undefined

//any:任意類型，跟在js中使用差不多
let an
an=9
an="hello"

//never:永遠不會有返回值類型。比如拋出異常和死循環函數

枚舉類型
枚舉：一組有名字的常量集合。

對象的類型注解
約束對象的結構

//對象的類型注解,注意是冒號和分號，分號可以省略
let person:{
    name:string;
    age:number
     sayHi:()=>void
    sayName:(name:string)=>void
    sum:(num1:number,num2:number)=>number
}

person={
    name:'lucy',
    age:18，
   sayHi(){
        console.log('hi')
    },
    sayName(name:string){
        console.log(name)
    },
    sum(num1,num2){
        return num1+num2
    }
}

缺點：結構相同不能復用
接口
關鍵字：interface
作用：約束對象 函數 類的結構；規范對象的屬性 屬性的類型 屬性值的類型

interface List{
    id:number,
    name:string
}
interface Result{
    data:List[]
}
 function render(result:Result){
     result.data.forEach(value => {
         console.log(value.id,value.name)
     });
 }
 let result={
     data:[
        {
            id:1,
            name:"chen1"
         },
         {
            id:2,
            name:"chen2"
         },
     ]
    
    }
 render(result)

當不確定接口中屬性個數時需要使用 索引簽名,索引簽名包括字符串索引簽名和數字索引簽名

//數字索引
 interface StringArray{
     [index:number]:string
 }
 let cat:StringArray=['lucky','tom','biubiu']

 //字符串索引
 interface Names{
     [x:string]:string;
 }
 let fruit:Names={
     "cc":"98",
     "ll":""
 }
//當接口中定義了一個索引后，例如設置了 【x:string】= string，就不能設置y：number了。
//因為設置了【x:string】= string相當于這個接口的字符串索引返回值都是字符串，而y：number違背這一原則，沖突了。反過來 如果定義了【x:string】=Number, 就不能設置 y:string了。
//可以同時使用兩種類型的索引，但是數字索引的返回值必須是字符串索引返回值類型的子類型。
//因為 數字索引或轉化為字符串索引，而轉化的這部分索引對應的值的類型范圍 超過了 字符串索引類型的范圍，就會報錯，相當于超出范圍。

函數

//定義函數
 //1變量
 let add:(num1:number,num2:number)=>number
 //2接口
 interface Add{
     (num1:number,num2:number):number
 }
 //3類型別名，type關鍵字
 type Sum=(num1:number,num2:number)=>number
//實現具體函數
 let addfn1:Sum=(a,b)=>a+b
 let addfn2:Add=(a,b)=>a+b

 //混合類型接口：既可以定義函數，也可以像對象一樣可以有屬性和方法
interface Libs{
    ():void
    version:string
    doSomething():void
}
let lib:Libs=(()=>{})as Libs//用到類型斷言，不然報錯
lib.version="1.0.0"
lib.doSomething=()=>{
    console.log('hi,ts')
}

//封裝，使之復用
function getLib(){
    let lib:Libs=(()=>{})as Libs//用到類型斷言，不然報錯
    lib.version="1.0.0"
    lib.doSomething=()=>{
        console.log('hi,ts')
    }
    return lib
}

let lib1=getLib()
lib1.doSomething()