TypeScript

   js的升级版，向JS中引入了类型的概念，并添加了许多新的特性。

​ 相对比JS，TS拥有了静态类型，更加严格的语法，更强大的功能；TS可以在代码执行前就完成代码的检查，提示错误的代码，这也是我喜欢他的地方，当然ESLint可以，就看你用不用，哈哈

1、类型声明（泛型）

1 、通过类型声明可以指定TS中变量（参数、形参）的类型添加约束

   let a:string='123'     //指定变量类型
             
              指定参数类型 和 返回数据类型
              function fn(a:number,b:number):number{
                     return  a+b        //返回必须是number类型
              }
                      fn(1,2)

2、 指定类型后，当为变量赋值时，TS编译器会自动检查值是否符合类型声明，符合则赋值，否则报错

            let a:number
               a='123' //提示变红

（1）类型：

           number(数字)、string（字符串）、boolean（true、flase）、字面量、  any(任意类型)、unknown
           void（空或者undefined）、never(不存在任何值)、object(对象)、
           array（数组）、tuple(固定长度数组) 、enum(枚举，TS中新增类型)   

number

string

boolean

let a:boolean
    a=true
    a=false
   

字面量创建变量

      可以使用字面量去指定变量的类型，通过字面量可以确定变量的取值范围

       语法：
              变量:类型
        // 可以使用 | 来连接多个类型
         let 变量名: 类型|类型   //|  与
          let a:number|string
              a=123
              a='拓海'        

any(任意类型)

显式any
        let a:any
            a:123  
            a:'123'
            a:'false'
 隐式 any ts的解析机制会自动给没指定类型的变量添加any
         let b
             b:123
             b:false 
           

unknown(未知)

   安全的any

let e=unknown
    e=122
    e="123"
    e=false

void空

   //变量为空
   let a:void
       a=null
       a=undefined
   

never

// never 没有任何返回值  
function error(message: string): never {
    throw new Error(message);
  }

object

// 指定对象类型 (不实用)
let b: object
b = {}
b = function () { }

// 一般都是用来限制对象的属性类型
// 语法:
//   {属性名:属性值}
//    必须一一对应
// 加上问好属性是可选的  ?
let a: { name: string, age?: number }
a = { name: "小面馆", age: 19 }   //加?号后age可写可不写


//   添加任意类型
let c: { name: string, [propNmae: string]: any }
c = { name: "小明", age: 18 }

// 设置函数结构的类型声明
// 语法:(形参:类型,形参:类型)=>返回值
let g: (a: string, b: number) => number

g = (name: '小明', sge: 18): number => {
    return 10
}

array

// array类型声明：
//   语法:
//  类型:[]
//  Array<类型>

// 指定数组里面都是字符串
let e: string[]
e = ['1', '2']

//    表示数组里面是数字

let l: number[]
l = [1, 2, 3]

//    数字里可以是任意类型
let o: any[]
o = [1, '1', {}]

//   也可以这样表示  
let G: Array<number>
G = [1, 2, 3]

tuple元组

// 元组，固定长度的数组
        //   语法:[类型，类型]
let k: [string, string]
//   k=['1', 'a' ,123]   //长度只能为2

enum

enum Color {
  Red,
  Green,
  Blue,
}
let c: Color = Color.Green;

enum Color {
  Red = 1,
  Green,
  Blue,
}
let c: Color = Color.Green;

enum Color {
  Red = 1,
  Green = 2,
  Blue = 4,
}
let c: Color = Color.Green;

（2）类型断言

     有时候，解析器不知道变量的类型是啥，可以通过类型断言解析器变量的类型

**
**

let e:unknown
    e=2
    e=true

    let a:string='123'
    // 断言告诉解析器他是啥类型
       a=e as string
       a=<string> e