JA : Translate middle of "setImmediate"

locale/ja/docs/guides/timers-in-node.md

@@ -1,8 +1,9 @@
 ---
-title: Timers in Node.js
+title: Node.js のタイマー
 layout: docs.hbs
 ---
 
+<!-- 
 # Timers in Node.js and beyond
 
 The Timers module in Node.js contains functions that execute code after a set
@@ -12,6 +13,17 @@ To fully understand when timer functions will be executed, it's a good idea to
 read up on the the Node.js
 [Event Loop](/en/docs/guides/event-loop-timers-and-nexttick/).
 
+ -->
+# Node.js のタイマーと仕組み
+
+Node.js の Timers モジュールには、
+一定期間後にコードを実行する関数が含まれています。
+ブラウザの JavaScript API をエミュレートするためにすべてのメソッドがグローバルに利用可能であるため、
+`require()` を介してタイマーをインポートする必要はありません。
+タイマー関数がいつ実行されるかを完全に理解するためには、
+Node.js の[イベントループ](/ja/docs/guides/event-loop-timers-and-nexttick/)を読むことをお勧めします。
+
+<!-- 
 ## Controlling the Time Continuum with Node.js
 
 The Node.js API provides several ways of scheduling code to execute at
@@ -21,6 +33,17 @@ its own implementation of these methods. Timers integrate very closely
 with the system, and despite the fact that the API mirrors the browser
 API, there are some differences in implementation.
 
+ -->
+## Node.js を使って連続した時間を制御する
+
+Node.js APIには、現時点以降のある時点でコードを実行するように
+スケジューリングする方法がいくつかあります。
+以下の関数はほとんどのブラウザで利用可能であるためおなじみのように思われるかもしれませんが、
+Node.js は実際にはこれらのメソッドの独自の実装を提供します。
+タイマーはシステムと非常に密接に統合されており、
+API がブラウザ API を反映しているという事実があるにもかかわらず、実装にはいくつかの違いがあります。
+
+<!-- 
 ### "When I say so" Execution ~ *`setTimeout()`*
 
 `setTimeout()` can be used to schedule code execution after a designated
@@ -56,6 +79,43 @@ timeout that was set. This returned object can be used to cancel the timeout (
 see `clearTimeout()` below) as well as change the execution behavior (see
 `unref()` below).
 
+ -->
+### "そう言うとき" 実行する ~ *`setTimeout()`*
+
+`setTimeout()` を使用して、
+指定したミリ秒後に
+コードの実行をスケジュールすることができます。
+この関数はブラウザの JavaScript API の [`window.setTimeout()`](https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout)に似ていますが、
+コードの文字列を渡して実行することはできません。
+
+`setTimeout()` は、最初の引数として実行する関数と、
+2番目の引数として数値として定義されたミリ秒の遅延を受け入れます。
+追加の引数も含めることができ、これらは関数に渡されます。
+これはその一例です:
+
+```js
+function myFunc(arg) {
+  console.log(`arg was => ${arg}`);
+}
+
+setTimeout(myFunc, 1500, 'funky');
+```
+
+上記の関数 `myFunc()` は、`setTimeout()` の呼び出しにより、
+可能な限り 1500 ミリ秒 (または 1.5 秒) くらいで実行されます。
+
+設定されたタイムアウト間隔は、
+その*正確な*ミリ秒数の後に実行することに依存することはできません。
+これは、イベントループをブロックまたは保留している他の実行コードがタイムアウトの実行を遅らせるためです。
+*唯一*保証されているのは、
+タイムアウトが宣言されたタイムアウト間隔より早く実行されないということです。
+
+`setTimeout()` は、設定されたタイムアウトを参照するために使用できる
+`Timeout` オブジェクトを返します。
+この返されたオブジェクトを使用して、タイムアウトをキャンセル (下記の `clearTimeout()` を参照) し、
+実行動作を変更 (下記の`unref()` を参照) することができます。
+
+<!-- 
 ### "Right after this" Execution ~ *`setImmediate()`*
 
 `setImmediate()` will execute code at the end of the current event loop cycle.
@@ -99,6 +159,50 @@ code has been scheduled to execute with `process.nextTick()`, the execution
 cannot be stopped, just like with a normal function. Refer to [this guide](/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick)
 to better understand the operation of `process.nextTick()`.
 
+ -->
+### "この直後に" 実行する ~ *`setImmediate()`*
+
+`setImmediate()` は現在のイベントループサイクルの終わりにコードを実行します。
+このコードは、現在のイベントループ内の I/O 操作の*後*、
+および次のイベントループのためにスケジュールされたタイマーの*前*に実行されます。
+このコードの実行は「この直後」に行われると考えることができます。
+つまり、`setImmediate()` 関数呼び出しに続くコードは、
+`setImmediate()`関数引数の前に実行されます。
+
+`setImmediate()` の最初の引数は実行する関数になります。
+それ以降の引数は、実行時に関数に渡されます。これが例です:
+
+```js
+console.log('before immediate');
+
+setImmediate((arg) => {
+  console.log(`executing immediate: ${arg}`);
+}, 'so immediate');
+
+console.log('after immediate');
+```
+
+`setImmediate()` に渡された上記の関数は、すべての実行可能コードが実行された後に実行され、
+コンソール出力は次のようになります:
+
+```
+before immediate
+after immediate
+executing immediate: so immediate
+```
+
+`setImmediate()` は `Immediate` オブジェクトを返します。
+これを使用して、スケジュールされた Immediate をキャンセル (下記の `clearImmediate()` を参照) できます。
+
+Note: Don't get `setImmediate()` confused with `process.nextTick()`. There are
+some major ways they differ. The first is that `process.nextTick()` will run
+*before* any `Immediate`s that are set as well as before any scheduled I/O.
+The second is that `process.nextTick()` is non-clearable, meaning once
+code has been scheduled to execute with `process.nextTick()`, the execution
+cannot be stopped, just like with a normal function. Refer to [this guide](/en/docs/guides/event-loop-timers-and-nexttick/#process-nexttick)
+to better understand the operation of `process.nextTick()`.
+
+<!-- 
 ### "Infinite Loop" Execution ~ *`setInterval()`*
 
 If there is a block of code that should execute multiple times, `setInterval()`
@@ -123,6 +227,32 @@ milliseconds, or 1.5 seconds, until it is stopped (see below).
 Just like `setTimeout()`, `setInterval()` also returns a `Timeout` object which
 can be used to reference and modify the interval that was set.
 
+ -->
+### "Infinite Loop" Execution ~ *`setInterval()`*
+
+If there is a block of code that should execute multiple times, `setInterval()`
+can be used to execute that code. `setInterval()` takes a function
+argument that will run an infinite number of times with a given millisecond
+delay as the second argument. Just like `setTimeout()`, additional arguments
+can be added beyond the delay, and these will be passed on to the function call.
+Also like `setTimeout()`, the delay cannot be guaranteed because of operations
+that may hold on to the event loop, and therefore should be treated as an
+approximate delay. See the below example:
+
+```js
+function intervalFunc() {
+  console.log('Cant stop me now!');
+}
+
+setInterval(intervalFunc, 1500);
+```
+In the above example, `intervalFunc()` will execute about every 1500
+milliseconds, or 1.5 seconds, until it is stopped (see below).
+
+Just like `setTimeout()`, `setInterval()` also returns a `Timeout` object which
+can be used to reference and modify the interval that was set.
+
+<!-- 
 ## Clearing the Future
 
 What can be done if a `Timeout` or `Immediate` object needs to be cancelled?
@@ -151,6 +281,36 @@ clearImmediate(immediateObj);
 clearInterval(intervalObj);
 ```
 
+ -->
+## Clearing the Future
+
+What can be done if a `Timeout` or `Immediate` object needs to be cancelled?
+`setTimeout()`, `setImmediate()`, and `setInterval()` return a timer object
+that can be used to reference the set `Timeout` or `Immediate` object.
+By passing said object into the respective `clear` function, execution of
+that object will be halted completely. The respective functions are
+`clearTimeout()`, `clearImmediate()`, and `clearInterval()`. See the example
+below for an example of each:
+
+```js
+const timeoutObj = setTimeout(() => {
+  console.log('timeout beyond time');
+}, 1500);
+
+const immediateObj = setImmediate(() => {
+  console.log('immediately executing immediate');
+});
+
+const intervalObj = setInterval(() => {
+  console.log('interviewing the interval');
+}, 500);
+
+clearTimeout(timeoutObj);
+clearImmediate(immediateObj);
+clearInterval(intervalObj);
+```
+
+<!-- 
 ## Leaving Timeouts Behind
 
 Remember that `Timeout` objects are returned by `setTimeout` and `setInterval`.
@@ -183,6 +343,49 @@ setImmediate(() => {
   timerObj.ref();
 });
 ```
+ -->
+## Leaving Timeouts Behind
+
+Remember that `Timeout` objects are returned by `setTimeout` and `setInterval`.
+The `Timeout` object provides two functions intended to augment `Timeout`
+behavior with `unref()` and `ref()`. If there is a `Timeout` object scheduled
+using a `set` function, `unref()` can be called on that object. This will change
+the behavior slightly, and not call the `Timeout` object *if it is the last
+code to execute*. The `Timeout` object will not keep the process alive, waiting
+to execute.
+
+In similar fashion, a `Timeout` object that has had `unref()` called on it
+can remove that behavior by calling `ref()` on that same `Timeout` object,
+which will then ensure its execution. Be aware, however, that this does
+not *exactly* restore the initial behavior for performance reasons. See
+below for examples of both:
+
+```js
+const timerObj = setTimeout(() => {
+  console.log('will i run?');
+});
+
+// if left alone, this statement will keep the above
+// timeout from running, since the timeout will be the only
+// thing keeping the program from exiting
+timerObj.unref();
+
+// we can bring it back to life by calling ref() inside
+// an immediate
+setImmediate(() => {
+  timerObj.ref();
+});
+```
+<!-- 
+## Further Down the Event Loop
+
+There's much more to the Event Loop and Timers than this guide
+has covered. To learn more about the internals of the Node.js
+Event Loop and how Timers operate during execution, check out
+this Node.js guide: [The Node.js Event Loop, Timers, and
+process.nextTick()](/en/docs/guides/event-loop-timers-and-nexttick/).
+
+ -->
 ## Further Down the Event Loop
 
 There's much more to the Event Loop and Timers than this guide