设计模式在 TypeScript 中的应用 - 代理模式

定义

代理模式是为一个对象提供一个代用品，或占位符，以便控制对它的访问。

实现

思路：把客户端真正调用的类和方法隐藏，只暴露代理类给客户端。

简单点的例子：

// 食品服务接口
interface FootService {
  makeChicken (salt: string): void;
  makeNoodle (salt: string): void
}

// 食物接口
class Foot {

  // 种类
  public type: string

  // 重量
  public salt: string

  public constructor (type: string, salt: string) {
    this.type = type
    this.salt = salt
    this.cook()
  }

  // cook
  public cook (): void {
    console.log(`种类：${this.type}，重量：${this.salt}`)
  }
}

// 真实的食品服务
class FootServiceReal implements FootService {
  public chicken: Foot
  public Noodle: Foot

  public makeChicken (salt: string): any {
    this.chicken = new Foot('chicken', salt)
  }
  public makeNoodle (salt: string): any {
    this.Noodle = new Foot('noodle', salt)
  }
}

// 代理食品服务
class FootServiceProxy implements FootService {
  // 真实的实现类
  private footServiceReal: FootServiceReal

  private prepareFood () {
    if (!this.footServiceReal) {
      this.footServiceReal = new FootServiceReal()
    }
  }

  public makeChicken () {
    console.log('马上开始做鸡肉')
    console.log('==========')
    this.prepareFood()
    this.footServiceReal.makeChicken('500g')
    console.log('==========')
    console.log('鸡肉做好了')
  }

  public makeNoodle () {
    console.log('马上开始做面条')
    console.log('==========')
    this.prepareFood()
    this.footServiceReal.makeNoodle('100g')
    console.log('==========')
    console.log('面条做好了')
  }
}

const foot = new FootServiceProxy()
foot.makeChicken()
console.log('========')
foot.makeNoodle()

缓存代理比较常见，可以为一些开销比较大的运算结果提供缓存，在下次运算时，如果传递进来的参数跟以前一致，则可以直接返回前面存储的运算结果。

// 加法
function add (arg: Array<number>): number {
  console.log('进行一次加法计算')
  return arg.reduce((prev: number, cur: number): number => prev + cur, 0)
}

// 乘法
function mul (arg: Array<number>): number {
  console.log('进行一次乘法计算')
  return arg.reduce((prev: number, cur: number): number => prev * cur, 1)
}

// 代理
class CalculateProxy {
  private cache: Object = {}
  private fn: Function

  public constructor (fn: Function) {
    this.fn = fn
  }

  public calculate (...arg: Array<number>): void {
    const str: string = arg.join(',')
    if (str in this.cache) {
      return this.cache[str]
    } else {
      return this.cache[str] = this.fn(arg)
    }
  }
}

const addCalculateProxy = new CalculateProxy(add)
console.log(addCalculateProxy.calculate(1, 2, 3, 4))
console.log(addCalculateProxy.calculate(1, 2, 3, 4))
console.log('=========')
const mulCalculateProxy = new CalculateProxy(mul)
console.log(mulCalculateProxy.calculate(1, 2, 3, 4))
console.log(mulCalculateProxy.calculate(1, 2, 3, 4))