TS

1.js语言是动态弱类型语言 赋值各种类型不报错 函数有参数不传参调用，传多个参调用也不报错
2.ts是静态语言
---扩展了js的类型
---支持ES新特性
---添加ES不具备的新特性（抽象类，接口）
---丰富的配置选项
---强大的开发工具（类型检测，语法提示）
3.ts安装 npm i -g typescript
验证 tsc -v
ts文件转为js文件--->tsc ts文件名（在当前文件的路径下）
4.vscode插件
---chinese(vscode汉化)
---Live Server(本地服务器--html中右键open with live server，可以打开默认浏览器看效果)
5.自动类型判断
当对变量的声明和赋值同时进行时，TS编译器会自动判断变量类型
当变量的声明和赋值同时进行，可以省略掉类型声明
let a:numbrt
a= 12；
或者let a=12 也可以 (可以自动判断a的类型为number)
6.字面量声明
字面量(客观存在且无法改变的值，例如：1 2 3 4 5 true "hello")
字面量声明 let a=12;类似于js中const a=12;
7.any类型(表示任意数据类型，对该变量关闭了TS的类型检测)
显示声明：let a:any;a=12,a="89"
隐式声明：let a; a=90;a="999"
8.unknown类型（更健全的any类型）
let a:unknown;
a=123;
a=true;
let b:boolean;
b=a(报错)
if(typeof a==="boolean"){b=a} --a,b输出都是true
9.ts类型断言
if(typeof a==="boolean"){b=a}
b=a as boolean (当a是boolean时，对b进行赋值)
10.ts中的函数
函数中形参要定义类型，传参时多传少传都会报错
函数的返回值
未定义返回值的时候 返回值为undefined
function fun(){}--->返回undefined
function fun():number{}--->返回number
function fun():void{}--->返回空
function fun():void{
return 123--->报错
return "123"--->报错
return true --->报错
return NaN--->报错
return null ---->ok
return undefined--->ok
return ;---->ok
}
function fun():never{ --->使用较少
throw new Error('出错了')
//程序报错代码立即结束，结束之后不会有返回值
}
11.对象类型声明
let a:object; a={}; a=function(){}
let b:{name:string} //对象中的属性不能多不能少
若是对象中的部分属性（age，sex）不确定是否存在
let c:{
name:string, 包含属性name
age?:number,可能包含age
sex?:string 可能包含sex
}
只知道必须的属性，不必须的属性不知道
let propName:string;
let d={
name:string,
[propName:string]:unknown
}
propName:string--->任意的属性名
12.数组

let arr：string[];
arr[0]="ss"---->ok
arr[1]=12----->报错

let b:Array
b[0]="sd"---->报错
b[1]=false--->ok

13.tuple类型 元组(定长的数组，因为固定长度,存储效率好,不会出现扩容的现象,效率高点)
let a:[string,boolean,number];
a=["12",false,123] --->ok，多一个少一个元素报错
14.Enum(枚举)
enum 枚举名称{成员1，成员2.....}(成员数量不定)

enum a{
  male,
female
}
console.log(a.male)--->0
console.log(a.female)--->1

数字枚举

enum a{
  male = 3,
female
}
console.log(a.male)--->3
console.log(a.female)--->4

字符串枚举

enum a{
  red = "红",
yellow="黄"
}
console.log(a.red)--->红
console.log(a.yellow)--->黄

15.联合类型声明
let a:number|string (a既可以是number又可以是string)
a=123---->ok
a="123"---->ok
16.ts类型别名
type myType=1|2|3|4|5|6|7|8|9|10;
let a:myType;
let b:myType;
这样呢，a，b就和myType一样的类型和值
16.ts的配置---自动编译文件
tsc 文件名 -w (自动编译文件的命令)
17.在文件夹下新建文件：tsconfig.json
执行 tsc -w,这样tsconfig.json的根目标下所有的ts文件都可以被编译
18.tsconfig.json的配置
include：定义希望被编译文件所有的目录
{
//只编译dev目录下面的
“include”:["./dev//"] //：任意目录，：任意文件
//定义不需要编译的目录
“exclude”:["./prop/*/"]
//继承其他文件的配置
“extends”：“./config/base”
//指定需要编译文件的列表
“files”:one.ts,two.ts
}
19.complierOptions
----target:默认（ES3）,"ES5","ES6/ES2015","ES2016","ES2017"或“ESNext”
----module:指定使用的模块化规范(可选值：“none”,"commonJs","AMD","System","UMD","ES6"或者“ES2015”)
只有"AMD"和"System"能和--outFile一起使用
“ES6”和“ES2015”可使用在目标输出为“ES5”或更低的情况
----lib指定编译过程中需要引入的库的文件列表
----outDir:用来指定编译后文件所在的目录
----outFile:将编译的代码合并成一个文件（多个ts文件打包成一个ts文件）
-----allowJs:(默认false)是否对js文件进行编译，是否编译合并到outFile文件中
-----checkJs:(默认false)检测js代码是否符合语法规
-----removeComments:编译得时候是否删除注释内容 true--删除 false--不删除
-----noEmit 不生成编译后得文件 true--不生成 false--生成
----noEmitOnError当存在语法错误时候，不生成编译后得文件
----awaysStrict编译后得代码是否使用严格模式 true--是(编译后的文件头部有“use strict”)，false--否
注释：当代码使用了模块化的模式时，会使用严格模式awaysStrict为false也是如此
----noImplicitAny不允许隐式的any类型
----strictNullChecks严格的检查空值
----strict所有严格检查的总开关
20.直接运行ts的配置
全局安装ts-node （npm i -g ts-node）
ts-node -v:查看ts-node版本
ts-node 文件名---->编译运行ts文件
21.面向对象
程序中特定的操作要通过各种对象来操作
操作浏览器---->windows对象
操作网页---->document对象
操作控制台---->console对象
---程序中的对象
22.ts中的类
创建类---->关键字class

class Person{
  static  readOnly  name:string;
  age:number
}
实例化
let men=new Person();（不传参数的时候可以不用()）

静态修饰符---->static
被static修饰的属性或者方法 属于类 不属于实例 实例无法调用 只有类可以调用
readOnly---->属性只能读取不能修改
23.构造方法

class Person{
  name:string;
 constructor(){console.log(this.name)}
}

以方法的形式进行调用的时候---->this指向window
以对象的形式进行调用的时候---->this指向被调用的对象
当实例化对象的时候会自动调用constructor这个构造方法，所有用constructor可以给类赋初始值
24.继承
class Dog extends Animal{}
25.ts的重写()
直接在子类中重写父类的属性和方法
26.super关键词 指父类，超类
通过super可以在子类中调用父类中的方法

class Dog extends Animal{
age:number;
  sleep(){
    super.sleep();---->子类继承父类的sleep方法  
 }
 constructor(name:string,age:number){
   super(name);  --->继承父类的constructor且有初始化参数
   this.age=age  --->子类新增参数
 }
}

如果子类中写了构造方法，在子类的构造方法中必须调用父类的调用方法。子类不写构造函数，父类就自动调用，子类写，会把父类的构造函数覆盖，所以必须调用父类构造函数。
27.ts中的抽象类
以abstract开头的类被称为抽象类
abstract class Animal{
name:string="抽象类";
abstract sleep():void;--->抽象方法没有方法体，没有实现
}
let dog=new Animal()---->报错，无法创建抽象类的实例
注意：1.抽象类只能被继承，不能初始化一个实例;
2.子类继承抽象类，必须重写抽象类中的所有抽象方法，如果不重写，那么这个类也应该是抽象类
28.ts的接口--->用来定义一个类结构，定义一个类中应该包含的属性和方法。接口也可以当成类型声明去使用，接口可以重复声明，取所有相同接口名的并集
interface 接口名

interface myInterface{
  name:string;
  sleep():void;  --->接口中的方法默认都是抽象方法，没有方法体
}
let b:myInterface;--->通过接口声明一个变量
b={
  name:"xdclass",
  sleep(){
   console.log('xd')
  }
}

一个对象继承一个接口--->
class Person implements myInterface{}
29.ts中属性的封装
属性修饰符
---- public:可以在任意位置访问，是默认值。
---- private:私有属性，只能在类的内部进行访问，子类或者其他地方都不能访问。通过在类中添加方法使得私有属性可以被外部访问。
---- protected:受保护的属性，只能在当前类中被访问
属性的封装 setAge getAge 保证属性不能随意被赋值
属性存取器 getter读取属性，setter设置属性
30.ts中的泛型
定义一个函数，把传入的参数并返回回去
function cache(prop:string):string{
return prop
}
在定义函数或者类的时候，如果遇到类型不明确的就可以使用泛型，泛型就是一个不确定的类型<任意一个大写的字母>
function cache(prop:T):T{
return prop
}
----泛型约束：指定泛型的类型
let a=cache('true')
----多个泛型
function cache(prop:T,flag:P):T{
return prop
}
---泛型在接口中的使用

interface myInterface{
name:T;
}
class Person implements myInterface{
  name:T;
 age:P;
constructor(name:T,age:P){
  this.name=name;
this.age=age
}
}
let  obj=new Person("张三"，30 )