标签: chaining

以此示例代码为例:

int a = 10;
int b = 20;
int c = 30;

int & foo1() {
    qDebug() << "foo1" << endl;
    return a;
}

int & foo2() {
    qDebug() << "foo2" << endl;
    return b;
}

int & foo3() {
    qDebug() << "foo3" << endl;
    return c;
}

int main(void)
{
    foo1() = foo2() = foo3() = 7;
}

由于任务从右到左,我期望看到foo3第一个和foo1最后一个,但它是相反的.

Are the rules for such scenarios concretely defined and how? Also, does the compiler differentiate …

我有一个名为paymentStrategy的服务,它被注入我的控制器.

$scope.buy = function() {
  paymentStrategy.buy()
    .then(function(response) {

  }
}

来自paymentStrategy的这种购买方法会触发需要按顺序调用的几种方法.当buy()中的所有方法都完成后,需要调用().

这可能是微不足道的,但我对角度很新.

目前,在init()方法之后直接触发buy().then().我觉得我们需要将所有这些方法放在一个promises数组中并应用$ q.all().

任何帮助或建议将不胜感激

angular.module('deps-app.payment.services', []).
  factory('paymentStrategy', function($q) {

 var deferred = $q.defer();
 var ITEM_TO_PURCHASE = "test.beer.managed";
 var promises = [];

 var handlerSuccess = function(result) {
      deferred.resolve(result);
  };

 var handlerError = function(result) {
      deferred.reject(result);
  };

 _init = function() {

     inappbilling.init(handlerSuccess, handlerError, { showLog:true }); 
     return deferred.promise;
    }

  _purchase = function() {
        inappbilling.buy(handlerSuccess, handlerError, ITEM_TO_PURCHASE);
        return deferred.promise;
  }

  _consume = function() {
        inappbilling.consumePurchase(handlerSuccess, handlerError, ITEM_TO_PURCHASE);
        return deferred.promise;
  }

return  { …

这绝对是主观的,但我想尽量避免它变得有争议.我认为如果人们适当地对待它可能是一个有趣的问题.

在我最近的几个项目中,我曾经实现过长代理链是常见的架构.

可能经常遇到双重委托链:

bool Exists = Env->FileSystem->FileExists( "foo.txt" );

三重代表团并不罕见:

Env->Renderer->GetCanvas()->TextStr( ... );

存在更高级别的代表团,但实际上很少.

在上述示例中,不执行NULL运行时检查,因为所使用的对象始终存在并且对于程序的运行是至关重要的并且在执行开始时被显式构造.基本上我曾经在这些情况下拆分委托链:

1)我重用通过委托链获得的对象:

{ // make C invisible to the parent scope
   clCanvas* C = Env->Renderer->GetCanvas();
   C->TextStr( ... );
   C->TextStr( ... );
   C->TextStr( ... );
}

2)在使用之前,应该检查委托链中间某处的中间对象是否为NULL.例如.

clCanvas* C = Env->Renderer->GetCanvas();

if ( C ) C->TextStr( ... );

我曾经通过提供代理对象来对抗案例(2),以便可以在非NULL对象上调用方法,从而产生empty结果.

我的问题是:

1. 案例(1)或(2)是模式还是反模式？
2. 有没有更好的方法来处理C++中的长委托链？

以下是我在做出选择时考虑的一些优缺点:

优点:

• 它非常具有描述性:从一行代码中可以清楚地看出对象来自哪里
• 长代表团看起来不错

缺点:

• 交互式调试很费力,因为很难检查委托链中的多个临时对象

我想知道长代表团的其他利弊.请根据有争议的观点提出你的推理和投票,而不是你对它的看法.

我想知道我如何能够选择"最终" Exception,其中包含一条详细信息,其中包含许多链接异常的所有详细信息.

例如,假设这样的代码:

try {
  try {
    try {
      try {
        //Some error here
      } catch (Exception e) {
        throw new Exception("FIRST EXCEPTION", e);
      }
    } catch (Exception e) {
      throw new Exception("SECOND EXCEPTION", e);
    }
  } catch (Exception e) {
    throw new Exception("THIRD EXCEPTION", e);
  }
} catch (Exception e) {
  String allMessages = //all the messages
  throw new Exception(allMessages, e);
}

我对完整不感兴趣stackTrace,但只是在我写的信息中.我的意思是,我想得到这样的结果:

java.lang.Exception: THIRD EXCEPTION + SECOND EXCEPTION + FIRST EXCEPTION

我最感兴趣的是Java,但我认为这是一个普遍的问题.最近我一直在使用Arquillian framework(ShrinkWrap),它使用了很多方法链接.方法链接的其他实例是在方法StringBuilder,StringBuffer.使用这种方法有明显的好处:减少详细程度就是其中之一.

现在我想知道,为什么并非所有将void返回参数实现为可链接的方法？链接必然存在一些明显和客观的缺点.因为如果所有方法都是可链接的,我仍然可以选择不使用它.

我不是要求改变Java中的现有代码,这可能会破坏某些地方的某些东西,但解释为什么不使用它也会很好.我更多地要求从未来的框架(用Java编写)设计视角.

我发现了一个类似的问题,但原来的提问者实际上想知道为什么它被认为是一种好的做法:方法链 - 为什么这是一个好的做法,或不是？

虽然有一些答案可用,但我仍然不确定链接的所有优点和缺点是什么,以及将所有void方法链接起来是否有用会被认为是有用的.

有没有一种在Ruby中有条件地链接方法的好方法？

我想在功能上做的是

if a && b && c
 my_object.some_method_because_of_a.some_method_because_of_b.some_method_because_of_c
elsif a && b && !c
 my_object.some_method_because_of_a.some_method_because_of_b
elsif a && !b && c
 my_object.some_method_because_of_a.some_method_because_of_c

etc...

因此,根据一些条件,我想弄清楚在方法链中调用哪些方法.

到目前为止,我以"好的方式"做到这一点的最佳尝试是有条件地构建方法的串,并使用eval,但肯定有更好的,更红宝石的方式？

我看过一张幻灯片,它提供了一个node.js框架Fab.

这是JavaScript吗？

有人可以解释一下代码中发生了什么吗？

我都输了.

我想在Go中创建一个链接API的方法.在所有示例中,我都可以发现链式操作似乎总能成功,我无法保证.因此,我尝试扩展这些以添加错误返回值.

如果我这样做的话

package main

import "fmt"

type Chain struct {
}

func (v *Chain)funA() (*Chain, error ) {
    fmt.Println("A")
    return v, nil
}
func (v *Chain)funB() (*Chain, error) {
    fmt.Println("B")
    return v, nil
}
func (v *Chain)funC() (*Chain, error) {
    fmt.Println("C")
    return v, nil
}

func main() {
    fmt.Println("Hello, playground")
    c := Chain{}
    d, err := c.funA().funB().funC() // line 24
}

编译器告诉我chain-err-test.go:24: multiple-value c.funA() in single-value context并且不会编译.有没有一个好方法,所以funcA,funcB和funcC可以报告错误并停止该链？

鉴于以下示例代码克隆表行,设置一些属性,然后将其附加到表:

$("#FundTable").append(
    objButton.parents("tr").clone()
        .find(".RowTitle").text("Row " + nAddCount).end()
        .find(".FundManagerSelect").attr("id", "FundManager" + nAddCount)
                                .change(function() { ChangeFundRow(); }).end()
        .find(".FundNameSelect").attr("id", "FundName" + nAddCount).end()
);

有没有人有任何关于如何将其格式化为更容易的建议？这样做是否有任何公认的惯例？

拥有一套可以遵循的规则并将其纳入一组标准将是有用的.

我有一个超过9行的表.

如果我这样做:$('table tr:gt(3):lt(6)'),我最后会收到3或6个元素,为什么？是否所有选择器都应用于相同的主选择,或者它们是否连续应用于不同的选择？