设计模式之「行为型模式」 about blog HOT 3 OPEN

var strategies = {
  'S': (salary)=> salary * 4,
  'A': (salary) => salary * 3,
  'B': (salary) => salary * 2
}

var calcBonus = (level, salary) => strategies[level](salary)

console.log(calcBonus('S', 20000))
console.log(calcBonus('A', 10000))

Array.prototype.forEach2 = function(callback, that) {
  let T
  
  if (this == null) {
    throw new TypeError(' this is null or not defined');
  }

  let O = Object(this)
  let len = O.length;

  if (typeof callback !== "function") {
    throw new TypeError(callback + ' is not a function');
  }

  if (arguments.length > 1) {
    T = thisArg; // 如果未提供 T，则为 undefined
  }

  for (let i = 0; i < len; i++) {
    if (i in O) {

      callback.call(T, O[i], i, O)
    }

  }
}

;
['a', 'b', 'c'].forEach2((item, index) => {
  console.log(`item - ${item}, index - ${index}`)
})

function makeIterator(array) {
  var nextIndex = 0;
  return {
    next: function() {
      return nextIndex < array.length ?
        {value: array[nextIndex++], done: false} :
        {value: undefined, done: true};
    }
  };
}

const order1 = function(orderType, pay, stock) {
  if ( /* logic */ ) {
    /* do something */
  } else {
    order2(orderType, pay, stock)
  }
}

const order2 = function(orderType, pay, stock) {
  if ( /* logic */ ) {
    /* do something */
  } else {
    orderNormal(orderType, pay, stock)
  }
}

const order1 = function(orderType, pay, stock) {
  if ( /* logic */ ) {
    /* do something */
  } else {
    return 'NEXT_SUCCEWSSOR'
  }
}

const order1 = function(orderType, pay, stock) {
  if (orderType === 1 && pay === true) {
    console.log('111')
  } else {
    return 'NEXT_SUCCESSOR'
  }
}

const order2 = function(orderType, pay, stock) {
  if (orderType === 2 && pay === true) {
    console.log('222')
  } else {
    orderNormal(orderType, pay, stock)
  }
}

const orderNormal = function(orderType, pay, stock) {
  if (stock > 0) {
    console.log('ok')
  } else {
    console.log('nope')
  }
}

class Chain {
  constructor(fn) {
    this.fn = fn
    this.successor = null
  }
  setNextSuccessor(successor) {
    return this.successor = successor
  }

  passRequest() {
    let ret = this.fn.apply(this, arguments)

    if (ret === 'NEXT_SUCCESSOR') {
      return this.successor && this.successor.passRequest.apply(this.successor, arguments)
    }
    return ret
  }
}

let c1 = new Chain(order1)
let c2 = new Chain(order2)
let cn = new Chain(orderNormal)
c1.setNextSuccessor(c2)
c2.setNextSuccessor(cn)
c1.passRequest(2, true, 500)

class Chain {
  constructor(...fns) {
    this.fns = fns
    this.successor = null
  }

  passRequest() {
    let ret
    const fns = this.fns
    for (let i = 0; i < fns.length; i++) {
      if (typeof fns[i] === 'function') {
        ret = fns[i].apply(fns[i], arguments)
      }
      if (ret !== 'NEXT_SUCCESSOR') {
        break;
      }
    }
    return ret
  }
}

let c = new Chain(order1, order2, orderNormal)
c.passRequest(2, true, 500)

Function.prototype.after = function(fn) {
  let self = this
  return function() {
    ret ret = self.apply(this, arguments) // this 为调用时的 this
    if (ret === 'nextSuccessor') {
      return fn.apply(this, arguments) // this 为调用时的 this
    }
    return ret
  }
}

const order = order1.after(order2).after(orderNormal)
order(1, 200)

var myObject = {
	doSomething: function(a, b) {
		return a + b;
	}
};

// Call a function after myObject.doSomething returns
var remover = meld.after(myObject, 'doSomething', function(result) {
	console.log('myObject.doSomething returned: ' + result);
});

myObject.doSomething(1, 2); // Logs: "myObject.doSomething returned: 3"

remover.remove();

myObject.doSomething(1, 2); // Nothing logged