复制下划线的链式方法样式

Question

在下面的函数cat 中，您可以直接调用eat 和play 函数，而无需实例化新的cat 对象，这可以通过将函数cat.eat 中的值传入@987654328 来演示@函数获取状态。

var cat = function(obj){
  // if (obj instanceof cat) return obj;
  // if (!(this instanceof cat)) return new cat(obj);
  // this.catwrapped = obj;
}

cat.eat = function(food){
  if(food == "tuna") return 95
  if(food == "milk") return 35
  return 0
}

cat.play = function(energy){
  if(energy < 50) return 0
  return 100
}

var energy  = cat.eat("tuna")
var status = cat.play(energy)

console.log(status) // 100

我正在尝试保留此功能并添加下划线样式链接。因此，您可以执行以下操作。这是如何实现的？

cat.day = function(obj){
  var instance = cat(obj);
  // instance._chain = true;
  return instance;
}

var status = cat.day()
  .eat("tuna")
  .play()
  .status()

console.log(status) // should log 100

我需要在cat 和cat.day 中拥有最少多少代码才能完成这项工作？

Answer 1

您需要返回对象的指针才能执行链式调用：

cat.play = function(energy){
  // do something with energy
  return cat
}

cat.eat = function(food){
  // do something with food
  return cat
}

var status = cat.day()
   .eat("tuna")
   .play()
   .status()

由于您将 return 用于不同的目的（并在之后忽略它），您需要重新考虑您的程序算法

更新。您可以创建一个函数来执行任务或根据参数返回数据：

var energy = 0;
cat.eat = function(v) {
    // return something on empty call
    if (!arguments.length) return energy 
    // process passed data
    energy += v
    // return cat object to allow chaincals
    return cat
}

在这种情况下 cat.eat(10) 将允许您执行链式调用，而 cat.eat() 将返回值，存储在能量中

更新 2：您的函数不会更改任何内部变量，因此任何数据都将在标准链调用中丢失。你做什么，你需要一个管道和一个函数的直接输出到另一个输入。有很多方法可以做到：

你可以尝试使用下划线reduce函数：

var status = _.reduce([cat.play, cat.eat], function(status, f){ return f(status); }, "tuna");

或者你可以直接调用他们：

cat.status(cat.play(cat.eat("tuna")))

如果你创建内部变量来存储能量，你甚至可以调用下划线链：

var cat = function() {
  this.energy = 0; 
}

cat.eat = function(food){
  if (food == "tuna") cat.energy = 95
  else if(food == "milk") cat.energy = 35
  else cat.energy = 0
}

cat.play = function(){
  if(cat.energy < 50) cat.energy = 0
  else cat.energy = 100
}

var status = _.chain(cat)
   .eat("tuna")
   .play()
   .value()
   .energy

不过好像有点多余

Answer 2

我复制了所有使其可链接的下划线函数，并将其添加到对象的末尾。

这个想法是您可以创建行为类似于普通函数的函数，执行某种输入/输出操作。然后，您可以遍历所有这些函数，并构建使对象可链式化所涉及的原型，例如存储数据和传输参数。

var _ = require("underscore")

var cat = function(obj) {
  if (obj instanceof cat) return obj;
  if (!(this instanceof cat)) return new cat(obj);
  this._wrapped = obj;
};

cat.eat = function(food){
  if(food == "tuna") return 95
  if(food == "milk") return 35
  return 0
}

cat.play = function(energy){
  if(energy < 50) return 0
  return 100
}

// Add a "chain" function. Start chaining a wrapped Underscore object.
cat.chain = function(obj) {
  var instance = cat(obj);
  instance._chain = true;
  return instance;
};

// Helper function to continue chaining intermediate results.
var chainResult = function(instance, obj) {
  return instance._chain ? cat(obj).chain() : obj;
};

var ArrayProto = Array.prototype
var push = ArrayProto.push

cat.mixin = function(obj) {
  _.each(_.functions(obj), function(name) {
    var func = cat[name] = obj[name];
    cat.prototype[name] = function() {
      var args = [this._wrapped];
      push.apply(args, arguments);
      return chainResult(this, func.apply(cat, args));
    };
  });
};

// Add all of the Underscore functions to the wrapper object.
cat.mixin(cat);

// Extracts the result from a wrapped and chained object.
cat.prototype.value = function() {
  return this._wrapped;
};


// var energy  = cat.eat("tuna")
// var status = cat.play(energy)
//
// console.log(status) // 100

var status = cat.chain("tuna")
  .eat()
  .play()
  .value()

console.log(status) // 100

更新：

我制作了使任何对象成为可链接对象的函数。

这是混合：

var _ = require("underscore")

_.mixin({
  prototypeChain: function(thObj){
    return function(obj) {
      var instance = thObj(obj);
      instance._chain = true;
      return instance;
    }
  },
  prototypeExtend: function(theObj){
    var chainResult = function(instance, obj) {
      return instance._chain ? theObj(obj).chain() : obj;
    }
    var prototypes = _.map(_.functions(theObj), function(name) {
      var func = theObj[name];
      theObj.prototype[name] = function() {
        var args = [this._wrapped];
        Array.prototype.push.apply(args, arguments);
        return chainResult(this, func.apply(theObj, args));
      };
    });
    _.extend(theObj, prototypes)
  },
  prototypeValue: function(){
    return function(){
      return this._wrapped;
    }
  }
})

它是这样工作的：

var cat = function(obj) {
  if (obj instanceof cat) return obj;
  if (!(this instanceof cat)) return new cat(obj);
  this._wrapped = obj;
};

cat.eat = function(food){
  if(food == "tuna") return 95
  if(food == "milk") return 35
  return 0
}

cat.play = function(energy){
  if(energy < 50) return 0
  return 100
}

cat.chain = _.prototypeChain(cat)
_.prototypeExtend(cat)
cat.prototype.value = _.prototypeValue()

var energy  = cat.eat("tuna")
var status = cat.play(energy)

console.log(status) // 100

var status = cat.chain("tuna")
  .eat()
  .play()
  .value()

console.log(status) // 100

Answer 3

我为此创建了一个 npm 模块 underscore-chainable。

npm install underscore-chainable

然后

var _ = require("underscore")
_.mixin(require("underscore-chainable"))

var cat = _.makeChainable() // make the `cat` object chainable

cat.eat = function(food){
  if(food == "tuna") return 95
  if(food == "milk") return 35
  return 0
}

cat.play = function(energy){
  if(energy < 50) return 0
  return 100
}

_.extendChainable(cat) // extend the chainablity

// adds `.chain` and `.value`

var energy  = cat.eat("tuna")
var status = cat.play(energy)

console.log(status) // 100

var status = cat
  .chain("tuna")
  .eat()
  .play()
  .value()

console.log(status) // 100