js是动态类型弱类型语言，而ts是静态类型弱类型语言。
强类型语言：不允许改变变量的数据类型，除非进行强制类型转换。
弱类型语言：变量可以被赋予不同的值。
静态类型语言：在编译阶段确定所有变量的类型。
动态类型语言：在执行阶段确定所有变量的类型。
静态类型，基于语法解析TSDoc，ide增强使可读性增强。在编译阶段即可暴露出大部分错误，致使可维护性增强。因此使得ts在多人合作的大型项目中可以获得更好的稳定性和开发效率。
js的超集，简单来说，就是js的代码都可以在ts里面运行，因此也可以把ts理解为type+js。
npm i -g typescript
安装之后，在cmd中输入tsc -v ，如果出现了版本号，代表安装成功。
ts的数据类型有两种，一种是js原有的数据类型，一种是新增的数据类型
原始类型：number/string/bollean/null/undefined/symbol
对象类型：object（数组、对象、函数等）
js写法:
- let a = 'hhh'
- let b = 666
- let c = true
- let d = null
- let e = undefined
- let f = {name:'maobuhui'}
- let g = 100
- let h = Symbol()
ts写法:
- let a:string = 'hhh'
- let b:number = 666
- let c:boolean = true
- let d:null = null
- let e:undefined = undefined
- let f:object = {name:'maobuhui'}
- let g:bigint = 100n
- let h:symbol = Symbol()
（1）联合类型
let 变量: 类型1 | 类型2 | 类型3 .... = 初始值
let arr1 :number | string = 1 // 可以写两个类型
（2）自定义类型
type 别名 = 类型
type x = string // 定义
const str1:x = 'abc'
const str2:string = 'abc'
（3）数组类型
// 写法1：
let 变量: 类型[] = [值1，...]:
let numbers: number[] = [1, 3, 5] // numbers必须是数组，每个元素都必须是数字
// 写法2：
let 变量: Array<类型> = [值1，...]
let strings: Array= ['a', 'b', 'c'] // strings必须是数组，每个元素都必须是字符串
（4）函数
单个函数
// 普通函数
function 函数名(形参1： 类型=默认值， 形参2：类型=默认值,...): 返回值类型 { }
// 声明式实际写法:
function add(num1: number, num2: number): number {
return num1 + num2
}
// 箭头函数
const 函数名（形参1： 类型=默认值， 形参2：类型=默认值, ...):返回值类型 => { }
const add2 = (a: number =100, b: number = 100): number =>{
return a + b
}
// 注意： 箭头函数的返回值类型要写在参数小括号的后面
add（1,'1') // 报错
统一定义函数格式
const add2 = (a: number =100, b: number = 100): number => {
return a + b
}
function add1 (a:number = 100 , b: number = 200): number {
return a + b
}
// 这里的 add1 和 add2 的参数类型和返回值一致，
// 那么就可以统一定义一个函数类型
type Fn = (n1:number,n2:number) => number
const add3 : Fn = (a,b)=>{return a+b }
// 这样书写起来就简单多啦
（5）函数返回值类型void
function greet(name: string): void { console.log('Hello', name) //}
（6）可选参数
可选参数：在可选参数名的后面添加 ?（问号）
function slice (a?: number, b?: number) {
// ? 跟在参数名字的后面，表示可选的参数
// 注意：可选参数只能在 必须参数的后面
// 如果可选参数在必选参数的前面，会报错
console.log(111);
}
slice()
slice(1)
slice(1,2)
}
（7）对象类型
const 对象名: {
属性名1：类型1，
属性名2?：类型2，
方法名1(形参1: 类型1，形参2: 类型2)： 返回值类型,
方法名2:(形参1: 类型1，形参2: 类型2) => 返回值类型
} = { 属性名1: 值1，属性名2：值2 }
// 创建类型别名
type Person = {
name: string，
age: number
sayHi(): void
}
// 使用类型别名作为对象的类型：
let person: Person = {
name: '小花',
age: 18
sayHi() {}
}
(8)接口
当一个对象类型被多次使用时，有如下两种方式来来描述对象的类型，以达到复用的目的：
interface 接口名 {属性1: 类型1, 属性2: 类型2}
// 这里用 interface 关键字来声明接口
interface IGoodItem {
// 接口名称(比如，此处的 IPerson)，可以是任意合法的变量名称，推荐以 `I` 开头
name: string, price: number, func: ()=>string
}
// 声明接口后，直接使用接口名称作为变量的类型
const good1: IGoodItem = {
name: '手表',
price: 200,
func: function() {
return '看时间'
}
}
const good2: IGoodItem = {
name: '手机',
price: 2000,
func: function() {
return '打电话'
}
}
接口和类型 的区别 interface（接口）和 type（类型别名）的对比：
先有的 interface，后有的 type,推荐使用 type。
(9)接口继承
interface 接口2 extends 接口1 {
属性1： 类型1， // 接口2中特有的类型
}
interface a { x: number; y: number }
// 继承 a
// 使用 extends(继承)关键字实现了接口
interface b extends a {
z: number
}
// 继承后，b 就有了 a 的所有属性和方法(此时，b 同时有 x、y、z 三个属性)
（10）元组
元组是一种特殊的数组，可以限制数组的内容和长度。
基础用法
let x: [string,number]
x = ['a',123]
x = [123,'a']//error
x = [123,123,'a']//error
可选参数
let x:[string,number?]
x = ['a']
x = ['a', 123]
剩余元素
let x:[number,...string[]]
x = [123,"q","w","e"]
只读
let x:readonly[number,string] = [123,"q"]
//此时对x进行任何修改都会抛出异常
（11）any
let a:any = 123
a = "qwe"
let b
b = 111
let cc:any = "aaa"
console.log(cc.firname)//undefined
(12)字面量类型
字符串字面量类型：将字符串字面量作为类型
let sex = 'man' | 'woman'
boolen字面量类型
let type = true | false
number字面量类型
let num = 1 | 2 | 3 | 4 | 5