js的类型：

7种基本类型：boolean,number ,string ,null,undefined,symbol(es6),bigint(es10) 2020.

引用类型obj:arry,function,date

ts新增类型：

tuple 元祖

nver

any

void

其他高级类型

：+类型名字  类型注解

重新定义类型会报错

类型不同不能相互赋值

null只能赋值给null,undefined只能赋值给undefined  null不等于undefined;

Symbole()独一无二的变量 命名冲突，私有属性  拿它解决

BigInt(322223112333);  number类型有精度限制，这个就是为了解决这个问题。大数不会失真

Tsconfig  target: ESNext   module:ESNext 

数组  :string[]   : Array<number|string>   联合类型

元组 是特殊的数组  tuple:[string,number,boolean]=['a',1,false];

tuple.push('abc')

tuple[2]  能加不能读，不能够越界，必须要是要一一对应

函数

fun1:(params:string)=>boolean=()=>false

function fun2(params:string):boolean{return false}

type Fun=(params:string)=>boolean;  类型定义可复用

const fun1:Fun=()=>false;

const fun3:Fun=()=>true;

对象

const obj:object={a:1,b:2,}工作中不这样定义 ，因为object比较泛，有点类似any了，类型越具体越好

const obj1:{a:string,b:string}={a:'1',b:'2'}

interface Obj {a:string,b:string}

const obj1:Obj={a:'1',b:'2'}

void 没有任何返回值

const v=():void=>{}

any;如果都是any就和javascript没有区别了

没有加类型注解没有加：默认就是any的 可以随便的赋值  尽量别使用any，使用any就放弃了类型的好处

let x;

x=1;

never  永远不会有返回值    在业务代码中很少用never   高级类型编程的时候会用到

const n1=():never=>{throw new Error()} 

const n2=():never=>{while(true){}}  死循环卡这儿了

tuple

push可以突破限制，但是读取不到

const arr: [number,string] = [1,'test'];

arr.push(66);

arr[2]; // 语法错误

函数类型：箭头函数（推荐）+ 函数语句

类型别名 

type Func = (p:string) => boolean;

const func1: Func = ('test') => true;

function func2(p:string):boolean{

    return true

}

any: 任何类型，放弃类型检查

never：永远没有返回值

const f1 = () :never  => {

    throw new Error() // 终止进程

    // 或者

    while(true){

        //  无限循环

    }

}

js和ts类型

// 数组
const arr1:string[] = ['a','b','c'];
const arr2:Array<number | string> = ['a',3,5];

// 元祖--严格按照顺序，一一对应
const tuple: [string,number] = ['a',3]

// 函数
// 1.箭头函数
type Fun = (params:string)=>boolean;
const fun1:Fun = ()=>false;
// 2.函数语句
function fun2(params:string):boolean{
return false;
}
// 没有返回值--void
const v=():void =>{}

// 对象
interface Obj {a:string,b:string}
const obj:Obj = {
a:'1',
b:'2'
}

定义数组、函数

TS 变量声明格式：变量名 + 类型注解。

当变量赋值与声明类型不一致的时候，TS 会提醒类型校验不一致。

const aNum: number = 123; // 数字类型
const aStr: string = 'Hello ts'; // 字符串类型
const aBool: bool = true; // 布尔类型
const aNull：null = null; // null 类型，值只能是null
const aUndefined: undefined = undefined; // undefined 类型，值只能是undefined
const aSymbol: symbol = Symbol(); // symbol 类型，表示独一无二，每次声明的数据都是不同的
const bSymbol: symbol = Symbol(); // 用作私有属性、解决命名冲突问题
console.log(aSymbol === bSymbol); // 输出 false
console.log(Number.MAX_VALUE); // JS 支持的最大数值：Number.MAX_VALUE
const aBigint：bigint = 123456789123456789n; // 处理比JS支持最大的数还大的数值
const bBigint: bigint = Bigint(123456789123456789); // 两种定义Bigint 变量的方法
const sArr: string[] = ['a', 'b', 'c']; // 字符串数组
const nArr: number[] = [1, 2, 3]; // 数字数组
const bsArr: Array<string> = ['a', 'b', 'c']; // 包装类型
const bnArr: Array<number> = [1, 2, 3]; // 包装类型
const lhArr: Array<number | string> = [1, 2, 3, '4']; // 联合类型
const aTuple: [string, number] = ['a', 1]; // tuple 元组类型，是特殊的数组，显式的定义数组每一项元素类型和元素数量上限，并且一一对应。
aTuple.push(8); // 元组可以添加元素，但是不能读
aTuple[2]; // 会提醒 Tuple type '[string, number]' of length '2' has no element at index '2'
const bTuple: [string, number, number] = ['abc', 1, 8]; // tuple 元组新增元素，要一一对应

// 函数定义，一般两种类型：箭头函数、function
// 一、箭头函数
const aFun = () => false; 
// 函数类型定义
const aFun: () => boolean = () => false; // `() => boolean` 就是定义的函数类型
// 如果有参数
const aFun: (params: string) => boolean = () => false; // `(params: string) => boolean` 就是定义的函数类型
// 二、普通function 函数
function bFun() {
    return true;
} 
// 函数类型定义
function bFun(params: string): boolean {
    return true;
}
// 推荐使用箭头函数，方便提取函数类型定义
type Fun = (params: string) => boolean;
const cFun: Fun = () => false;
const dFun: Fun = () => false;
type Fun = (params: string) => void; // 如果函数没有返回值


// 对象，这样定义比较宽泛
const aObj: object = {
    a: 1,
    b: 2
}
// 对象，类型定义越具体越好，工作中一般如下定义
const bObj: { a: string, b: string } = {
    a: 'hello',
    b: 'world'
}
// 对象定义类型也可以提取，用interface
interface Obj { a: string, b: string }
const cObj: Obj = { a: 'hi', b: 'typescript' }

// void 类型，没有任何返回值
// 注意以下返回值为空的函数类型定义方式
const aVoid = (): void => {};
const bVoid: () => void = () => {}
type Fun = (params: string) => void;
const cVoid: Fun = () => {}

// any 就相当于没有类型定义，和js 一样了，可以随便赋值。

// never 永远没有返回值，一般高级编程会用，日常很少
const aNever = (): never => {
    throw new Error()
}
const bNever = (): never => {
    while(true) {}
}