标签: chaining

我正在尝试学习一些关于Node和异步编程的知识.我读到了Promises,并试图在一个小项目中使用它们,这个项目将用户的帖子从服务A复制到服务B.我在理解如何最好地在Promises之间传递状态时遇到一些麻烦

该项目是使用Promise库为NodeJS编写的

我当前问题的一个简单定义是:

• 如果服务B中尚不存在帖子,则将用户的帖子从服务A复制到服务B.
• 这两种服务都提供http API,需要一个不易记忆的用户ID来查找该用户的帖子,因此必须从用户名中查找用户ID.
• 所有的http调用都是异步的.

这是一些伪代码,说明了我如何将Promise链接在一起.

Promise.from('service_A_username')
  .then(getServiceAUserIdForUsername)
  .then(getServiceAPostsForUserId)
  .then(function(serviceAPosts) {
    // but what? store globally for access later?
    doSomethingWith(serviceAPosts);
    return Promise.from('service_B_username');
  })
  .then(getServiceBUserIdForUsername)
  .then(getServiceBPostsForUserId)
  .done(function(serviceBPosts) {
    // how do we interact with Service A posts?
    doSomethingThatInvolvesServiceAPostsWith(serviceBPosts); 
  });

我想过要做的一些事情:

1. 将getIdForUsername调用带入getPostsForUserId函数.但是,我希望保持每个功能单元尽可能简单,遵循"做一件事,做得好"的原则.
2. 创建一个"上下文"对象并将其传递给整个链,在此对象中读取和存储状态.然而,这种方法使得每个功能都非常适用于链条,因此难以单独使用.

还有其他选择,建议采用什么方法？

鉴于以下课程:

public class MyClass
{
    private string _param;

    public MyClass ()
    {
        _param = string.Empty;
    }

    public MyClass (string param)
    {
        _param = param;
    }
}

我在两种链接这些构造函数的方法之间分裂:

第一个:

public MyClass () : this (string.Empty)
{
}

public MyClass (string param)
{
    _param = param;
}

第二个:

public MyClass ()
{
    _param = string.Empty;
}

public MyClass (string param) : this ()
{
    _param = param;
}

那么,从无参数构造函数链接到其他方式更好吗？

我正在读一本名为JavaScript模式的书,但有一部分我觉得这个人很困惑.

这个家伙实际上在书中引出了klass设计模式,在那里他逐一开发了它.他首先提出了这个问题:

function inherit(C, P) {
C.prototype = P.prototype;
}

他说:

"这为您提供了简短快速的原型链查找,因为所有对象实际上共享相同的原型.但这也是一个回顾,因为如果继承链中的某个子项或孙子修改原型,它会影响所有父母和祖父母."

但是,我实际上试图在Child中修改原型say()并且它对Parent没有影响,实际上Child仍指向Parent并且完全忽略了它自己的同名原型,这是有意义的,因为它指向不同的内存位置.那家伙怎么能这样说呢？以下证明了我的观点:

function Parent(){}

Parent.prototype.say = function () {
return 20;
};

function Child(){
}

Child.prototype.say = function () {
return 10;
};

inherit(Child, Parent);

function inherit(C, P) {
C.prototype = P.prototype;
 } 

 var parent = new Parent();
var child = new Child();


var child2 = new Child()
alert(child.say(); //20
alert(parent.say()); //20
alert(child2.say()); //20

任何孩子或孙子都不可能修改原型!

这导致了我的第二点.他说,在继承链(我无法重现)中意外修改父原型的可能性问题的解决方案是打破父母和孩子原型之间的直接联系,同时从原型链中受益.他提供以下解决方案:

function inherit(C, P) {
var F = function () {};
F.prototype = P.prototype; …

我在谷歌上找不到关于这个主题的任何内容,所以我想我应该在这里问一下:

有可能用Python链接函数,就像jQuery一样吗？

['my', 'list'].foo1(arg1, arg2).foo2(arg1, arg2).foo3(arg1, arg2) #etc...

当我编写这段代码时,我失去了很多空间和可读性:

foo3(foo2(foo1(['my', 'list'], arg1, arg2), arg1, arg2), arg1, arg2) #etc...

似乎存在一些用于创建此类功能的虚幻库,但我似乎无法理解为什么这必须如此复杂......

谢谢!

我不认为我正确理解jQuery链接.我循环遍历数组并尝试将div元素添加到我的包装CSS类中,每个div元素都有一个'click'类和自定义css top和left属性,如下所示:

$('<div></div>').appendTo('.wrapper').addClass('click').css('top',click.y).css('left'.click.x);

但它无法按预期工作 - 它添加了一个div元素,将我的.wrapper div的类设置为'click'然后停止.

如果我删除

.css('top',click.y).css('left'.click.x);

它按预期工作 - 向包装器div添加新的div元素.

我怎样才能让它正常工作？谢谢

我有一些文本视图,我想制作MSN的嗡嗡声效果.

我的计划是:

• 看看,让我们说10dip在左边,
• 把它带回到它的起始位置
• 之后再拿10dip
• 然后回来
• 回来
• 离开...依此类推.

我的观点是,我有一些运动序列要设置为一个视图,并且需要一个接一个地执行.

我怎样才能做到这一点？

例如

class tester
{
    @Test
    public void testBeanUtils() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException
    {
        Stranger stranger = new Stranger();
        BeanUtils.setProperty(stranger,"name","wener");
        BeanUtils.setProperty(stranger,"xname","xwener");
        BeanUtils.setProperty(stranger,"yname","ywener");

        System.out.println(stranger);
    }
    @Data// lombok annotation generate all setter and getter
    public static class Stranger
    {
        @Accessors(chain = true)// generate chained setter
        String name;
        String xname;
        String yname;

        public Stranger setYname(String yname)// no lombok, still not work
        {
            this.yname = yname;
            return this;
        }
    }
}

我的输出:

TestValues.Stranger(name=null, xname=xwener, yname=null)

这有什么问题？连锁二传手是一件好事.有什么建议？

编辑

再次回到这个问题.这次我无法删除Accessors chain.现在,我commons-lang3用来实现.

// force …

Promise.all()不保证承诺将按顺序解决.如何才能做到这一点？

找了好久，还是没有找到我想要的。

有相当多的示例要么需要创建一个新实例，要么只有不返回任何内容的函数（这意味着可以通过返回来解决问题this）。

我希望下面的例子很好地说明了我的观点：

// Say I have these functions
function aNumber(){
    var max = 100, min = 0;
    return (Math.floor(Math.random() * (max - min + 1)) + min);
}
function divideBy(_number, _divider){
    return (_number / _divider);
}
function multiplyBy(_number, _multi){
    return (_number * _multi);
}
function add(_number, _add){
    return (_number + _add);
}
function subtract(_number, _sub){
    return (_number - _sub);
}

// #########################################################

// I can do this with them
var test = aNumber();
test = divideBy(aNumber, 2); …

我正在努力学习如何使用promises,但我很难理解链接.我假设使用此代码,两个承诺都将运行.然后,当我调用test.then()时,它应该知道测试已经解决并将解析数据传递给then().

一旦该函数完成,它将进入下一个then(),用test2 promise重复相同的过程.

但是,我只能打印出第一个承诺结果,而不是第二个.这里缺少什么想法？

var test = new Promise(function(resolve, reject){
    resolve('done1');
});

var test2 = new Promise(function(resolve, reject){
    resolve('done2');
});

test
.then(function(data) {
    console.log(data);
})
.then(test2)
.then(function(data) {
    console.log(data);
});