函数类型

let log = function (message) {

    console.log(message);

}

let log2 = (message: string) => console.log(message);

log2('hello');//参数只能转入string

typescript中，函数的写法与JavaScript的完全一样，与JavaScript最大的不同就是，typescript 可以给函数绑定类型。

let log3 = (message: string, code?: number) => {

    console.log(message, code);

}

log3('hello', 3);

typescript中，调用函数与JavaScript有个显著的不同，就是typescript调用函数过程中，如果函数定义了两个参数，调用时必须填写两个参数，并且类型要一致。typescript可以使用 ? 来表示参数的可选性，被用 ? 来指定的参数可以不填写，函数里面的这个参数就被设定为undefined；也可以给参数设定默认值

let log3 = (message: string, code: number = 0, data?: array) => {

    console.log(message, code);

}

log3('hello');

注意：不管是可选参数，还是默认参数，都必须在参数列表的末尾，并且按照从后往前的顺序进行排列

类型适配（类型断言）Type Assertions

let message : any; //初始化声明了变量的类型，后续不会因为赋值而改变类型

message = 'abc';

message.endsWith('c'); //此时message类型是any类型而不是string类型

如何改变变量初始化的类型？

明确告诉typescript编译器目前message真正的类型就是string，而通知typescript进行类型适配的过程就叫做 Type Assertions，中文叫类型断言。
两种方法：

1、let ddd =  (<string>message).endsWith('c');

2、let aaa = (message as string).endsWith('c');

注意！注意！注意！

在使用类型适配 Type Assertions 的时候，一定要非常非常了解当前变量的类型，必须对自己的代码有百分之百的信心！否则引发严重的错误！

1、void：

函数在没有任何返回的情况下，函数就是一个 void 类型。

funciton printResult() {

    console.log('lalalla');

}

也可以给函数指定类型：

function printResult() : void {

    console.log('lalalla');

}

console.log('hello ', printResult()); //hello undefined

在原生JavaScript中没有void对应的表述的。

2、undefined：

function printResult() : undefined {

    console.log('lalalla');

    return;

}

使用过JavaScript的都知道，其实undefined也是一个值，是一个未经初始化的值。

使用undefined的时候可以说某个东西是undefined，但使用void，表示这个东西不存在。

两者都表示没有，undefined说的是变量没有赋值没有初始化，而void指定是变量本身就不存在。

3、never：（一个函数永远执行不完，这就是 never 的本质。实际开发过程中，never是用来控制逻辑流程的，大部分是用来处理异常或者处理promise）

function throwError(message: string, errorCode: number) : never {

    throw { //抛出异常，强行结束

        message,

        errorCode

    }

    //永不会执行到这里，这个函数永远不会执行完成，因此这个函数类型是 never

}

throwError('not found', 404);

function whileLoop() : never {

    while(true) {

        console.log('hhh');

    }

}

1、any 支持并且兼容所有类型（）

let randomVal: any = 666;

randomVal = true;

randomVal = 'sdfsa';

randomVal = {};

randomVal();

randomVal.toUpperCase();

这段代码编写没有报错，但编译后就报错了！

2、unkonwn 不保证类型，但能保证类型安全

在使用 unkonwn变量的时候，需要做一定程度的判断或者类型转换，当确定变量类型以后才能正常使用。

let randomVal: unkonwn = 666;

randomVal = true;

randomVal = 'sdfsa';

randomVal = {};

if (typeof randomVal === 'function') {

    randomVal();

}

if (typeof randomVal === 'string') {

    randomVal.toUpperCase();

}

区别：

使用any适合代码的快速成型快速上线，但是会遗留一些明显的安全隐患。

使用unkonwn比any保险一点，可以保证类型的安全。

动态类型：any

（重点问题：日常使用JavaScript的时候其实就是在使用一个any类型，那么，typescript目的是给JavaScript带来强类型定义，为什么还要引用这种any类型动态支持各种类型呢？）

使用any主要的目的是为了加速我们的开发过程，避免太冗长或者没有必要或者约定俗成的类型定义。

有人说使用typescript就不要使用any，使用any就失去了类型的意义了。

在代码中使用any，目的是为了快速开发、提升效率，避免过度设计。

可以想一下，为什么JavaScript可以流行这么多年还经久不衰，这正是因为JavaScript的灵活性！

而typescript所带来的any则在极大程度上保留了JavaScript的它的灵活性，喜欢JavaScript是因它无与伦比的灵活性，但是痛恨的同样也是它的灵活性。

JavaScript这种野蛮生长猥琐发育的灵活性可以让团队快速开发，但是给也会给团队带来不可阅读性、不可维护性、不可拓展性等一系列的问题，而typescript则正是因为有any类型，才能在继承JavaScript以后最大程度的保持语言灵活性的同时，还能带来强类型语言才能形成的高可维护性。

typescript中的any绝非无意义，它是通过多方论证得出的结果，所有要多用，并且用好any类型，使用any类型时一定要小心，合理使用它！

枚举类型 enum （在默认情况下，枚举类型的表现形式与c++类似，枚举类型真正的类型数据是数字，也是从0开始计算）

enum Color1 = {red, green, blue}

let color1 = Color.blue; //2

enum Color2 = {red = 5, green, blue}

let color2 = Color2.blue; //7

enum Color3 = { red = 3, green = 'greeen', blue = true}

let color3 = Color3.blue; //true

联合类型：一个变量可以同时支持两个或多个不同的类型

let union : string | number

union = 2;

union = 'sdfedf';

union = true; 报错

let union2 : number | string | boolean | string[]

function merge(n1: number | string, n2: number | string) {

    if (typeof n1 === 'string' || typeof n2 === 'string') 

        return n1.toString() + n2.toString;

    else 

        return n1 + n2;

}

let mergeNumber = merge(1,3); //4

let mergeString = merge('2','4'); //24

let mergeString = merge('hello', 2); //hello2

数组 array

let list1: number[] = [1,2,3,4]

let list2: Array<number> = [1,2,3,4]

let list3 = [1,2,3,4]

let list4 = [1,'aa']

let list5: any[] = [1,'aa',true]

元组 tuple（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

let person1: [number, string] = [1, 'lulingkun']

元组是一个特殊的数组，是固定长度固定类型的数组

元组bug：person1[2] = 3; 报错，但 person1.push(3) 不报错可以通过编译

let person2 = [1, 'lulingkun']; 这不是元组类型，而是union array，联合类型数组，本质上就是数组，既没有固定长度也没有固定类型，是混合number和string的类型

给函数的参数设置取值类型

function add (n1: number, n2: number) {

    return n1 + n2;

}

自动映射数据类型

let isTrue = true;

手动指定数据类型

let total: number = 0;

string 字符串类型

"hello"

'hello'

`hello`

高级类型

union 组合类型

nullable 可空类型

literal 预定义类型

typescript 的基本类型

boolean、string、number、array、object、null、undefined

tuple、enum、void、never、any

var 没有 block 作用域，在 JavaScript 中可以无限次数声明和使用，导致内存泄漏

推荐使用：

const 声明常量

let 声明变量（解决 var 中带来的作用域混论的问题）

热味儿

interface IPoint {

  drawPoint: () => void;

  getDistance: (p: IPoint) => number;

  // getter  setter 正常写法

  // getX:()=>number;

  // setX:(value)=>void;

  // getY:()=>number;

  // setY:(value)=>void;

  // 懒人包写法

  X: number;

  Y: number;

}

class newPoint implements IPoint {

  constructor(private x: number, private y: number) {

    console.log(`在 constructor 中,x is ${x},y is ${y}`);

  }

  drawPoint = () => {

    console.log(`x : ${this.x}, y : ${this.y}`);

  }

  getDistance = (p: IPoint) => {

    return Math.sqrt(Math.pow(p.X - this.x, 2) + Math.pow(p.Y - this.y, 2));

    // return 0;

  }

  // 懒人包写法

  get X() {

    return this.x;

  }

  set X(value: number) {

    this.x = value;

  }

  get T() {

    return this.y;

  }

  set Y(value: number) {

    this.y = value;

  }

  // 正常写法

  // setX =(value:number)=>{

  // if(value<0){

  // throw new Error("value 不能小于0")

  // }

  // this.x=value;

  // }

  // setY =(value:number)=>{

  // if(value<0){

  // throw new Error("value 不能小于0")

  // }

  // this.y=value;

  // }

  // getX=()=>{

  // return this.x;

  // }

  // getY=()=>{

  // return this.y;

  // }

}