相关疑难解决方法(0)

我目前正在等待所有承诺按顺序完成:

(async() => {
  let profile = await profileHelper.getUserData(username);
   let token = await tokenHelper.getUserToken(username);
   console.log(profile);
   console.log(token);
   return {profile: profile, token: token};
})();

但是这样,配置文件和令牌按顺序执行.由于两者彼此独立,我希望它们两者一起独立执行.我认为这可以使用Promise.all完成,但我不确定语法,我也找不到任何帮助.

所以我的问题是如何将上面的api调用转换为一起运行然后返回最终输出.

我希望浏览器在发生类型错误时显示错误消息.
错误,如无法读取属性的未定义或未定义的引用.

new Promise(function(resolve,reject){
    // do stuff ...
    reject('something logical is wrong');
}).catch(e => console.error(e));

new Promise(function(resolve,reject){
    // do stuff, and a syntax error :/
    var a = { };
    a.something.otherthing = 1; /* we have an error here */
    // ... 
}).catch(e => console.error(e));

在第一个例子中,错误是逻辑错误,并且可以在catch(..)块中捕获它. 但在第二个例子中,它是一个明显的开发错误,它在开发新东西时一直发生.我不想抓住它,我希望浏览器像控制台中的其他错误一样向我显示错误.我希望能够在异常上打开chrome暂停并查看其他变量的状态.我想在控制台中看到堆栈跟踪. 我希望它像一个正常的错误.

任何的想法？

节点 8.1.2，我有一个结构，其中一个文件在映射中调用另一个文件的函数。在一个真实的例子中，我会使用Promise.all，map但这不是这里的问题。这是结构：

A.js:

const { b } = require('./B')

function expressStuff (req, res, next) {
  things.map(thing => {
    return b(thing)
  }))

  return res.status(200).json(...)
}

B.js:

// Thing -> Promise<Object>
function b (thing) {
  return ThingModel.update(...) // this returns a Promise but FAILS and throws an errror
}

module.exports = { b }

好的。所以在函数中，b我尝试获取一些异步数据（从数据库中）。它失败并抛出 Uncaught Promise Rejection。

如何处理？

我尝试了多种解决方案：

A1.js:

const { b } = require('./B')

function expressStuff (req, res, next) {
  things.map(thing => { …

我想使用redux-saga运行并行效果，如果发生错误则不抛出异常。

all如果满足以下条件，则使用redux-saga 的效果：

在所有效果完成之前，其中一种效果被拒绝：将拒绝错误引发到生成器内部。

基本上，我想等待所有效果完成以触发动作。我想做这样的事情，但用all其他东西代替：

export function* getSaga() {
  yield put(request());
  try {
    yield all([fetchItems1, fetchItems2, fetchItems3]);
    // Wait for all to resolve or get rejected, then dispatch succeed.
    yield put(actions.succeeded());
  } catch (e) {
    // This should never happen.
  }
}

我尝试使用，fork但是如果一项失败，它将取消所有其他任务。而且我尝试使用spawn它，但是它并不等待任务完成发送succeeded。

使用常规JS，有一种称为反射的模式，我想将其应用到传奇中。

我们如何实现这一目标？

谢谢

我的问题基本上是一个组合

• 限制并发的最佳方法是什么？
• 等到所有承诺完成，即使有些承诺被拒绝

我知道Promise.allSettled，但我未能找到限制并发的好方法。

到目前为止我所拥有的：

想法1使用p-limit：

const pLimit = require('p-limit');
const limit = pLimit(10);

let promises = files.map(pair => {
    var formData = {
        'file1': fs.createReadStream(pair[0]),
        'file2': fs.createReadStream(pair[1])
    };
        
    return limit(() => uploadForm(formData));
});
    
(async () => {
    const result = await Promise.allSettled(promises).then(body => {
        body.forEach(value => {
            if(value.status == "rejected")
                file.write(value.reason + '\n---\n');
        });
    });
})();

我对这个解决方案的问题是，我必须首先创建所有承诺，并为此为每个承诺打开两个文件流，并且我将达到打开文件的限制。

想法 2使用p-queue：我尝试使用生成器函数在queue.on 'next'事件中创建和添加新的承诺，但我无法让它正常工作，这可能不是适合这项工作的工具。

使用 PromisePool 的想法 3：一开始这看起来很有希望。其中一些支持生成器函数来为池创建承诺，但我找不到一个明确声明其行为类似于Promise.allSettled.

我实施es6-promise-pool …

我有一系列的承诺。

我只想在所有承诺都给了我回应之后才继续，无论它们是解决还是拒绝。我认为 all() 函数可以处理它，但看起来只有当数组中的所有承诺都得到解决并且不考虑某些承诺的拒绝时它才有效。

我可以使用什么功能？

示例：函数 getUser 返回一个 Promise 对象。当所有的承诺给我一个回应时，我想抓住触发器，无论承诺是解决还是拒绝。

array_push($this->users['users'], $this->userFetcher->getUser($userName));

谢谢 ：）

我试图了解 node.js 单线程架构和事件循环，以使我们的应用程序更高效。因此，请考虑这种情况，我必须为 http api 调用进行多次数据库调用。我可以使用Promise.all()或使用单独的await.

例子：

使用异步/等待

await inserToTable1();
await insertToTable2();
await updateTable3();

使用Promise.all()我可以做同样的事情

await Promise.all[inserToTable1(), insertToTable2(), updateTable3()]

这里对于给定时间的一个 API 命中，Promise.all()将更快地返回响应，因为它并行触发 DB 调用。但是，如果我每秒有 1000 个 API 命中，会有什么不同吗？对于这种情况，事件Promise.all()循环更好吗？

更新 假设如下，通过 1000 个 API 命中，我指的是应用程序的总体流量。考虑有 20-25 个 API。其中一些可能会执行数据库操作，一些可能会进行一些 http 调用等。此外，我们永远不会达到数据库池的最大连接数。

提前致谢！！

我有一系列的承诺和每个承诺电话http.get().

var items = ["URL1", "URL2", "URL3"];
var promises = [];
//on each URL in items array, I want to create a promise and call http.get
items.forEach(function(el){
    return promises.push($http.get(el)); 
});
var all = $q.all(promises);
all.then(function success(data){
    console.log(data);
}).catch(function(reason){
    console.log("reason is", reason);
});

在我的情况下发生了什么

URL2.get没有得到解决,它立即触发catch()了$q.all.由于这种失败,all.then()永远不会被调用.

我想要的是

即使其中一项承诺遭到拒绝,我也希望所有的承诺能够继续下去.

我发现了一个类似的帖子,但解决方案建议使用另一个名为Kris Kowal的Q的角度蛋糕.所以我想知道如何在不使用外部包的情况下实现它？

鉴于以下内容

Promise.all(promises).then(resolved => {
    ...
}).catch(rejected => {
    ...
});

rejected只会包含被拒绝的第一个承诺.有没有办法捕捉所有被拒绝的承诺？

So I need to do something like:

promiseFunction1().then((result) => {

}).catch((err) => {
    // handle err
});

promiseFunction2().then((result) => {

}).catch((err) => {
    // handle err
});

....

promiseFunctionN().then((result) => {

}).catch((err) => {
    // handle err
});

// WAIT FOR BOTH PROMISES TO FINISH
functionWhenAllPromisesFinished();

I cannot use Promise.all, as I DO NOT CARE IF ONE or ALL OF THEM FAIL. I need to be sure that ALL promises have finished. Also, the callback functions in then() are …