Javascript 允诺到底在引擎盖下做什么？

我试着去理解诺言，这里的一切。 我在这里所做的是使用Promise.all隐藏下面的代码，以实现相同的结果。 我明白所有的承诺都结合了数据1，数据2。 我在这里的问题是，如何承诺。所有的工作没有解决方法？ Promise是否在方法本身中解析这些数据

请告知

const readAllUsersChaining = () => {
  return new Promise((resolve, reject) => {
    let result = [];
    getDataFromFilePromise(user1Path)
      .then((data) => {
        result.push(JSON.parse(data)); // what are you doing? he's gone mad...
        return getDataFromFilePromise(user2Path);
      })
      .then((data) => {
        result.push(JSON.parse(data));
        result ? resolve(result) : reject(result);
      });
  });
};

我在这里的问题是，如何承诺。所有的工作没有解决方法

不太清楚你的意思<代码>承诺。所有仅在内部创建一个新的承诺，当所有其他承诺都已解决时，该承诺将得到解决

下面是

Promise的一个简单实现。对于参数总是Promise的情况，所有的
：

function all(promises) {
  if (promises.length === 0) {
    return Promise.resolve([]);
  }
  return new Promise((resolve, reject) => {
    const results = [];
    let resolved = 0;
    promises.forEach((promise, i) => {
      promise.then(
        result => {
          results[i] = result;
          resolved++;
          if (resolved === promised.length) {
            resolve(results);
          }
        },
        error => reject(error)
      );
  });
}

我在这里的问题是，如何承诺。所有的工作没有解决方法

不太清楚你的意思<代码>承诺。所有
仅在内部创建一个新的承诺，当所有其他承诺都已解决时，该承诺将得到解决

下面是
Promise的一个简单实现。对于参数总是Promise的情况，所有的
：

function all(promises) {
  if (promises.length === 0) {
    return Promise.resolve([]);
  }
  return new Promise((resolve, reject) => {
    const results = [];
    let resolved = 0;
    promises.forEach((promise, i) => {
      promise.then(
        result => {
          results[i] = result;
          resolved++;
          if (resolved === promised.length) {
            resolve(results);
          }
        },
        error => reject(error)
      );
  });
}

Promise.all
允许等待所有作为参数传递的Promise在
之前被填满，然后执行
方法attach

真正的用例是，当您必须对一个API执行五次调用时，如果您只想在从所有API调用中获取数据时执行一些处理，那么就需要执行五次调用。您可以依赖于
Promise.all
函数，该函数将等待所有已传递的promised都被填满，然后依次将其填满

下面我提供了一个
承诺的示例。其中有两个承诺作为论据通过。第一个有一个计时器，它在5秒后将其填满，第二个则立即将其填满。只有当两个承诺都作为参数ar fullfilled传递时，
承诺.all
才会被fullfilled


const firstPromise=新承诺（（解析、拒绝）=>{
设置超时（（）=>{
返回解析({
名称：“第一个承诺”
});
}, 5000);
});
const secondPromise=新承诺（（解决、拒绝）=>{
返回解析({
名称：“第二个承诺”
});
})
const all=Promise.all（[firstPromise，secondPromise]）。然后（（response）=>{
控制台日志（响应）；
});
Promise.all
允许在执行
然后附加
方法之前，等待所有作为参数传递的Promise被完全填充

真正的用例是，当您必须对一个API执行五次调用时，如果您只想在从所有API调用中获取数据时执行一些处理，那么就需要执行五次调用。您可以依赖于
Promise.all
函数，该函数将等待所有已传递的promised都被填满，然后依次将其填满

下面我提供了一个
承诺的示例。其中有两个承诺作为论据通过。第一个有一个计时器，它在5秒后将其填满，第二个则立即将其填满。只有当两个承诺都作为参数ar fullfilled传递时，
承诺.all
才会被fullfilled


const firstPromise=新承诺（（解析、拒绝）=>{
设置超时（（）=>{
返回解析({
名称：“第一个承诺”
});
}, 5000);
});
const secondPromise=新承诺（（解决、拒绝）=>{
返回解析({
名称：“第二个承诺”
});
})
const all=Promise.all（[firstPromise，secondPromise]）。然后（（response）=>{
控制台日志（响应）；
});“我的问题是，如何承诺。所有的工作都没有解决方法？”不太清楚你的意思<代码>承诺。所有
只是在内部创建一个新的承诺，当所有其他承诺都已解决时，该承诺将得到解决。它依赖于在组成承诺中发生的
.resolve（）
调用。“我的问题是，承诺是如何工作的。所有承诺都没有解决方法？”不太清楚您的意思
Promise.all
只是在内部创建一个新的Promise，当所有其他Promise都已解析时，该新的Promise将被解析。它依赖于在组成Promise中发生的
.resolve（）
调用。