我在我的业余爱好节点项目中遇到这个问题.我有一个函数(processDataSet)正在处理数据数组(inputArray)并返回一个promise.该函数使用for循环遍历输入数组并saveObjectData在每一轮调用函数.此保存功能处理单个数据条目并返回承诺.

似乎如果saveObjectData函数失败,processDataSet函数捕获返回拒绝,但它自己reject似乎没有在for循环中正确调用.我认为这是一个时间问题,我不明白.查看代码下方的输出打印结果.

function processDataSet(inputArray, scriptConfig) {
    var contentType = scriptConfig.contentType;
    return new Promise(function(resolve, reject) {
        if(!Array.isArray(inputArray)) {
            return reject(new Error("Input data is not an array. Cannot process."));
        }
        if(!scriptConfig) {
            return reject(new Error("Invalid scriptConfig"));
        }
        if(!typeof contentType === "string" && !contentType instanceof String) {
            return reject(new Error("Invalid contentType for the data set. The parameter should be a string."));
        }

        console.log("Post processing data for the script " + scriptConfig.name …

Axios被描述为基于Promise的，因此在使用Axios查询数据时是否需要返回新的Promise？

app.get('/api/nearbyRecommendations', async (req, res) => {

    if(!req.query) return res.send({ error: 'Please enable location to get recommendations.' })

    try {
        const { longitude, latitude } = req.query
        const locationName = await location.getLocationName(longitude, latitude)
        res.send(locationName)
    } catch (error) {
        res.send(error)
    }
})   

我正在向MapBox API发出GET请求，但是即使为.xn（）块中添加了一个新的Error，尽管为Axios请求设置了catch块，我也似乎从未收到任何错误。

const getLocationName = async (latitude, longitude) => {
    return new Promise((resolve, reject) => {
        axios.get(`https://api.mapbox.com/geocoding/v5/mapbox.places/${longitude},${latitude}.json?access_token=${darkSkyAPIKey}`, {json: true})
        .then(response => {
            if(!response.data) return reject({ error: 'No location found.' })

            resolve(response.data)
        }).catch(error => {
            reject(error)
        })
    })
}

如果可能的话，请提供帮助并指出可能进行更改以遵循最佳实践的任何内容。

异步编程比同步编程困难得多。

使用nodeJS，我正在尝试以下操作：

for (var i = 0; i < 10; i++) {
    someFunction().then(function() {
        // Do stuff
    });
}

但是我希望循环仅在“完成”部分完成后才能继续。

任何想法如何可以轻松实现...？

谢谢！

我正在寻找类似的东西Promise.all,即使在一个或多个承诺拒绝或抛出错误的情况下,它也将继续同时解决承诺.每个请求都不依赖于其他请求.

接近我想要的 - 请参阅评论

function fetchRequest (request) {
  return new Promise(function (resolve, reject) {
    fetch(request)
    .then(function(response) {
      return response.text();      

    }).then(function (responseXML) {
      //Do something here. Maybe add data to dom
      resolve(responseXML);

    }).catch(function (err) {
      reject(new Error(err));
    }
}

function promiseRequests (requests) {
  var result = Promise.resolve();

  for (var i = 0; i < requests.length; i++) {
    result = fetchRequest(requests[i])
  }

  //This is wrong as it will resolve when the last promise in the requests array resolves
  // - …

我正在看这个问题,答案是有道理的

什么是明确的承诺构建反模式,我该如何避免它？

但是,如果你只想简单地在函数中添加一条日志消息或者简单的东西有什么方法可以避免创建像这样的新承诺

function getStuffDone(param) {
    return new Promise(function(resolve, reject) {
        // using a promise constructor
        myPromiseFn(param+1)
        .then(function(val) {
            console.log("getStuffDone executing");
            resolve(val);
        }).catch(function(err) {
            console.log("getStuffDone error");
            reject(err);
        });
    });
}

如果你想在这个位置运行promise之前想要一条日志消息怎么办？这会让事情变得更加困难吗？

function getStuffDone(param) {
    return new Promise(function(resolve, reject) {
        // using a promise constructor
        console.log("getStuffDone starting");
        myPromiseFn(param+1)
        .then(function(val) {
            console.log("getStuffDone executing");
            resolve(val);
        }).catch(function(err) {
            console.log("getStuffDone error");
            reject(err);
       });
   });
}

我们需要编写一个Node.js函数，该函数轮询某个API端点以获取先前请求的计算结果。结果需要一个随机的时间才能生成，而可能根本不生成。我们希望尽快得到它，但是我也不想等待太久，这意味着在一定数量的API调用之后，我们希望函数失败（拒绝Promise）。

我们的代码和API之间存在一种通信方式。

const Bluebird = require('bluebird');

function getResult() {
  return new Bluebird(async function (resolve, reject) {

    let counter = 0;

    while (counter < 10) {
      await Bluebird.delay(1000);

      const res = await apiCall();
      if (res.data) {
        resolve(res.data);
      } else {
        counter += 1;
      }
    }

    reject('timeout');
  });
}

这是正确的方法吗？

我在接收两个对等点之间的 WebRTC 数据通道消息时遇到问题。

下面是一个 MVP，其中两个对等点位于同一页面，并且信号通道被替换为纯 JavaScript 对象交换。

我不会选择使用trickle ICE，并且我知道不使用它的缺点，我不认为它会以任何方式干扰我下面的 MVP。

代码的行为完全符合预期，并且所有日志消息都会通过。唯一缺少的是用于数据通道消息处理的消息，就好像消息从未从任一对等方发送到另一方一样。这是尝试发送Test 的事件处理程序。发送方法调用失败并出现空引用错误，我无法跟踪其根本原因。

我遵循《Untangling the WebRTC Flow》来获得这个 MVP。您可以在这里实时查看它，因此您不必亲自运行它。

class Peer {\n    constructor(name) {\n        this.name = name;\n    }\n    offer() {\n        const peerConnection = new webkitRTCPeerConnection({ iceServers: [ { url: "stun:stun.l.google.com:19302" } ] });\n        peerConnection.onnegotiationneeded = event => console.debug(this.name, "onnegotiationneeded");\n        peerConnection.onsignalingstatechange = event => console.debug(this.name, "onsignalingstatechange", peerConnection.signalingState);\n        peerConnection.onicegatheringstatechange = event => console.debug(this.name, "onicegatheringstatechange", peerConnection.iceGatheringState);\n        peerConnection.oniceconnectionstatechange = event => console.debug(this.name, "oniceconnectionstatechange", peerConnection.iceConnectionState);\n …

我正在循环中处理一个列表,该循环运行async返回一个promise我不想退出处理异常,所以我聚合它们并将它们传递给外部finally块中的resolve回调.我想知道这是否是反模式,如果是,请提供一个如何正确执行的指针.谢谢.

例

async doSomething(list) {
let errorCount = 0
let errors = []
return new Promise(async (resolve, reject) => {
  try {
    list.forEach(async (item) => {
      try {
        actionThatThrows(item)
      } catch (e) {
        errorCount++
        errors[errorCount] = e
      }
    })
  } catch (e) {
    errorCount++
    errors[errorCount] = e
  } finally {
    if (errorCount > 0) {
      resolve(errors)
    } else {
      resolve()
    }
  }
})

}

我上一篇文章中强调的某些性能建议我参考stackoverflow 中的以下问题避免显式的 Promise 构造反模式

坦白说，我对 JS 和 Node 都是新手，也没有经常使用 Promise。我去读了那些文章，但要么我无法理解或无法联系，要么我对承诺的理解一直模糊/错误

所以我决定在新线程中提出这个问题并寻求帮助。

那么我在做什么以及为什么这样做

我正在创建帮助程序/通用函数，我可以用它来保持代码整洁，如果我想随时更改函数内部的任何内容，我不必手动更改每个函数。

这些是我制作的功能

//Find user by email Address 
const findUserByEmail = (emailAddress) => {
    return new Promise((resolve, reject) => {
     User.findOne({email: emailAddress}).then(response => {
        resolve(res)
      }).catch(error => {
        reject("Error in findUserByEmail", error);
      })
    })
}

//Create User 
const createNewUser = (newUserDetails) => {
    return new Promise((resolve, reject) => {
      new User({
         fullName: newUserDetails.fullName,
         email: newUserDetails.email,
         image: newUserDetails.image,
         gender: newUserDetails.gender,
         age: newUserDetails.age
      }).save().then((response) => { …

我有点困惑 promise.all 是如何工作的，它是否并行运行 promise 数组？

所以这是一个示例代码

// index.js

const getSomething = async (args) => {
  return await apiCallHere(args)
}

// Create Array of Promises
const arrayOfPromises = sampleArray.map(sample => new Promise((resolve, reject) => {
      try {
        const something = this.getSomething(sample, args)
        resolve(something) 
      } catch (error) {
        reject(error)
      }
}))

await Promise.all(arrayOfPromises)

据我观察， Promise.all 并行运行承诺，并等待所有承诺完成。