一、安装解析ts的工具包
node.js只认识js代码，不认识ts代码。
需要将ts代码转化为js，然后就可以在node.js中运行了。
安装步骤：打开终端，输入命令npm i -g typescript回车
typescript是用来解析ts的工具包。提供了tsc命令，实现了ts-js的转化。
二、ts的使用
1.使用步骤
1.创建ts文件
2.写代码
3.执行代码
在当前目录打开终端，输入命令tsc hello.ts，会生成一个hello.js文件
执行js代码：输入命令node hello.js
2.简化执行ts的步骤
每次修改代码后，都要重复执行两个命令才能执行ts代码。
简化方式：使用ts-node包，安装命令：npm i -g ts-node
ts-node包内部将ts--js，然后执行js代码。
ts-node包提供了命令ts-node，用来执行ts代码。
3.使用ts-node时遇到的的问题
ts-node : 无法将“ts-node”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写，如果包括 路径，请确保路径正确，然后再试一次。
解决办法：配置环境变量
Warning: To load an ES module, set "type": "module" in the package.json or us
e the .mjs extension.
(Use `node --trace-warnings ...` to show where the warning was created)
export {};
^^^^^^
SyntaxError: Unexpected token 'export'
解决办法：在ts文件内部最后一行加上export{};
4.优化编译（可以不用）
tsc --init命令 解决ts和js冲突问题，生成tsconfig.json文件
tsc --watch 自动编译
tsc --noEmitOnError --watch命令 在出现错误的时候不编译成js文件，直到问题解决
三、变量和数据类型
1.变量
存储数据的容器，并且是可以变化的。
2.变量的使用
声明变量并指定类型，给变量赋值。
3.类型注解
是为变量添加类型约束的方式。：数据类型
4.变量的命名规范
变量名称只能出现数字、字母、下划线_，美元$，并且不能以数字开头。
变量名称区分大小写。
变量名称要有意义，顾名思义。
使用驼峰命名法。
5.TS的数据类型
ts支持js的所有数据类型，同时还增加了额外的数据类型：any、unknown、void、函数、类、接口、枚举等
a.基本数据类型
number：用于表示数字，包括整数和浮点数。
string：用于表示文本字符串。
boolean：用于表示真（true）或假（false）。
null：表示空值或无效值。
undefined：表示未定义的值，变量声明后未赋值时默认为 undefined。
void：用于表示没有任何类型，通常用于函数没有返回值的情况。
//1.布尔值：最基本的数据类型就是boolean的true/false值，
let isDone:boolean=false;
//2.数字：支持十进制和十六进制二进制八进制
let decLiteral:number=6;
let hexLiteral:number=0xf00d;
let binaryLiteral:number=0o744;
//3.字符串：可以使用模板字符串并以${}的形式嵌入表达式
let name1:string="bob";
name1="smith";
let name2:string="gene";
let age:number=37;
let sentence1:string=`hello,my name is ${name2},I will be ${age+1} years old next month`
let sentence2:string="hello,my name is"+name2+".\n\n"+"i will be"+(age+1)+"years old next month."
let n: null = null;
let u: undefined= undefined;
function logMessage(message: string): void {
console.log(message);
}
export{}b.复杂数据类型 (数组，元组，枚举)
array：数组类型，可以存储同种类型的多个值。可以使用 T[] 或 Array<T> 表示数组类型。
tuple：元组类型，允许存储不同类型的值，固定长度。
enum：枚举类型，定义一组命名常量。
//1.数组:可以在元素类型后面接上[],表示由数字类型元素组成的一个数组
let list1:number[]=[1,2,3];
let list2:Array<number>=[1,2,3]
//2.enum枚举:可以为一组数值赋予名字，枚举表示的是一个命名元素的集合值
enum user{zhangsan,lisi,wangwu};
console.log(user.zhangsan, user.lisi, user.wangwu)//默认情况下数据的值从0 开始,0,1,2
enum user1{zhangsan,lisi=99,wangwu }
console.log(user1.zhangsan, user1.lisi, user1.wangwu);//0,99,100
enum user2{zhangsan,lisi="李四",wangwu="王五"}
console.log(user2.zhangsan, user2.lisi, user2.wangwu);//0 李四 王五
//3.tuple元组：用来表示已知元素数量和类型的数组，各元素的类型不必相同，对应位置的类型需要相同
let x:[string,number];
x=["hello",10]
let person: [string, number] = ["Alice", 30];
export{}c. 特殊数据类型（any,unknown,never）
any：表示任意类型，禁用类型检查，适用于不确定类型的值。
unknown：与 any 类似，但更安全，必须在使用前进行类型检查。
never：表示永远不会有值的类型，通常用于函数抛出异常或无限循环的情况。
//1.any所有类型，任何类型，
let notSure:any=4;
notSure="maybe a string instead";
notSure=false;
//有一个数组，包含了不同类型的数据
let list3:any[]=[1,true,"free"];
list3[1]=100;
//2.unknown 未知类型，没有类型
const n:number=1;
const n1:any=n;
const n2:unknown=n;
//any和unknown类型的区别：变量n1具有any类型，表示n1可以是任何类型，可以对n1做任何操作，即使是n1是number类型，n1.push的调用依然不会报错，这样会失去typescript带来的类型安全性，不推荐使用any，
//而n2具有unknown类型，它表示n2是未知类型（没有类型）所以n2不支持任何操作，所以在某些场合，使用unknown，可以限制某些变量的行为，使编码更加谨慎
//3never：表示永远不会有值的类型，通常用于函数抛出异常或无限循环的情况。
function throwError(message: string): never {
throw new Error(message);
}
export{}d. 自定义数据类型(interface,type)
object：表示非原始类型的对象。可以是任何类型的对象（不包括原始类型如 number, string, boolean 等）。
接口（interface）：用于定义对象的结构。
类型别名（type）：用于为类型定义一个新名称。
//自定义类型
let obj: object = { name: "Alice", age: 30 };
//1、接口interface 接口名{键：类型}
//自定义函数类型
interface IPerson{
name:string;
readonly sex:string|number;
age?:number;
eat:(food:string)=>void
}
//定义函数变量，并给函数赋值
let p01:IPerson={
name:"张三",
sex:"男",
eat:function(food:string):void{
console.log("吃"+food);
}
}
p01.name="张小三",
p01.age=12;
p01.eat("油条");
console.log("p01",p01);
//1.2、接口的继承：extends
interface IPerson1{
name:string,
age:number
}
interface Iprogrammer extends IPerson1{
language:string
}
let p02:Iprogrammer={
language:"js",
name:"李四",
age:12
}
console.log("p02",p02);
//简单模拟createRouter()函数的参数的类型
//路由配置
interface IRoute{
path:string,
name?:string,
component:()=>string
}
//创建路由对象
interface IRouterOptions{
history:()=>string,
routes:IRoute[]
}
//2、type
//interface只能定义对象类型，而type声明可以声明任何类型，包括基础类型，联合类型
type TPerson={
name:string,
readonly sex:string|number,
age?:number,
eat:(food:string)=>void
}
let p03: TPerson
p03={
name:"张小三",
sex:"女",
age:12,
eat:function(){}
}
type MyType=string|number|TPerson;
let temp:MyType;
type TAge=number;
let age1:TAge=12;
console.log("p03",p03);
export{}e. 联合类型和交叉类型
//交叉类型：将多个类型合并为一个类型
type IPerson2={
name:string,
age:number
}
type Iprogrammer2={
language:string
}
type IMy=IPerson2&Iprogrammer2
let p2:IMy={
language:"js",
name:"张三",
age:12
}
console.log("p2",p2);
//联合类型：一个变量的取值可以是多种类型
let temp2:string|number
temp=12;
temp="hi";
export{}6. 函数的类型限定
//函数：对函数的限定，能够限定形参的类型，返回值的类型（限定输入和输出）形参：输入；返回值：输出
//一、声明式function 函数名（参数：类型）：返回类型 {函数体}
function sum (x:number,y:number):number{
return 123;
}
//二、表达式
//1、定义和赋值分开，定义一个变量，变量是函数
//1.1.let 变量：输入类型=>输出类型
let show:(m:number,n:string,a?:string)=>number;
//1.2.给变量赋值(相当于定义函数)
show=function(t:number,s:string){
return t;
};
//1.3.调用函数
let b=show(12,"23","12")
//2定义的同时赋值 let 变量：输入类型=>输出类型=function(参数){}
let show1:(a:number,b:string)=>number=function(a,b){
return a;
}
//三、接口定义函数类型
//1.自定义函数类型
interface Func{(a:number,b:string):boolean};
//定义函数变量，限定类型为Func,并且给函数赋值
let show2:Func=function(a:number,b:string){
return true;
}
//调用函数
show2(12,"hi")
function fn():void{
//void类型修饰函数返回值时，表示函数不能有任何返回值return
}
//四、可选参数
//函数表达式，定义的同时赋值， let 变量：输入类型=>输出类型=function(参数){}，可选参数必须写在参数列表的最后
let show3:(a:number,b:string,c?:string)=>number=function(a,d){
return a
}
//五、参数默认值
function fn1(a:number,b:number=2):void{
console.log(a,b);
}
fn1(12,23);
fn1(12);
//六、剩余参数(弹性参数)得到的值是数组
// function fn2(a:number,...b):void{
// console.log(a,b);
// }
// fn2(12,23,34,45)
export{}
四、类型断言
类型断言是告诉编译器某个值的确切类型。在某些情况下，TypeScript可能无法推断出变量的类型，或者你知道某个值的类型与编译器推断的不一样。类型断言不会影响运行时行为，它仅在编译时起作用。类型断言可以用两种方式表示：
1.使用尖括号语法
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
2.使用 as 语法
let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;
类型断言的注意点：类型断言不做类型转换；自定义类型也可以用来做断言；权重最低
