TypeScript学习基础2

TypeScript基础数据类型

//Number 类型
const count:number=1;
//String 类型
const mynames:string='ping';
//Boolean 类型
const isDone:boolean=false;

Array 类型

let list:number[]=[1,2,3];
let kist:Array<number>=[1,2,3];
const stringArr:string[]=['1','2','3'];
const undefinedArr: undefined[] = [undefined, undefined];
const nullArr:null[]=[null,null];
const arr: (number | string)[] = [1, "string", 2];

Array-元祖类型（tuple)

元祖的表示和数组非常类似，只不过它将类型写在了里面 这就对每一项起到了限定的作用

元组就是固定长度的数组

let listTuple:[string,number]=['vikeing',123];
//sv或者excel格式的导出的文件，产生的数据结构转化成js时，用元组去管理比较合适
const jj:[string,string,number][]=[
    ["dajiao","tac",28],
    ["dajiao","tac",28],
    ["cuihua","tac",21],
]

定义元祖的语法  存储的元素数据类型不同，则需要使用元组;

type TurpleArr=[string,number,string];

const mixe:TurpleArr=['a',2,'c'];

const first=mixe[0];

const second=mixe[1];

枚举类型 -- enum 

用于取值被限定在一定范围内的场景，TypeScript支持数字的和基于字符串的枚举

类型可以分成：  数字枚举   字符串枚举   异构枚举

enum xxx { ... }

/ 声明d为枚举类型Direction
let d: Direction

枚举成员是只读的，枚举中的成员无法直接赋值   

  数字枚举 

enum Direction {
    Up,   // 值默认为 0
    Down, // 值默认为 1
    Left, // 值默认为 2
    Right // 值默认为 3
}
 
console.log(Direction.Up === 0); // true
console.log(Direction.Down === 1); // true
console.log(Direction.Left === 2); // true
console.log(Direction.Right === 3); // true

enum Direction {
    Up = 10,
    Down,
    Left,
    Right
}
 
console.log(Direction.Up, Direction.Down, Direction.Left, Direction.Right); // 10 11 12 13

  字符串枚举 

enum Direction {
    Up = 'Up',
    Down = 'Down',
    Left = 'Left',
    Right = 'Right'
}
 
console.log(Direction['Right'], Direction.Up); // Right Up
s[0]); // ON

 异构枚举

enum BooleanLikeHeterogeneousEnum {
    No = 0,
    Yes = "YES",
}

函数参数和返回类型定义

显式指定函数参数和返回值的类型

//参数名后的 :number 表示参数类型都是数字类型，
//圆括号后的 : number'则表示返回值类型也是数字类型
const add=(a:number,b:number):number=>{
  return a+b;
}
 
//在 TypeScript 中  使用void 类型来表示函数没有返回值的类型
function fun():void{
    console.log('123);
}

//如果一个函数是永远也执行不完的，就可以定义返回值为never


function forNever():never{
    throw new Error();
    console.log('123')
    
}



//先定义了一个函数类型（这里使用了类型别名 type），并且使用箭头函数实现了这个类型
type Adder=(a:number,b:number)=>number;//TypeScript 函数类型定义
const adds:Adder=(a,b)=>a-b;

 函数参数为对象(解构)时

//对象结构  定义多个属性
function add3({one,two}:{one:number,two:number}):number{
    return one+two;
}

//对象结构  定义1个属性
function getNumber({one}:{one:number}):number{
    return one;
}
const one=getNumber({one:1});

使用类似对象属性的简写语法来声明函数类型的属性

interface Entity{
    add:(a:number,b:number)=>number;
    del:(a:number,b:number)=>number;
}

const  entity:Entity={
    add:(a,b)=>a+b,
    del(a,b){
        return a-b
    }
}

可缺省和可推断的返回值类型

function  funcs(one:string,two:number){
    const nums=[two];
    const strs=[one];
    return {
        nums,
        strs
    }
}

可选参数、默认参数、剩余参数(...)

//可选参数
function funcs1(x?:string):void{
    console.log(x);
}

//函数参数是不可缺省且类型必须是 xxx 或者 undfined
function funcs2(x: string | undefined) {
  console.log(x);
}

//默认参数
function funcs12(x:number=8888){
    console.log(x);
}

//剩余参数

function buildName(firstName: string, ...restOfName: string[]) {
    return firstName + " " + restOfName.join(" ")
}

let aName = buildName("Lili", "John", "David", "Durban");
console.log(aName); //   Lili John David Durban

 函数重载

//最后这个函数的参数一定要是any，因为前连个函数的参数类型是不一定的
function funcs3(nameA:string,age:number):void;
function funcs3(age:number):void;
function funcs3(str:any,age?:any):void{
    if (typeof str == 'string') {
        console.log(`my name is ${str} ${age}`);
        
      } else { 
        console.log(`my age is ${str}`);
        
      }
}