TypeScript 学习笔记 （二）—— 类型

1. 原始数据类型

   // 定义布尔值
   let isDone: boolean = false;
   // 16进制
   let hexLiteral:number =0xf00d
   // 二进制
   let binaryLiteral : number =0b1010
   // 八进制
   let octalLiteral:number = 0o744
   let notNumber :number = NaN
   let infinityNumber:number = Infinity
   let undefined1:undefined=undefined
   let null1 : null=null
   // 定义字符串
   let str:string ='121aaa'
   // 定义空值
   function kongzhi():void { // 没有返回值的函数
       console.log('空置')
   }
   let kongzhi1:void=undefined
   // 编写报错 Type 'null' is not assignable to type 'void'
   let kongzhi2:void=null
   

2. 联合类型

   let aStrOrNum: string | number;
   aStrOrNum = 'seven';
   aStrOrNum = 7;
   

3. 任意类型

   let anyThing:any = 'Tom';
   // 报错 Uncaught TypeError: anyThing.setName is not a function
   // 编译成js后报错
   anyThing.setName('Jerry');
   // 报错 Uncaught TypeError: anyThing.sayHello is not a function
   // 编译成js后报错
   anyThing.sayHello();
   

4. 对象类型（接口）
   赋值的时候，变量的形状必须和接口的形状保持一致，不允许添加未定义的属性
一旦定义了任意属性，那么确定属性和可选属性的类型都必须是它的类型的子集
只读的约束存在于第一次给对象赋值的时候，而不是第一次给只读属性赋值的时候

   interface Person{
       // 只读属性，不可改变
       readonly id:number,
       name:string,
       age:number,
       // 可有可无的属性
       // nihao?:string,
       // 定义可有可无的属性 和 定义任何属性不能同时存在，编写时会报错，编译为js文件后能用
       // 定义任何键，定义字符串或者数字为值
       [propName:string]:string|number
   }
   let tom:Person={
      id:114141,
       name:'你好',
       age:45,
       nihao:'dada',
       d:4
   }
   // 报错 编写时会报错，编译为js文件后能用
   tom.id=123131
   

5. 数组类型

   let numArr:number[]=[1,2,3,4]
   // 编写时报错 Argument of type '"3"' is not assignable to parameter of type 'number'
   numArr.push('3')
   // 数组泛型定义数组
   let numArr1: Array<string>=['1','2']
   // 接口定义数组
   interface numberArray{
       [index:number]:number
   }
   let numArr2:numberArray=[1,2]
   // 类数组不是数组，例如arguments,只能用接口定义
   // 编写时报错 
   // Type 'IArguments' is missing the following properties from type 'number[]': pop, push, concat, join, and 15 more
   function test(){
       let args:number[]=arguments
   }
   // 接口定义方式一
   interface fnArgs {
       [index:number]:any,
       length:number,
       callee:Function
   }
   function test(){
       let args:fnArgs=arguments
   }
   // 接口定义方式二
   function test2(){
       let args:{
           [index:number]:number,
           length:number,
           callee:Function
       }=arguments
   }
   

6. 函数类型

   //  函数声明
   function sum(x:number,y:number):number{
       return x+y
   }
   // 注意，输入多余的（或者少于要求的）参数，是不被允许的：
   // 编写错误 
   // Expected 2 arguments, but got 1
   sum(1)
   // 编写错误
   // Expected 2 arguments, but got 3
   sum(1,2,3)
   // 函数表达式
   let sum1:(x:number,y:number) => number = (x:number,y:number):number =>{
       return x+y
   }
   // 接口定义函数
   // 采用函数表达式 | 接口定义函数的方式时，对等号左侧进行类型限制，可以保证以后对函数名赋值时保证参数个数、参数类型、返回值类型不变。
   interface sum2Interface{
       (x:number,y:number):number
   }
   
   let sum2:sum2Interface; 
   sum2 =  (x:number,y:number)=>{
       return x+y
   }
   // 可选参数，可选参数后面不允许再出现必需参数了
   function stringContact(x:string,y?:number):number{
       return x+y
   }
   // 默认值
   function sum4(x:number=0,y:number=1):number{
       return x+y*10
   }
   sum4() // 10
   // 剩余参数，ES6 中，可以使用 ...rest 的方式获取函数中的剩余参数（rest 参数）
   // rest 参数只能是最后一个参数，关于 rest 参数，可以参考 ES6 中的 rest 参数
   function push(array, ...items) {
       items.forEach(function(item) {
           array.push(item);
       });
   }
   let a: any[] = [];
   push(a, 1, 2, 3);
   // 函数重载
   function reverse(v:number):number;
   function reverse(v:string):string;
   function reverse(v:string|number):string|number{
       if(typeof v === 'number'){
           return Number(v.toString().split('').reverse().join(''))
       }else if(typeof v==='string'){
           return v.split('').reverse().join("")
       }
   }