Browse Source

doc: general improvements to timers.md

Overall improvements to timers.md documentation,

Includes squashed commit from @bengl:

  doc: add timer classes

  The timers returned by `setTimeout` and friends are
  actually instances of `Timeout` and `Immediate`.
  Documenting them as such, so that the `ref` and
  `unref` methods can be identified as methods on
  `Timeout` objects.

  Sparked by discussion in #5792

PR-URL: https://github.com/nodejs/node/pull/6937
Reviewed-By: Robert Jefe Lindstaedt <robert.lindstaedt@gmail.com>
Reviewed-By: Bryan English <bryan@bryanenglish.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
v7.x
James M Snell 9 years ago
parent
commit
86e07b7c24
  1. 2
      doc/api/globals.md
  2. 168
      doc/api/timers.md

2
doc/api/globals.md

@ -208,7 +208,7 @@ but rather than loading the module, just return the resolved filename.
[native addons]: addons.html [native addons]: addons.html
[timers]: timers.html [timers]: timers.html
[`clearImmediate`]: timers.html#timers_clearimmediate_immediateobject [`clearImmediate`]: timers.html#timers_clearimmediate_immediateobject
[`clearInterval`]: timers.html#timers_clearinterval_intervalobject [`clearInterval`]: timers.html#timers_clearinterval_immediateobject
[`clearTimeout`]: timers.html#timers_cleartimeout_timeoutobject [`clearTimeout`]: timers.html#timers_cleartimeout_timeoutobject
[`setImmediate`]: timers.html#timers_setimmediate_callback_arg [`setImmediate`]: timers.html#timers_setimmediate_callback_arg
[`setInterval`]: timers.html#timers_setinterval_callback_delay_arg [`setInterval`]: timers.html#timers_setinterval_callback_delay_arg

168
doc/api/timers.md

@ -2,90 +2,148 @@
Stability: 3 - Locked Stability: 3 - Locked
All of the timer functions are globals. You do not need to `require()` The `timer` module exposes a global API for scheduling functions to
this module in order to use them. be called at some future period of time. Because the timer functions are
globals, there is no need to call `require('timers')` to use the API.
## clearImmediate(immediateObject) The timer functions within Node.js implement a similar API as the timers API
provided by Web Browsers but use a different internal implementation that is
built around [the Node.js Event Loop][].
Stops an `immediateObject`, as created by [`setImmediate`][], from triggering. ## Class: Immediate
## clearInterval(intervalObject) This object is created internally and is returned from [`setImmediate()`][]. It
can be passed to [`clearImmediate()`][] in order to cancel the scheduled
actions.
Stops an `intervalObject`, as created by [`setInterval`][], from triggering. ## Class: Timeout
## clearTimeout(timeoutObject) This object is created internally and is returned from [`setTimeout()`][] and
[`setInterval()`][]. It can be passed to [`clearTimeout`][] or
[`clearInterval()`][] (respectively) in order to cancel the scheduled actions.
Prevents a `timeoutObject`, as created by [`setTimeout`][], from triggering. By default, when a timer is scheduled using either [`setTimeout`] or
[`setInterval()`][], the Node.js event loop will continue running as long as the
timer is active. Each of the `Timeout` objects returned by these functions
export both `timeout.ref()` and `timeout.unref()` functions that can be used to
control this default behavior.
## ref() ### timeout.ref()
If a timer was previously `unref()`d, then `ref()` can be called to explicitly When called, requests that the Node.js event loop *not* exit so long as the
request the timer hold the program open. If the timer is already `ref`d calling `Timeout` is active. Calling `timeout.ref()` multiple times will have no effect.
`ref` again will have no effect.
Returns the timer. *Note*: By default, all `Timeout` objects are "ref'd", making it normally
unnecessary to call `timeout.ref()` unless `timeout.unref()` had been called
previously.
## setImmediate(callback[, arg][, ...]) Returns a reference to the `Timeout`.
Schedules "immediate" execution of `callback` after I/O events' ### timeout.unref()
callbacks and before timers set by [`setTimeout`][] and [`setInterval`][] are
triggered. Returns an `immediateObject` for possible use with
[`clearImmediate`][]. Additional optional arguments may be passed to the
callback.
Callbacks for immediates are queued in the order in which they were created. When called, the active `Timeout` object will not require the Node.js event loop
The entire callback queue is processed every event loop iteration. If an to remain active. If there is no other activity keeping the event loop running,
immediate is queued from inside an executing callback, that immediate won't fire the process may exit before the `Timeout` object's callback is invoked. Calling
until the next event loop iteration. `timout.unref()` multiple times will have no effect.
If `callback` is not a function `setImmediate()` will throw immediately. *Note*: Calling `timout.unref()` creates an internal timer that will wake the
Node.js event loop. Creating too many of these can adversely impact performance
of the Node.js application.
## setInterval(callback, delay[, arg][, ...]) Returns a reference to the `Timeout`.
## Scheduling Timers
A timer in Node.js is an internal construct that calls a given function after
a certain period of time. When a timer's function is called varies depending on
which method was used to create the timer and what other work the Node.js
event loop is doing.
### setImmediate(callback[, ...arg])
* `callback` {Function} The function to call at the end of this turn of
[the Node.js Event Loop]
* `[, ...arg]` Optional arguments to pass when the `callback` is called.
Schedules the "immediate" execution of the `callback` after I/O events'
callbacks and before timers created using [`setTimeout()`][] and
[`setInterval()`][] are triggered. Returns an `Immediate` for use with
[`clearImmediate()`][].
When multiple calls to `setImmediate()` are made, the `callback` functions are
queued for execution in the order in which they are created. The entire callback
queue is processed every event loop iteration. If an immediate timer is queued
from inside an executing callback, that timer will not be triggered until the
next event loop iteration.
If `callback` is not a function, a [`TypeError`][] will be thrown.
### setInterval(callback, delay[, ...arg])
* `callback` {Function} The function to call when the timer elapses.
* `delay` {number} The number of milliseconds to wait before calling the
`callback`.
* `[, ...arg]` Optional arguments to pass when the `callback` is called.
Schedules repeated execution of `callback` every `delay` milliseconds. Schedules repeated execution of `callback` every `delay` milliseconds.
Returns a `intervalObject` for possible use with [`clearInterval`][]. Additional Returns a `Timeout` for use with [`clearInterval()`][].
optional arguments may be passed to the callback.
To follow browser behavior, when using delays larger than 2147483647 When `delay` is larger than `2147483647` or less than `1`, the `delay` will be
milliseconds (approximately 25 days) or less than 1, Node.js will use 1 as the set to `1`.
`delay`.
If `callback` is not a function `setInterval()` will throw immediately. If `callback` is not a function, a [`TypeError`][] will be thrown.
## setTimeout(callback, delay[, arg][, ...]) ### setTimeout(callback, delay[, ...arg])
* `callback` {Function} The function to call when the timer elapses.
* `delay` {number} The number of milliseconds to wait before calling the
`callback`.
* `[, ...arg]` Optional arguments to pass when the `callback` is called.
Schedules execution of a one-time `callback` after `delay` milliseconds. Schedules execution of a one-time `callback` after `delay` milliseconds.
Returns a `timeoutObject` for possible use with [`clearTimeout`][]. Additional Returns a `Timeout` for use with [`clearTimeout()`][].
optional arguments may be passed to the callback.
The callback will likely not be invoked in precisely `delay` milliseconds. The `callback` will likely not be invoked in precisely `delay` milliseconds.
Node.js makes no guarantees about the exact timing of when callbacks will fire, Node.js makes no guarantees about the exact timing of when callbacks will fire,
nor of their ordering. The callback will be called as close as possible to the nor of their ordering. The callback will be called as close as possible to the
time specified. time specified.
To follow browser behavior, when using delays larger than 2147483647 *Note*: When `delay` is larger than `2147483647` or less than `1`, the `delay`
milliseconds (approximately 25 days) or less than 1, the timeout is executed will be set to `1`.
immediately, as if the `delay` was set to 1.
If `callback` is not a function, a [`TypeError`][] will be thrown.
## Cancelling Timers
The [`setImmediate()`][], [`setInterval()`][], and [`setTimeout()`][] methods
each return objects that represent the scheduled timers. These can be used to
cancel the timer and prevent it from triggering.
### clearImmediate(immediate)
* `immediate` {Immediate} An `Immediate` object as returned by
[`setImmediate()`][].
Cancels an `Immediate` object created by [`setImmediate()`][].
### clearInterval(timeout)
* `timeout` {Timeout} A `Timeout` object as returned by [`setInterval()`][].
If `callback` is not a function `setTimeout()` will throw immediately. Cancels a `Timeout` object created by [`setInterval()`][].
## unref() ### clearTimeout(timeout)
The opaque value returned by [`setTimeout`][] and [`setInterval`][] also has the * `timeout` {Timeout} A `Timeout` object as returned by [`setTimeout()`][].
method `timer.unref()` which allows the creation of a timer that is active but
if it is the only item left in the event loop, it won't keep the program
running. If the timer is already `unref`d calling `unref` again will have no
effect.
In the case of [`setTimeout`][], `unref` creates a separate timer that will Cancels a `Timeout` object created by [`setTimeout()`][].
wakeup the event loop, creating too many of these may adversely effect event
loop performance -- use wisely.
Returns the timer.
[`clearImmediate`]: timers.html#timers_clearimmediate_immediateobject [the Node.js Event Loop]: https://github.com/nodejs/node/blob/master/doc/topics/the-event-loop-timers-and-nexttick.md
[`clearInterval`]: timers.html#timers_clearinterval_intervalobject [`TypeError`]: errors.html#errors_class_typerror
[`clearTimeout`]: timers.html#timers_cleartimeout_timeoutobject [`clearImmediate()`]: timers.html#timers_clearimmediate_immediate
[`setImmediate`]: timers.html#timers_setimmediate_callback_arg [`clearInterval()`]: timers.html#timers_clearinterval_timeout
[`setInterval`]: timers.html#timers_setinterval_callback_delay_arg [`clearTimeout()`]: timers.html#timers_cleartimeout_timeout
[`setTimeout`]: timers.html#timers_settimeout_callback_delay_arg [`setImmediate()`]: timers.html#timers_setimmediate_callback_arg
[`setInterval()`]: timers.html#timers_setinterval_callback_delay_arg
[`setTimeout()`]: timers.html#timers_settimeout_callback_delay_arg

Loading…
Cancel
Save