Tajuk ditulis semula sebagai: Fungsi async rekursif tidak dapat mengembalikan nilai

Question

Saya sedang membuat fungsi async rekursif yang menjalankan pertanyaan mysql. Ini ialah pangkalan data yang saya gunakan:

+----+-------------------+------- ----+----------+-----------+--------+
|. id |
+----+-----------+-----------+----------+- -------- -------------------------+
|. 1 |. |
|. 2 |
|. 3 |
|. 00 |
|. 5 |
|. 6 |
|. 7 |
|. 8 |
|. 9 |
+----+-----------+-----------+----------+- -------- -------------------------+

Jika saya menyimpan pangkalan data ini dalam tatasusunan, saya boleh menjalankan fungsi ini:

function comp(tasks, taskId) {
    var task = tasks.find(task => task.id === taskId)
    var children = tasks.filter(t => t.parentId === taskId)

    task.children = children.map(child => comp(tasks, child.id));

    pulangkan tugas
}

untuk menyusun subtugas secara rekursif ke dalam tugas utama.

Masalahnya ialah saya tidak memahami fungsi tak segerak dengan cukup baik.

Ini adalah kemajuan saya setakat ini:

async function comp(taskId) {
    // SELECT * FROM tasks WHERE id = taskId
    var task = tunggu con.promise().query('select * from tasks where id = ' + taskId)

    
    // SELECT * FROM tasks WHERE parentId = taskId
    var children = await con.promise().query('select * from tasks where parentid = ' + taskId)

    
    tugasan[0][0].kanak-kanak = kanak-kanak[0].peta(kanak-kanak => {
        comp(child.id)
    })
    console.log(tugas[0])
    
}

Tetapi ini mengembalikan tugasan dengan subtugas yang tidak ditentukan:

[
  {
    id: 1,
    tugas: 'Bersihkan apartmen',
    selesai: 0,
    ibu bapa: null,
    dicipta oleh: 1,
    dicipta pada: 2022-03-23T23:47:33.000Z,
    kanak-kanak: [ undefined, undefined ]
  }
]

Ringkasnya, apa yang saya mahukan ialah yang berikut:

{
    id: 1,
    tugas: 'Bersihkan apartmen',
    selesai: 0,
    ibu bapa: null,
    dicipta oleh: 1,
    dicipta pada: 23-03-2022T23:47:33.000Z,
    kanak-kanak: [
        {
            id: 2,
            tugas: 'Bersihkan bilik air',
            selesai: 0,
            ibu bapa: 1,
            dicipta oleh: 1,
            dicipta pada: 23-03-2022T23:47:33.000Z,
            kanak-kanak: [
                {
                    ID: 4,
                    tugas: 'mandi basuh',
                    selesai: 0,
                    ibu bapa: 2,
                    dicipta oleh: 1,
                    dicipta pada: 23-03-2022T23:47:33.000Z,
                    kanak-kanak: [ ... ]
                  },
                  {
                    id: 5,
                    tugas: 'mencuci tandas',
                    selesai: 0,
                    ibu bapa: 2,
                    dicipta oleh: 1,
                    dicipta pada: 23-03-2022T23:47:33.000Z,
                    kanak-kanak: [ ... ]
                  },
            ]
          },
          {
            id: 3,
            tugas: 'Bersihkan dapur',
            selesai: 0,
            ibu bapa: 1,
            dicipta oleh: 1,
            dicipta pada: 2022-03-23T23:47:33.000Z,
            kanak-kanak: [ ... ]
          },
        
        
  }

Sebarang cadangan?

Answer 1

Anda sedang menunggu dua item asal yang dijangka selesai dijalankan sebelum memulakan panggilan rekursif seterusnya dan kemudian mencetak tanpa menunggu panggilan rekursif itu sendiri.

Pertama, anda perlukan

await comp(child.id);

Tetapi anda juga perlu menunggu setiap kanak-kanak selesai berlari.

Promise.all(array)

akan menunggu setiap janji dalam tatasusunan yang anda luluskan untuk dilengkapkan, manakala children[0].map(async () => {}) akan mengembalikan pelbagai janji. Teruskan menunggu dan anda sepatutnya baik-baik saja.

Answer 2

Sebenarnya, satu-satunya masalah dengan kod anda ialah anda tidak menunggu janji diselesaikan apabila semua janji dalam tatasusunan daripada fungsi async comp()的结果。 map()将返回一个Promise数组，你需要等待所有这些Promise，可以使用Promise.all()来实现。 Promise.all()返回一个Promise，当传递给Promise.all() telah diselesaikan. Jika anda menunggunya, susunan anak anda akan disebarkan seperti yang anda jangkakan.

Ini adalah kod menggunakan Promise.all(). Memandangkan saya tidak mempunyai pangkalan data yang betul pada masa ini, saya menggantikan semua panggilan async pangkalan data anda dengan panggilan tak segerak kepada fungsi dengan kelewatan buatan supaya anda boleh melihat bagaimana panggilan sedang menunggu dan sama ada keputusan sebenarnya sedang menunggu untuk.

const data = [
  {
    id: 1,
    task: "清洁公寓",
    completed: 0,
    parentid: null,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
  {
    id: 2,
    task: "清洁浴室",
    completed: 0,
    parentid: 1,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
  {
    id: 3,
    task: "清洁厨房",
    completed: 0,
    parentid: 1,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
  {
    id: 4,
    task: "洗淋浴器",
    completed: 0,
    parentid: 2,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
  {
    id: 5,
    task: "清洗马桶",
    completed: 0,
    parentid: 2,
    createdby: 1,
    createDate: "2022-03-24 00:47:33",
  },
  {
    id: 6,
    task: "清洁玻璃窗",
    completed: 1,
    parentid: 4,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
  {
    id: 7,
    task: "清洁水龙头",
    completed: 0,
    parentid: 4,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
  {
    id: 8,
    task: "清洁水槽",
    completed: 0,
    parentid: 3,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
  {
    id: 9,
    task: "倒垃圾",
    completed: 1,
    parentid: 3,
    createdby: 1,
    createdat: "2022-03-24 00:47:33",
  },
];

async function comp(tasks, taskId) {
  // 在这里执行你的数据库调用（这里只是模拟延迟，但函数是异步的，所以结果将保持不变）
  var task = await queryFind(tasks, taskId);
  var children = await queryFilter(tasks, taskId);

  // map()返回一个Promise数组，因为comp()返回一个Promise
  // Promise.all()返回一个Promise，当数组中的所有Promise都解决时返回
  task.children = await Promise.all(
    children.map((child) => comp(tasks, child.id))
  );

  return task;
}

// 这个函数模拟了一个异步的数据库访问。
async function queryFind(tasks, taskId) {
  // 等待100毫秒（模拟延迟）
  await sleep(100);
  return tasks.find((task) => task.id === taskId);
}

// 这个函数模拟了一个异步的数据库访问。
async function queryFilter(tasks, taskId) {
  // 等待100毫秒（模拟延迟）
  await sleep(100);
  return tasks.filter((t) => t.parentid === taskId);
}

// 延迟执行，这里应该模拟网络延迟
async function sleep(ms) {
  return new Promise((resolve) => setTimeout(() => resolve(), ms));
}

// 从ID为1的任务开始；需要将函数调用包装在一个异步方法中才能使用await
(async () => {
  const test = await comp(data, 1);
  console.log(JSON.stringify(test, null, 4));
})();