typescript基础学习---2

数组类型和元组类型

// 数组类型
let arr1:number[] = [1,2,3,4,5]
let arr2:Array<number>  = [1,2,3,4,5]

// 元组类型
let arr3:[number,string,number] = [1,'sss',3]

对象类型和索引签名

// 对象索引
type A = {
  username:string,
  age:number
}

let a:A = {
  username:'111',
  age:20
}


// 索引签名
type B = {
  username:string,
  age:number,
  // 索引签名
  [index:string]:any
}

let b:B = {
  username:'lisi',
  age:33,
  hobby:'eat'
}

函数类型与void类型

// 这里表示函数返回值类型是number
let foo = function(n1:number,n2:number):number{
  return 123
}
// 等价于
let foo2:(n1:number,n2:number)=>number = function(n1,n2){
  return 123
}

// void:代表函数没有任何返回值

函数重载与可调用注解

function foo(n1: string): any;
function foo(n1: string, n2: number): any;
function foo(n1: string, n2: number, n3: number): any;
// 函数实现必须写
function foo(n1: string, n2?: number, n3?: number): any {
  if (n2 === undefined && n3 === undefined) {
    // 只传了一个参数，则执行这段逻辑
    return `hello, ${n1}`;
  } else if (n3 === undefined) {
    // 传了两个参数，则执行这段逻辑
    return `${n1} + ${n2} = ${n1 + n2}`;
  } else {
    // 传了三个参数，则执行这段逻辑
    return `${n1} + ${n2} + ${n3} = ${n1 + n2 + n3}`;
  }
}

console.log(foo('Alice')); // 输出：hello, Alice
console.log(foo('1', 2)); // 输出：1 + 2 = 12
console.log(foo('1', 2, 3)); // 输出：1 + 2 + 3 = 123


// 可调用注解
// type A = ()=>void
type A = { // 可调用注解,可以针对函数重载进行注解
    (): void
}
let a:A = () => {};

枚举类型和const枚举

enum Roles {
  SUPER_ADMIN,
  ADMIN = 3,
  USER,
}
console.log(Roles.SUPER_ADMIN) //0
console.log(Roles.ADMIN) //3
console.log(Roles.USER) //4

// 这里的0不是下标是他的值,第一项默认是0依次递增
console.log(Roles[0]) //SUPER_ADMIN
console.log(Roles[3]) //ADMIN
console.log(Roles[4]) //USER

// const枚举
// 编译后看不到原来的对象
// 如果只当常量使用就定义const 更有利于提升性能
const enum Roles {
  SUPER_ADMIN = "super_admin",
  ADMIN = 'admin',
  USER = 'user',
}

console.log(Roles.SUPER_ADMIN);


// 编译成js后
console.log("super_admin" /* Roles.SUPER_ADMIN */);