相关疑难解决方法(0)

我有一个我正在使用的API的速率限制器,它允许每秒20个请求.所有请求都是基于承诺的,一旦有响应,承诺将通过API数据解决.

问题:

我设置了一个promiseArray,它包含所有等待响应的58k承诺.所以内存越来越慢,直到我的内存耗尽为止.在我的具体情况下,我不需要将已解析的数据传递给我then(),数据占用了我所有的RAM.

代码:

  }).then(() => {
    // 2. Crawl for all clanprofiles from these leaderboards
    const promiseArray = []
    for (let i = 0; i < clanTags.length; i++) {
      // Resolved data from getClanProfile() is eating up all my RAM
      const p = backgroundScheduler.getClanProfile(clanTags[i], true)
      promiseArray.push(p)
    }
    return Promise.all(promiseArray)
  }).then(() => {

那么有没有办法等待promiseArray被解析而不需要解析数据？

所以我试图增加数据以将数字发送到其他用户的数字。

const sendNum = async(e) => {
        e.preventDefault();
        
        
        const targetQuery = query(userCol, where("keycode", "==", parseInt(target)));
        const targetSnapshot = await getDocs(targetQuery)
        
        targetSnapshot.forEach((document) => {
            console.log(document.data().num)
            console.log(document.id)
            const targetRef = doc(db, 'users', document.id)

            setDoc(targetRef, {
                num: // increment user data here
            }, {merge: true})
        })
}

但是我找到的文档，我不太理解它们。而我所理解的，它已经过时了。所以如果有人知道怎么做我会很高兴:)

在我的程序源代码中我有以下函数（Promise并发限制函数，类似于pLimit）：

async function promiseMapLimit(
  array,
  poolLimit,
  iteratorFn,
) {
  const ret = [];
  const executing = [];
  for (const item of array) {
    const p = Promise.resolve().then(() => iteratorFn(item, array));
    ret.push(p);

    if (poolLimit <= array.length) {
      const e = p.then(() => executing.splice(executing.indexOf(e), 1));
      executing.push(e);
      if (executing.length >= poolLimit) {
        await Promise.race(executing);
      }
    }
  }

  return Promise.all(ret);
}

它工作正常，所以如果我向它传递一个数字数组 [1..99] 并尝试将其乘以 2，它将给出正确的输出 [0..198]。

const testArray = Array.from(Array(100).keys());

promiseMapLimit(testArray, 20, async (value) => value * 2).then((result) =>
  console.log(result)
);

代码示例 - js …

function getNamesById(nameIds) {
    var defer = $q.defer();

    var result = [];
    nameIds.forEach(function (nameId) {
        account.getNameById(nameId).then(function (name) {
            result[nameId] = name;
        });
    });
    defer.resolve(result);
    return defer.promise;
}

我上面的代码显然没有按预期工作。我必须迭代一个 id 数组并构造另一个以 id 作为键的数组，以及从异步函数获取的值

为什么这个片段

const firstArray = ['toto', 'toto'];
const secondArray = ['titi', 'titi'];
firstArray.forEach(async (toto, i) =>
{
  await secondArray.forEach(async titi =>
  {
    // async code
    console.log(titi, i);
  });
  // async code
  console.log(toto, i);
});

产生以下输出：

删除await关键字会产生预期的输出

我的猜测是它存在于await关键字的行为中，因为没有它，生成的输出就是预期的输出。

编辑：这纯粹是一个微不足道的问题。我想了解为什么在 forEach 之前使用 wait 提供这种行为。这背后没有“具体代码”。

EDIT2：编辑了片段，因为评论和答案反映了对我的问题的误解

我的 firestore 数据有点像这样：

"Support": { "userid":"abcdxyz", "message": "hello" }

我正在使用 nodejs 来获取我的数据，我还想显示发送此消息的人的电子邮件地址和姓名。所以我使用以下功能：

database.collection("support").get().then(async function (collections) {
var data = [];
console.log("data collected");
collections.forEach(async function (collection) {
    var temp = {};
    var collectionData = collection.data()
    var userInfo = await getUserDetails(collectionData.userId)
    temp.name = userInfo.name
    temp.supportMessage = collectionData.supportMessage
    data.push(temp)
    console.log("data pushed")
});
    console.log("data posted")
    return res.status(200).end(JSON.stringify({ status: 200, message: "Support Message fetched successfully.", data: data }))
}).catch(error => {
    return res.status(500).end(JSON.stringify({ status: 500, message: "Error: " + error }))
});

这里的日志顺序是：采集数据、发布数据、推送数据

我想要这样的顺序：收集数据，推送数据（x 次），发布数据

给定标准的Express.js设置

const express = require('express');
const app = express();
const router = express.Router();

router.get('/test/:id', (req, res) => {
  return res.status(200).json({ hello: 'world' });
});

app.use('/api', router);

app.listen(3000, () => console.info('Up on port 3000));

我一次又一次地向端点发出1000个请求：

const fetch = require('node-fetch');
for (let i = 0; i < 1000; i++) {
  let id = Math.floor(Math.random() * 12) + 1;
  fetch(`http://localhost:3000/api/test/${id}`).then(res => res.json()).then(data => console.log(data)).catch(error => console.error(error));
}

我确实经常看到返回的数据，但有时我会看到ECONNRESET错误。ECONNRESET错误消息的数量也各不相同：有时我会收到一些，有时会更多。我确实了解该消息，但是无法解决该问题背后的问题。

这是一个示例错误：

{ FetchError: request to http://localhost:3000/api/test/8 failed, reason: connect ECONNRESET 127.0.0.1:3000 …

我有一个字符串数组,['string1', 'string2']我想将它们中的每一个转换为(例如:) blob:http://something-new但我得到的结果(2) [Promise, Promise].如何获得解决的价值？

这是代码

const results = id.map(async assetId => {
    const responseIds = await API.assets.getAssetFileById(assetId);
    let asset = responseIds.data.asset;
    const urlCreator = window.URL || window.webkitURL;
    const blobFile = await file_helper.dataUrlToBlob(asset.file);

    return asset.file = await urlCreator.createObjectURL(blobFile);
});

console.log(results) // (2) [Promise, Promise]

预期产量:

console.log(results) // (2) ['blob:http://something-new1', 'blob:http://something-new2']

我正在尝试从Figma API中获取数据，但不幸的是，我无法在一个调用中做到这一点。我首先需要获取一个团队中所有项目的列表，然后为每个项目获取文件列表。

这是我要做的代码：

  const [projects, setProjects] = useState([]);
  const [files, setFiles] = useState([]);

  useEffect(() => {
    const fetchProjects = async () => {
      const result = await axios(
        `https://api.figma.com/v1/teams/${teamId}/projects`, {
          headers: { 'Authorization': `Bearer ${token}` }
        });
      setProjects(result.data.projects);
    };

    fetchProjects();
  }, []);

  useEffect(() => {
    projects.forEach(project => {
      const fetchFiles = async () => {
        const result = await axios(
          `https://api.figma.com/v1/projects/${project.id}/files`, {
            headers: { 'Authorization': `Bearer ${token}` }
          });

        setFiles([ ...files, {
          projectName: project.name,
          files: result.data.files
        }])
      };

      fetchFiles();
    }) …

我很难理解与处理 Promise 的情况有何for...of不同。.forEach()

使用这个片段：

const allSettled = async arr => {
    const data = []

    for (const promise of arr) {
        try {
            const result = await promise;
            data.push(result);
        } catch (e) {
            data.push(e)
        }
    }

    return data
}

我检查数组中的每个承诺，等待它解决并将结果推送到data. 它按顺序执行。

如果我有这个片段：

const badAllSettled = arr => {
    const data = []

    arr.forEach(async promise => {
        try {
            const result = await promise;
            data.push(result);
        } catch (e) {
            data.push(e)
        }
    })

    return data
}

我得到空数组（因为 …