typeScript 原始类型,各种类型,接口,类,抽象类,泛型

typeScript 原始类型

1. string 字符串
2.number 数字
3.boolean 布尔值 
4.void 空值 一般 赋值 undefined
5. null 空值
6.undefined
7.symbol

 

作用域问题
function(){ const a:number =1 }

export {}
 

// Object类型 是指非原始类型,如 数组,对象,函数

const foo :object = function(){}
const obj :{foo:number,bar:string } ={ foo :123,bar:"yuqi"}

数组类型
 

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

元组类型

// 元组类型
const tuple :[number,string]=[18,"yuqi"]
const age:number = tuple[0] //18
const yu:string = tuple[1]  // yuqi
console.log(age,yu);
const [ages,yus]=tuple 
console.log(ages,yus); // 18 yuqi

枚举 enum

// 枚举类型 enum
// 0.失败 1.成功

enum stuName{
  err = 0,
  res = 1
}

const post ={
  status : stuName.res
}

函数类型

// 函数类型
function fcn(a:number,b:string):string{
    return `今年${a}岁,叫${b}`
}
fcn(18,"yuqi")

任意类型

// 任意类型 ,没有类型检查,不安全,建议不要轻易使用
function foo(value:any){
  return JSON.stringify(value)
}
foo(100)
foo("yuqi")

断言
 

// 类型断言
const res:number=6
const str :string ="yuqi"
const num = res as number  //  as 断言
console.log(num); // 6

接口 ( interface ) 

// 接口 :约束对象的结构,要实现接口,那么必须要实现接口中的成员
interface Post{
  title:string,
  age:number,
  subTitle ?: string,  //可选成员  
  readonly sumary:string //只读成员
}
function printPost(post :Post){
  console.log(post.title);
  console.log(post.age);
}
printPost({
  title:"yuqi",
  age:18
})

类 class

// 类 class  
// 访问修饰符 public > protected  > private
class Person{
  public name:string      // 公共的,都可以访问
  protected age:number    // 子类可以访问
  private gender:string   // 只能内部访问
  constructor(name:string,age:number){
    this.name=name;
    this.age=age
  }
  say(message:string):void{
    console.log(`hi,${message}`); 
    
  }
}
const p= new Person("yuqi",18);
p.say("message")

类与接口

// 类 与 接口
interface Eat{
  eat(food:string):void 
}
interface Run{
  run(distance:number):void
}

class Person implements Eat,Run{
  eat(food:string):void{
    console.log(`优雅进餐${food}`);
  }
  run(distance:number):void{
    console.log(`行走${distance}`);
    
  }
}
const P = new Person();
P.eat("慢慢")
P.run(18)

类,抽象类, 接口

// 类 与 接口 
// 抽象类
// 类 继承 抽象类  实现 接口

abstract class Animal {
  foo(sum:string):void{
    console.log(`hi,${sum}`);
    
  }
}


interface Eat{
  eat(food:string):void 
}
interface Run{
  run(distance:number):void
}

class Person extends Animal implements Eat,Run{
  eat(food:string):void{
    console.log(`优雅进餐${food}`);
  }
  run(distance:number):void{
    console.log(`行走${distance}`);
    
  }
  foo(dd:string):void{
    console.log(`hi,${dd}`);
  }
}
const P = new Person();
P.eat("慢慢")
P.run(18)
P.foo("yuqi")

泛型 : 先不定义类型,去使用时定义类型

// 泛型 : 先不定义类型,去使用时定义类型
function createNumberArray(length: number,value:number){
  let arr = Array<number>(length).fill(value)
  return arr
}
const res = createNumberArray(3,50)
console.log(res);  //50 50 50

// 对createNumberArray 改进
function createArray<T>(length: number,value:T):T[]{
  let arr = Array<T>(length).fill(value)
  return arr
}
const ress = createArray<string>(3,"foo")
console.log(ress); 

类型声明  例如: @type/lodash
(declare function camelCase )