标签: method-chaining

我的问题是在方法链接+继承的背景下不能很好地发挥作用？.但不幸的是,方法链的所有示例/答案都使用单级继承.我的用例涉及多级继承,例如

abstract class PetBuilder{...}
class  DogBuilder extends PetBuilder{..}
class DogType1Builder extends DogBuilder {...}

要构造一个Dog Object,我将使用DogBuilder或DogType1Builder

如何使用getThis技巧用于上述用例？

我想使用构建器模式来构造一个复杂的Dog对象(Dog Object Model)".DogType1将有一些添加的属性.

所以使用getThis Trick声明上面的类就会变得像

abstract class PetBuilder<T extends PetBuilder<T>>
class DogBuilder<T extends DogBuilder<T>> extends PetBuilder<DogBuilder<T>>
class DogType1Builder extends DogBuilder<DogType1Builder>

现在这会产生两个问题

'DogBuilder'中的1.builder方法看起来像

public T someMethodInDog(String dogName) {
..
return (T)this; ///i dont want type casting and i cant use getThis Trick Here (compiler reports error for conversion from DogBuilder to T)
}

2.由于DogBuilder已经参数化,因此要创建"DogBuilder"的实例,我将不得不使用

DogBuilder<DogBuilder> builder=new DogBuilder(); //passing <DogBuilder> …

我正在编写一个javascript DSL,并想知道在实现允许在单个对象上调用多个方法的javascripts时,方法链是否是常见的做法.我来自Ruby背景,使用instance_eval更容易实现DSL,所以我更喜欢以类似的方式实现我的包,但我不想违反惯例.

我的选择是通过例子:

MyObject('test').method1(function() {
  console.log('hi');
}).method2(function() {
  console.log('bye');
});

要么:

MyObject('test', function() {
  this.method1(function() {
    console.log('hi');
  });

  this.method2(function() {
    console.log('bye');
  });
});

我想我会把它抛给JS大师,看看实现它的首选方法是什么.我认为这确实是个人偏好的问题,但可能有一种更为公认的方法.任何想法？

我想处理一系列数据,其中每个数据的输出可以用作其他数据的输入.

例如:

    var batch = [
        {"id":"a1","depends":[],"data":{"some":"data a1"}},
        {"id":"b1","depends":["a1"],"data":{"some":"data b1"}},
        {"id":"b2","depends":["a1"],"data":{"some":"data b2"}},
        {"id":"c1","depends":["b1","b2"],"data":{"some":"data c1"}},
        {"id":"x1","depends":[],"data":{"some":"data x1"}},
    ];

这意味着一旦a1完成,其输出将被发送到两者b1并且b2; 当这些完成时,既它们的输出的将被发送到c1(仅在两个其完成的. x1可以并行与所有的执行a1,b1,b2,和c1;以及b1在具有平行可以执行b2,因为没有depends在它们之间定义.

完成c1并x1完成所有5个后,应归还所有五个的输出.

我们假设没有定义循环依赖,因此是有向无环图(DAG)

我想知道如何使用Q实现这个,因为:

• 所有数据处理都是异步的,因此我需要使用回调,延迟和承诺; 而我更喜欢后者
• Promise可以加倍作为定义图中边缘的便捷方式

但是,我未能将这个过去概念阶段

var doPromises = {};

var doData = function(data, dependsResultsHash, callback) {
  //Not real processing, simply echoes input after a delay for async simulation purposes …

对不起,如果这个问题引起任何混淆,我希望实现这一点,并且不知道正确的方法来处理这样的事情.

对于我的一个项目,我想实现方法链.我想要包含以下功能:

.toVector()
.toArray()
.toBool()
...

我曾想过将这些放在命名空间中,例如:

namespace Misc {
   template<typename T, typename Inverse>

   vector<T> toVector(Inverse begin, Inverser end) {
      // ...
      // ..
   }

   // ...
   // ...
}

这是因为可能有多个类,这些类可以使用这些函数,因此,它必须是OO而不是在不同的类中一次又一次地实现每个函数.

假设我有以下类Wav读取wav文件中包含的数据:

class Wav {
   public:
     Wav();
     Wav(string theFileName);
     void getWaveData();
  protected:
     vector<double> data;
};

data 显式存储为类的向量.

在我的主要内容中,我希望能够做到以下几点:

int main()
{
    Wav wave("file.wav");

    int* data = wave.getWaveData().toArray(); // Method chaining to store as an array
}

我不知道这是否可能,如果是这样的话,如果不在Misc每个类中反复实现所有函数,我将如何处理这个问题.有没有办法在命名空间和类之间进行通信而不必反复包含所有函数？

我希望有人有一个建议,我会尽力回答任何问题.

编辑:

我写了以下函数:

template<typename T, typename Inverse>
T* toArray(Inverse …

调用函数链有开销吗？例如，在以下 for 循环中：

for(int i = 0; i < n; i++)
{
  var=object.method1().method2().method3();
}

第一个效率是否比第二个低？

var = object.method1().method2();
for(int i = 0; i < n; i++)
{
  var.method3();
}

我关心的是知道函数调用/返回是否有开销，而不是函数内部的功能。

谢谢。

我有一个由几个值组成的Python集,我想使用这样的方法链:

>>> f = {1, 2, 3}
>>> g = f.copy().discard(3)
>>> g
>>>

但是g变空了.但是,它没有链接:

>>> g = f.copy()
>>> g
{1, 2, 3}
>>> g.discard(3)
>>> g
{1, 2}

有人能解释一下这种行为吗？

对于单级索引列，我会执行以下操作

arrays = [['one', 'two', ]]
tuples = list(zip(*arrays))
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
df = pd.DataFrame(pd.np.random.randn(3, 2), index=['A', 'B', 'C'], columns=index)
print(df)


first   one two
A   0.919921    -1.407321
B   1.100169    -0.927249
C   -0.520308   0.619783

print(df.assign(one=lambda x: x.one * 100))

first   one         two
A       144.950877  0.633516
B       -0.593133   -0.630641
C       -5.661949   -0.738884

现在，当我有一个 MultiIndex 列时，我可以使用访问所需的列，.loc但我无法将其分配给任何内容，因为它出现了错误SyntaxError: keyword can't be an expression。

这是一个例子，

arrays = [['bar', 'bar'],
          ['one', 'two']]

tuples = list(zip(*arrays))
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
df …

我有个问题。例如：

StringBuilder sb = new StringBuilder();
sb.append("Teacher,");
String s = sb.append(" Good").append("Morning!").toString();

现在，在最后一行中，我创建了两个附加方法的链。我知道每个方法追加方法都会返回内存中字符串的地址（我是对的？对吧？）。所以在第一个中它附加到指向的sb.append地址。sb第一个sb.append在运行时首先执行，但是接下来会发生什么.append？接下来.append是使用第一个追加方法返回的地址还是我错了？这就是我的意思：

第一个追加 ->sb.append(" Good"); 第二个追加returnedAddr.append("Morning!");

是这样工作的吗？

我想在 Java 中调用一系列 API 调用。要求是在后续的 API 调用请求中会用到一些 API 的响应。我可以使用某些循环来实现这一点。但我想以实现通用的方式使用设计模式。有什么帮助吗？

责任链不能满足我的需要，因为一开始我不知道我的请求上下文是什么。

String out = null;
Response res = execute(req);
out += res.getOut();
req.setXYZ(res.getXYZ);
Response res = execute(req);
out += res.getOut();
req.setABC(res.getABC);
Response res = execute(req);
out += res.getOut();

System.out.println("Final response::"+out);

RxJS v4 曾经有一种Observable.transduce方法可以使用转换器。这允许使用在过去具有重大性能优势的独立于库的传感器运算符。

来源

• https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/transduce.md
• https://github.com/Reactive-Extensions/RxJS/blob/master/doc/gettingstarted/transducers.md
• https://medium.com/front-end-hacking/rxjs-transducers-vs-method-chaining-performance-87561cf4ce65
• https://github.com/ReactiveX/rxjs/pull/1323

RxJS v5.5 和 v6 具有可管道操作符和 v6 删除了方法链。因此，我假设 RxJS 操作符是标准的转换器。查看源代码，情况似乎并非如此。

RxJS v6 操作符的功能就像一个转换器，其中每个值在下一个值通过之前完全通过链传递，但 RxJS v6 操作符没有使用我在其他库中看到的标准转换器方法，这意味着，我不认为它们是便携式的。

关于传感器的整个事情是他们对集合本身一无所知。您可以编写 100 个普遍适用于任何集合或流类型的运算符，而不是专门为 observable 编写 100 个运算符。

在 RxJS v5 中是否.pipe一致.transduce或完全删除了这种方法？