Denoのイベントループを理解する!

Promise 自体が新しい ECMAScript の機能であり、それまでは Callback API やタスクとして処理する非同期処理が主流だった。したがって、それらを活用するために Node はタスクベースである Phase 概念を取り込んだイベントループが作られた、ということか

• タスクベースの非同期処理(タイマーの setTimeout() や fs.readFile() など)
• マイクロタスクベースの非同期処理(データ取得の fetch() など)
  • Deno はタイマー以外は基本的にこちらになる

https://developer.mozilla.org/ja/docs/Web/JavaScript/Guide/Using_promises#古いコールバック_api_をラップする_promise_の作成

Promise はコンストラクターを使って 1 から生成すこともできます。これが必要になるのは古い API をラップする場合のみでしょう。
理想的には、すべての非同期関数はプロミスを返すはずですが、残念ながら API の中にはいまだに古いやり方で成功/失敗用のコールバックを渡しているものがあります。顕著な例としては setTimeout() 関数があります。
古い様式であるコールバックとプロミスの混在は問題を引き起こします。というのは、saySomething() が失敗したりプログラミングエラーを含んでいた場合に、そのエラーをとらえられないからです。setTimeout にその責任があります。
幸いにも setTimeout をプロミスの中にラップすることができます。良いやり方は、問題のある関数をできる限り低い水準でラップした上で、直接呼び出さないようにすることです。
(上記ページより引用)

タスクベースの非同期処理自体が理想的ではなく、マイクロタスクベースの非同期処理が理想である旨が読み取れる。タスクベースとマイクロタスクベースの非同期処理が混在してしまうと問題になる。

https://nodejs.dev/learn/understanding-javascript-promises#creating-a-promise

A more common example you may come across is a technique called Promisifying. This technique is a way to be able to use a classic JavaScript function that takes a callback, and have it return a promise:
(上記ページより引用)

Promise でタスクベースの非同期処理(つまり古いタイプの非同期 API)をラップする手法は "Promisifying" と呼ばれる。

https://ja.javascript.info/promisify

const fs = require('fs');

const getFile = fileName => {
// この部分が Promisifying
  return new Promise((resolve, reject) => {
    fs.readFile(fileName, (err, data) => {
      if (err) {
        reject(err); // calling `reject` will cause the promise to fail with or without the error passed as an argument
        return; // and we don't want to go any further
      }
      resolve(data);
    });
  });
};

getFile('/etc/passwd')
  .then(data => console.log(data))
  .catch(err => console.error(err));

In recent versions of Node.js, you won't have to do this manual conversion for a lot of the API. There is a promisifying function available in the util module that will do this for you, given that the function you're promisifying has the correct signature.
(上記ページより引用)

promisifying 関数というのが util module にあり、これを使うことで手動でラップすることなくPromisify できるようになっている。

これとは別に Promise-based な API もあるよね?

マイクロタスクベースな非同期タイマーがあってもよいはずと思って探したら次の issue を発見。
https://github.com/denoland/deno/issues/4052

そこから、standard library に指定時間たったら Promise を返す関数があった。
https://deno.land/std@0.137.0/async#delay

Resolve a Promise after a given amount of milliseconds

https://github.com/denoland/deno/blob/a0d3b4ebc509d9e5dfca555084fd1100e114664a/std/util/async.ts#L110-L117

現在はこんな感じになっている。
https://github.com/denoland/deno_std/blob/58204e6f5617fe7a80dfdbe98e6d9f1cadef1d1e/async/delay.ts

Node Callback API

The callback APIs perform all operations asynchronously, without blocking the event loop, then invoke a callback function upon completion or error.
The callback APIs use the underlying Node.js threadpool to perform file system operations off the event loop thread*. These operations are not synchronized or threadsafe. Care must be taken when performing multiple concurrent modifications on the same file or data corruption may occur.
(File system: Callback API | Node.js v18.0.0 Documentation より引用)

Node Promise API

The fs/promises API provides asynchronous file system methods that return promises.
The promise APIs use the underlying Node.js threadpool to perform file system operations off the event loop thread. These operations are not synchronized or threadsafe. Care must be taken when performing multiple concurrent modifications on the same file or data corruption may occur.
(File system: Promise API | Node.js v18.0.0 Documentation より引用)

addEventListener("myEvent", () => {
  console.log("❓ Event dispatched");
  queueMicrotask(() => {
    console.log("👦 MICRO: Inner listener");
  });
});

console.log("🦖 MAINLINE: start");
const myEvent = new Event("myEvent");

queueMicrotask(() => {
  console.log("👦 MICRO: (1) top scope");
  dispatchEvent(myEvent); // 同期的にリスナーを呼び出すはず
});
queueMicrotask(() => {
  console.log("👦 MICRO: (2) top scope");
  dispatchEvent(myEvent); // 同期的にリスナーを呼び出すはず
});

setTimeout(() => {
  console.log("⏰ TIMRES: delay [100ms]");
  dispatchEvent(myEvent); // 同期的にリスナーを呼び出すはず
  queueMicrotask(() => {
    console.log("👦 MICRO: after Event dispatched");
  });
}, 100);

dispatchEvent(myEvent); // 同期的にリスナーを呼び出すはず
console.log("🦖 MAINLINE: End");

Deno の addEventListener について再度しらべてみたがやはりタスクではなく、関数呼び出しのように同期的にリスナーを呼び出していた。

❯ deno run simpleEvent.js
🦖 MAINLINE: start
❓ Event dispatched
🦖 MAINLINE: End
👦 MICRO: (1) top scope
❓ Event dispatched
👦 MICRO: (2) top scope
❓ Event dispatched
👦 MICRO: Inner listener
👦 MICRO: Inner listener
👦 MICRO: Inner listener
⏰ TIMRES: delay [100ms]
❓ Event dispatched
👦 MICRO: Inner listener
👦 MICRO: after Event dispatched

      // Repeatedly invoke macrotask callback until it returns true (done),
      // such that ready microtasks would be automatically run before
      // next macrotask is processed.

true (done) が返ってくるまでマクロタスクを繰り返しinvokeさせる。
準備できたマイクロタスクは自動的に次のマクロタスクが処理される前に実行される。

ただマイクロタスクをどこで処理しているのかが分からない。

Deno におけるマクロタスクが何なのか?

• Timers: setTimeout(cb, delay), setInterval(cb, interval) のコールバックは確実にマクロタスク