以下代码片段是否相同？

版本1

function doSomething() {
  var defer = $q.defer();

  foo().then(function() {
    bar().then(function() {
      defer.resolve();
    });
  });

  return defer.promise;
}

版本2

function doSomething() {
  return foo().then(bar);
}

我正在尝试编写一个将节点式回调函数转换为promises的简单函数,因此我可以将它们与async/await一起使用.

当前代码:

function toPromise(ctx, func, ...args) {
  let newPromise;

  args.push((err, res) => {
    newPromise = new Promise((resolve, reject)=> {
       if(err) reject(err);
       else{
        resolve(res) 
      };
     });
    });

   func.apply(ctx, args);

   return newPromise;
}

示例用法:

const match = await toPromise(user, user.comparePassword, password);
//trying to avoid the following:
user.comparePassword(password, (err, res) => {
     ... });

对于一些很棒的库来说,这可能没有任何意义,但我只是想把它编写为一个练习.

问题当然是匹配评估为未定义,显然在await语法行之后,promise得到解决.

知道如何解决这个问题吗？

我目前在Node/amqp应用程序中使用Q promise库.我已经读过Q对像BlueBird或Vow这样的库的表现......不太好.

不幸的是,我无法弄清楚如何使用BlueBird(或Vow)来替换我目前的Q使用模式.

这是一个例子:

this.Start = Q(ampq.connect(url, { heartbeat: heartbeat }))
    .then((connection) => {
        this.Connection = connection;
        return Q(connection.createConfirmChannel());
    })
    .then((channel) => {
        this.ConfirmChannel = channel;
        channel.on('error', this.handleChannelError);
        return true;
    });

我应该提到 - 我正在使用TypeScript ...在这个例子中,我正在接受amqplib的承诺,并从中创建一个Q承诺(因为我不喜欢amqplib的承诺).我如何使用BlueBird或Vow做到这一点？

另一个例子是:

public myMethod(): Q.Promise<boolean> {
    var ackDeferred = Q.defer<boolean>();

    var handleChannelConfirm = (err, ok): void => {
        if (err !== null) {
            //message nacked!
            ackDeferred.resolve(false);
        }
        else {
            //message acked
            ackDeferred.resolve(true);
        }
    }

     ...some other code here which invokes callback above...

    return ackDeferred.promise;
}

这种模式是如何实施的？ …

如何在promise中包含一个可以同步/同步功能的函数？

我打电话给下面的功能

action[fn](req, res);

在函数fn(在下面的例子中)运行可以有内部(我使用动态调用每个函数)同步或 a-sync如下例所示,

1. 它是如何建议将其包装在诺言中.
2. 如果有的话如何处理错误......

我使用nodeJS应用程序

 run: function (req, res, filePath) {
        var writeStream = fs.createWriteStream(fileRelPath, {flags: 'w'});
        req.pipe(writeStream);
        req.on("end", function () {
            console.log("Finish to update data file")
        });
        res.end("File " + filePath + " saved successfully");
    }

我有一个需要返回承诺的ajax调用.功能如下

client.tickets.create(ticket,  function(err, req, result) {
  if (err) {    
    logger.error(err);

    return false;
  }

  return JSON.stringify(result);
});

在执行下一个操作之前,我必须等待此函数执行.我怎样才能宣传这个功能？

我尝试了以下内容,它给了我一个错误说Cannot call method then of undefined:

return client.tickets.create(ticket).then(function(result){
    return JSON.stringify(result);
},function(err){
    logger.error(err);
    return false;
});

我是异步编程的新手，我面临着类似于这个问题的问题，在这个问题中建议的方法使用回调，但我正在尝试使用 Promises 和 async-await 函数来做到这一点。我在控制台中未定义。这是我的例子。我错过了什么？

 //Defining the function
 async query( sql, args ) {
    const rows = this.connection.query( sql, args, async( err, rows ) => 
     { 
        if ( err )
           throw new Error(err); 
        return rows; 
      } );
}

//calling the function here 
 db.query("select 1")
 .then((row) => console.log("Rows",row)) // Rows undefined
 .catch((e) => console.log(e));

我想创建一个用于获取用户坐标的函数,但我发现我不确定我的方法是否足够好.
我想知道其他人如何编写这个函数,以便在ios和android上100%确定.
现在我有这样的事情:

function getUserLocation(callback: func) {
  Permissions.check('location')
  .then(response => {
    if (response == 'authorized') {
      navigator.geolocation.getCurrentPosition(
        (location) => {
          callback({
              latitude: location.coords.latitude, 
              longitude: location.coords.longitude
            }, response);
        },
        (error) => {
          callback(null);
        },
        Platform.OS === 'android' ? null : {enableHighAccuracy: true, timeout: 100000, maximumAge: 1000}
      );
    } else {
      callback(null, response);
    }
  })
}

因此,您可以看到我想使用此函数,因此调用者可以知道是否允许使用位置以及是否获取当前坐标.
我正在尝试的是学习如何:

1.使这样的功能等待.
2.其他人如何使这样的功能(对于两种操作系统)和100%相同的功能.

我正在使用javascript进行编程并使用Promises,现在正在使用Q.js.我终于明白我在理解我在做什么,但是我遇到了特定行为的困难时期.

我有一种情况,我有相似的相似代码重复几次.它基本上就是这样......

{
   // start
   var deferred = Q.defer();

   // do something {
      deferred.resolve();
   }

   return deferred.promise;
}

好吧,这一切都很好,但每次重复这一切都很烦人,所以我试图将它包装成一些东西.这只是一个例子,它不是整个javascript文件,因为大多数其他部分都不相关.

{
   var list = [];
   queue = function(f) {
      var deferred = Q.defer();
      list.push(f(deferred));
      return deferred.promise;
   }

   {
      queue(function(deferred){
         // do some work
         // we want the deferred here so we can resolve it at the correct time
         deferred.resolve();
      });
   }
}

问题是我不想让它在我排队的那一刻运行.我基本上想要构建列表,然后再运行它.我正在使用reduce函数运行列表Q.js

{
   return list.reduce(function(i, f) {
      return i.then(f);
   }, Q()); …

以下代码返回:

output.isPending?: true
output.isRejected?: false
output.isFulfilled?: false 

为什么？我原以为output.isRejected是true.

<html>

<head>
    <script src="http://cdnjs.cloudflare.com/ajax/libs/q.js/0.9.7/q.js"></script>
    <script src="http://jasmine.github.io/2.3/lib/jasmine.js"></script>
</head>

<body>
</body>
<script>
var output, bar;

bar = {
    doSomethingAsync: function() {
        var d = Q.defer();
        d.resolve('result');
        return d.promise;
    }
};

function Foo(bar) {
    this._bar = bar;

    this.go = function() {
        var deferred = Q.defer();
        this._bar.doSomethingAsync()
            .then(onSuccess.bind(this, deferred));

        return deferred.promise;
    }
};

function onSuccess(deferred, result) {
    deferred.reject();
}

output = new Foo(bar).go()
    .finally(function() {
        console.log('output.isPending?:', output.isPending());
        console.log('output.isRejected?:', output.isRejected());
        console.log('output.isFulfilled?:', output.isFulfilled());
    }); …

我只是想提高我对 JavaScript Promises 工作原理的理解。我创造了以下情况：

LOG 'FOO'
RUN CALLBACK LOGGING 'CALLBACK'
LOG 'BAR'

期望所有功能立即完成（我的意思是它们不会花费过多/未知的时间来完成，您将使用异步操作来完成）以便上述操作顺序将按该顺序发生。

您可以通过以下方式编写：

function foo(cb) {
  // LOG 'FOO'
  console.log('foo');
  // RUN CALLBACK
  cb();
}

function callback() {
  // LOG 'CALLBACK'
  console.log('callback');
}

foo(callback);

console.log('bar');

这会根据我在开始时指定的情况产生预期的输出。

> foo
> callback
> bar

您也可以通过以下方式编写它：

function foo() {
  return new Promise((resolve) => {
    // LOG 'FOO'
    console.log('foo');
    return resolve(null);
  });
}

function callback() {
  // LOG 'CALLBACK'
  console.log('callback');
}

foo().then(callback);

// LOG 'BAR'
console.log('bar');

这种情况会产生以下结果：

> foo …