typescript接口interface

//接口 关键字interface
/**

• 接口是一系列抽象方法的声明，是一些方法特征的集合
• 这些方法都应该是抽象的，需要由具体的类去实现
• 第三方就可以通过这组抽象方法调用，让具体的类执行具体的方法。
  */

interface people {
  fistName: string;
  lastName: string;
}
function preson(params: people): void {
  console.log(params.fistName + '--------------' + params.lastName);
}
let obj = {
  age: 20,
  fistName: '张',
  lastName: '三'
}
// preson(obj) //此写法可以添加接口未定义的属性
preson({
  // age: 20,
  fistName: '张',
  lastName: '三'
})
//报错 参数不能赋给类型“people”的参数。对象属性可以指定已知属性但不能不在类型“people”中

//接口可选属性 关键字符 ?

interface optional {
  fistName?: string; //可选传参
  lastName: string;
}
function presons(params: optional): void {
  console.log(params.fistName + '--------------' + params.lastName);
}
presons({
  lastName: '三'
})
presons({
  fistName: '张',
  lastName: '三'
})

//函数类型接口

interface encry {
  (key: string, value: string): string;
}

let ens: encry = function (key: string, value: string): string {
  return key + value
}
ens('张按', '上班')

//数组接口

interface encryArr {
  [index: number]: string;
}

let enArr: Array<string> = ['1', '2']

//类约束 关键字implements

interface Ans {
  eudh: string;
  eac(food: string): void;
}
class An implements Ans {
  eudh: string;
  constructor(eudh: string) {
    this.eudh = eudh
  }
  eac(food: string): void {
    console.log(food);
  }
}
let ad = new An('ss')
console.log('ad: ', ad);

//接口继承

interface inherit {
  eatch(): void;
}
interface Ang extends inherit {
  wodk(): void;
}

class Rijb implements Ang {
  asja: string;
  constructor(asja: string) {
    this.asja = asja
  }
  eatch(): void {
    console.log('eatch');
  }
  wodk(): void {
    console.log('wodk');
  }
}

//泛型-接口
//函数接口

interface Genint {
  (label: number, value: number): number
}
var gens: Genint = function (label: number, value: number): number {

  return label + value
}
console.log(gens(1, 3));

//泛型函数接口

interface Genints<T> {
  (label: T): T
}
function genss<T>(label: T): T {
  return label
}
let mygenss: Genints<number> = genss;
mygenss(123)

//泛型-函数

function generic<T>(value: T): T {
  return value
}
generic('554')
generic(554)
generic<number>(546)

//泛型-类
class Generics<T>{
  lists: T;
  constructor(lists: T) {
    this.lists = lists
  }
  add(list: T): void {
    console.log(list);
  }
}
let gen = new Generics<number>(123)
console.log('gen: ', gen);

//类作为泛型类

class ClassFx {
  title: string | undefined
  value: string | undefined
  desc: string | undefined
}

class ClassFxC {
  eate(kilo: ClassFx) {
    console.log(kilo);
  }
}

let Cdf = new ClassFxC()
let objs = {
  title: '563',
  value: '563',
  desc: '563'
}
Cdf.eate(objs)