Javascript 承诺.then（异步（））与.then（函数（）{return async（）}）

我试图弄清楚为什么会发生以下行为，以及可能带来的好处。使用bluebird作为promise实现

printValue = function (value){
   return new Promise(function(resolve, reject){
      console.log(value);
      resolve(value)
   });
}

describe.only('promises', function(){
   it('prints values with then', function(done){
      printValue(1)
      .then(printValue(2))
      .then(function(value){
         console.log('then value: ', value);
      })
      .then(done())
   });

   it('prints values with return', function(done){
      printValue(1)
      .then(function(){
         return printValue(2);
      })
      .then(function(value){
         console.log('return value: ', value);
      })
      .then(done())
   });

});

输出：

1
2
then value: 1

1
2
return value: 2

---

当第二个测试从第二个承诺中获得值时，为什么第一个测试保留原始承诺中的值？这是否意味着使用

.then（async（））

仅在不向函数传递参数时有效？或者仍然有使用上述语法传递参数的方法吗？

这不容易看到

在第一部分中，您有：

printValue(1)
      .then(printValue(2))
      .then(function(value){
         console.log('then value: ', value);
      })

你看，你实际上是在调用

printValue（2）

，当你调用它时，它会立即执行，而不是等待前面的函数被调用和它们的承诺得到解决。虽然

printValue

返回一个

Promise

，

。但是
需要一个调用时返回
Promise
的函数（或者只是一个返回值的函数）

所以在
中，然后（printValue（2））
，
。然后
接收到一个非函数值，它只是忽略它并转到链中的下一个函数

例如，您可以尝试此示例以查看：

printValue(1)
    .then("hello!")
    .then(function (val) {
        console.log("got " + val)
    });

所以，它实际上和你拥有的是一样的，你只是有一个函数返回一些东西，这里我们只是用一个值替换它

您也可以尝试以下方法：

var printValue = function (value){
    return new Promise(function(resolve, reject){
        console.log("called " , value)
        setTimeout(function () {
            console.log("resolving ", value);
            resolve(value)
        }, value*1000);
    });
}

您将在这里看到：

printValue(1)
        .then(printValue(2))
        .then(function (val) {
            console.log("got " + val)
        });

同时执行
printValue（1）
和
printValue（2）
。一秒钟后，将解析
printValue（1）
，并打印
got 1
 这不容易看出

在第一部分中，您有：

printValue(1)
      .then(printValue(2))
      .then(function(value){
         console.log('then value: ', value);
      })

你看，你实际上是在调用
printValue（2）
，当你调用它时，它会立即执行，而不是等待前面的函数被调用和它们的承诺得到解决。虽然
printValue
返回一个
Promise
，
。但是
需要一个调用时返回
Promise
的函数（或者只是一个返回值的函数）

所以在
中，然后（printValue（2））
，
。然后
接收到一个非函数值，它只是忽略它并转到链中的下一个函数

例如，您可以尝试此示例以查看：

printValue(1)
    .then("hello!")
    .then(function (val) {
        console.log("got " + val)
    });

所以，它实际上和你拥有的是一样的，你只是有一个函数返回一些东西，这里我们只是用一个值替换它

您也可以尝试以下方法：

var printValue = function (value){
    return new Promise(function(resolve, reject){
        console.log("called " , value)
        setTimeout(function () {
            console.log("resolving ", value);
            resolve(value)
        }, value*1000);
    });
}

您将在这里看到：

printValue(1)
        .then(printValue(2))
        .then(function (val) {
            console.log("got " + val)
        });

同时执行
printValue（1）
和
printValue（2）
。一秒钟后，将解析
printValue（1）
，并打印
got 1
 希望我能帮忙。

为什么第一次测试保留了原始承诺的值？

-因为它是解析的，所以它会找到一个可以解析它的函数。

-为了解决承诺问题，需要找到适当的方法传递已解决的值。

要修复第一个场景，您需要执行以下操作：

printValue(1)
  .then(printValue)      
  .then(function(value){
     console.log('then value: ', value);
  })

因此，当解析第一个printValue（原始）时，它会将该值传递给第二个printValue。

传递更多参数的方法是使用curry。以下面的例子（使用ramda）：

因此，假设您想将printValue（原始）的结果与另一个数字相加，使用带有Ramda的curry，您可以指定R.\uuuu，它将获取printValue结果的值，在本例中，您仍然可以传递和附加参数3。
希望我能提供帮助。

为什么第一次测试保留了原始承诺的值？

-因为它是解析的，所以它会找到一个可以解析它的函数。

-为了解决承诺问题，需要找到适当的方法传递已解决的值。

要修复第一个场景，您需要执行以下操作：

printValue(1)
  .then(printValue)      
  .then(function(value){
     console.log('then value: ', value);
  })

因此，当解析第一个printValue（原始）时，它会将该值传递给第二个printValue。

传递更多参数的方法是使用curry。以下面的例子（使用ramda）：

因此，假设您想将printValue（original）的结果与另一个数字相加，使用curry与Ramda一起使用，您可以指定R.\uu它将获取printValue结果的值，并且在本例中，您仍然可以传递和额外参数3。
传递函数引用不同于传递函数的返回值。因此，传递函数引用仅在不传递时才有用需要该引用的解析值吗？不，它们只是“不同”。用那个能做你需要做的事的。我看不出有理由否决投票。这是一个很好的问题。传递函数引用不同于传递函数的返回值。因此，传递函数引用仅在不需要该引用的解析值时有用吗？不，它们只是“不同”。用那个能做你需要做的事的。我看不出有理由否决投票。这是一个很好的问题。