现实世界

Question

像lodash这样的库实现了.chain()方法，其中每个随后的链接方法都将返回对this的引用，从而可以进行链接。缺点是，在链的最后，要调用.value()方法来解析函数集，则需要返回结果值。

我很好奇，是否有知道链是否在没有解析器功能的情况下终止的信息？每个方法都有一种方法可以知道是否有后续调用，是否不返回结果值？

这是一个例子：

enum Direction {
    LEFT = 'LEFT',
    UP = 'UP',
    DOWN = 'DOWN',
    RIGHT = 'RIGHT',
}

class Move {
    movement: Direction[];
    constructor () {
        this.movement = []
    }
    left () {
        this.movement.push(Direction.LEFT)
        return this
    }
    right () {
        this.movement.push(Direction.RIGHT)
        return this
    }
    up () {
        this.movement.push(Direction.UP)
        return this
    }
    down () {
        this.movement.push(Direction.DOWN)
        return this
    }
    resolve () {
        return this.movement;
    }
}

const m = new Move()

const code = m
    .up()
    .up()
    .down()
    .down()
    .left()
    .right()
    .left()
    .right()
    .resolve();

console.log(code)

我正在寻找一种方法，以某种方式更改每种方法，使其具有与上述m相同的值。

const code = m
    .up()
    .up()
    .down()
    .down()
    .left()
    .right()
    .left()
    .right();

Answer 1

每个单独的方法是否有一种方法可以知道是否存在后续调用，并且是否不返回结果值？

不。您可以使用基本上是轮询且不可靠的超时。

现实世界

需要一种解决方法并不是新事物，例如下划线使用chain和value对：https://underscorejs.org/#chaining

Answer 2

但是，有一种模式可以允许这种终止：

input.pipe(up(), up(), left());

通过使函数独立并“插入”它们，您知道链在pipe内结束（请注意，它们必须是高阶函数）。例如，rxjs使用此模式，尽管他们根本不关心链的终止。在此完成操作的原因（这也很好）是因为它为您提供了一个易于扩展的运算符系统，该运算符可以摇摇欲坠。

类似地，只要包装链，您就可以返回点链（如果您真的想要的话）：

input.chain(chain => chain.left().up());

chain方法可以运行提供给它的函数，并且知道到此结束，链终止了。因此，假设您的函数使用value方法返回一个对象，则pipe / chain可以最后隐式调用此对象：

chain(chainer: (obj: MyObj) => MyObj) { 
  return chainer(this).value(); 
}

当然，从本质上讲，这实际上转移了最终调用value的负担到开始调用链的负担。

还有一点要注意，我可能不会实现具有这种可变状态的类，但是，如果要使用链接，则应该使用不可变对象，并且每个这样的运算符都返回一个新对象。这样一来，您就不必担心两次应用连锁序列的风险，从而使连锁行为更加可预测和明智。

有没有一种方法让一组类方法知道调用何时终止？

2 个答案:

现实世界