FM / api

/usr/share/doc/nodejs/api

Name	Size	Mode	Actions
assets/	-	0755	rm
addons.html	85172	0644	edit dl rm
addons.json.gz	11188	0644	edit dl rm
addons.md	41013	0644	edit dl rm
all.html	4598048	0644	edit dl rm
all.json.gz	681643	0644	edit dl rm
assert.html	110665	0644	edit dl rm
assert.json.gz	12007	0644	edit dl rm
assert.md	47147	0644	edit dl rm
async_hooks.html	83599	0644	edit dl rm
async_hooks.json.gz	14085	0644	edit dl rm
async_hooks.md	38888	0644	edit dl rm
buffer.html	245762	0644	edit dl rm
buffer.json.gz	24105	0644	edit dl rm
buffer.md	105044	0644	edit dl rm
child_process.html	136767	0644	edit dl rm
child_process.json.gz	19399	0644	edit dl rm
child_process.md	62919	0644	edit dl rm
cli.html	87936	0644	edit dl rm
cli.json.gz	16615	0644	edit dl rm
cli.md	42263	0644	edit dl rm
cluster.html	60116	0644	edit dl rm
cluster.json.gz	9557	0644	edit dl rm
cluster.md	25426	0644	edit dl rm
console.html	46093	0644	edit dl rm
console.json.gz	6056	0644	edit dl rm
console.md	16431	0644	edit dl rm
crypto.html	283043	0644	edit dl rm
crypto.json.gz	32118	0644	edit dl rm
crypto.md	125198	0644	edit dl rm
debugger.html	18089	0644	edit dl rm
debugger.json.gz	2820	0644	edit dl rm
debugger.md	6133	0644	edit dl rm
deprecations.html	138537	0644	edit dl rm
deprecations.json.gz	18470	0644	edit dl rm
deprecations.md	79120	0644	edit dl rm
dgram.html	62425	0644	edit dl rm
dgram.json.gz	9630	0644	edit dl rm
dgram.md	27746	0644	edit dl rm
dns.html	98289	0644	edit dl rm
dns.json.gz	13838	0644	edit dl rm
dns.md	40799	0644	edit dl rm
documentation.html	10978	0644	edit dl rm
documentation.json	3328	0644	edit dl rm
documentation.md	2247	0644	edit dl rm
domain.html	36301	0644	edit dl rm
domain.json.gz	6355	0644	edit dl rm
domain.md	15521	0644	edit dl rm
embedding.html	18165	0644	edit dl rm
embedding.json.gz	3625	0644	edit dl rm
embedding.md	8811	0644	edit dl rm
errors.html	182982	0644	edit dl rm
errors.json.gz	36479	0644	edit dl rm
errors.md	81734	0644	edit dl rm
esm.html	92490	0644	edit dl rm
esm.json.gz	15054	0644	edit dl rm
esm.md	48466	0644	edit dl rm
events.html	75986	0644	edit dl rm
events.json.gz	9561	0644	edit dl rm
events.md	28823	0644	edit dl rm
fs.html	437179	0644	edit dl rm
fs.json.gz	47095	0644	edit dl rm
fs.md	187735	0644	edit dl rm
globals.html	19795	0644	edit dl rm
globals.json.gz	2525	0644	edit dl rm
globals.md	5838	0644	edit dl rm
http.html	164378	0644	edit dl rm
http.json.gz	25888	0644	edit dl rm
http.md	74465	0644	edit dl rm
http2.html	256451	0644	edit dl rm
http2.json.gz	37157	0644	edit dl rm
http2.md	121722	0644	edit dl rm
https.html	38345	0644	edit dl rm
https.json.gz	4847	0644	edit dl rm
https.md	13942	0644	edit dl rm
index.html	10087	0644	edit dl rm
index.json	54	0644	edit dl rm
index.md	1825	0644	edit dl rm
inspector.html	22433	0644	edit dl rm
inspector.json.gz	3338	0644	edit dl rm
inspector.md	6825	0644	edit dl rm
intl.html	23154	0644	edit dl rm
intl.json.gz	4038	0644	edit dl rm
intl.md	11092	0644	edit dl rm
module.html	21739	0644	edit dl rm
module.json.gz	2821	0644	edit dl rm
module.md	5341	0644	edit dl rm
modules.html	61333	0644	edit dl rm
modules.json.gz	11897	0644	edit dl rm
modules.md	30610	0644	edit dl rm
n-api.html	340382	0644	edit dl rm
n-api.json.gz	48682	0644	edit dl rm
n-api.md	206268	0644	edit dl rm
net.html	95113	0644	edit dl rm
net.json.gz	14265	0644	edit dl rm
net.md	40473	0644	edit dl rm
os.html	58658	0644	edit dl rm
os.json.gz	8576	0644	edit dl rm
os.md	34632	0644	edit dl rm
packages.html	65483	0644	edit dl rm
packages.json.gz	12401	0644	edit dl rm
packages.md	36538	0644	edit dl rm
path.html	39321	0644	edit dl rm
path.json.gz	4873	0644	edit dl rm
path.md	14750	0644	edit dl rm
perf_hooks.html	56215	0644	edit dl rm
perf_hooks.json.gz	6973	0644	edit dl rm
perf_hooks.md	20116	0644	edit dl rm
policy.html	15908	0644	edit dl rm
policy.json.gz	2908	0644	edit dl rm
policy.md	6324	0644	edit dl rm
process.html	169341	0644	edit dl rm
process.json.gz	27734	0644	edit dl rm
process.md	82162	0644	edit dl rm
punycode.html	16904	0644	edit dl rm
punycode.json.gz	1939	0644	edit dl rm
punycode.md	4063	0644	edit dl rm
querystring.html	19334	0644	edit dl rm
querystring.json.gz	2519	0644	edit dl rm
querystring.md	5423	0644	edit dl rm
readline.html	58434	0644	edit dl rm
readline.json.gz	8835	0644	edit dl rm
readline.md	25133	0644	edit dl rm
repl.html	54152	0644	edit dl rm
repl.json.gz	10053	0644	edit dl rm
repl.md	23754	0644	edit dl rm
report.html	44941	0644	edit dl rm
report.json.gz	6227	0644	edit dl rm
report.md	18287	0644	edit dl rm
stream.html	200501	0644	edit dl rm
stream.json.gz	34485	0644	edit dl rm
stream.md	98619	0644	edit dl rm
string_decoder.html	14415	0644	edit dl rm
string_decoder.json.gz	1545	0644	edit dl rm
string_decoder.md	2934	0644	edit dl rm
synopsis.html	11475	0644	edit dl rm
synopsis.json	3013	0644	edit dl rm
synopsis.md	2129	0644	edit dl rm
timers.html	27467	0644	edit dl rm
timers.json.gz	3637	0644	edit dl rm
timers.md	9738	0644	edit dl rm
tls.html	148381	0644	edit dl rm
tls.json.gz	29988	0644	edit dl rm
tls.md	81388	0644	edit dl rm
tracing.html	19586	0644	edit dl rm
tracing.json.gz	2829	0644	edit dl rm
tracing.md	6756	0644	edit dl rm
tty.html	26930	0644	edit dl rm
tty.json.gz	3758	0644	edit dl rm
tty.md	8989	0644	edit dl rm
url.html	97495	0644	edit dl rm
url.json.gz	13611	0644	edit dl rm
url.md	44869	0644	edit dl rm
util.html	178081	0644	edit dl rm
util.json.gz	20542	0644	edit dl rm
util.md	71255	0644	edit dl rm
v8.html	44688	0644	edit dl rm
v8.json.gz	6082	0644	edit dl rm
v8.md	15533	0644	edit dl rm
vm.html	103392	0644	edit dl rm
vm.json.gz	14023	0644	edit dl rm
vm.md	48293	0644	edit dl rm
wasi.html	17088	0644	edit dl rm
wasi.json.gz	2814	0644	edit dl rm
wasi.md	5932	0644	edit dl rm
worker_threads.html	70808	0644	edit dl rm
worker_threads.json.gz	11326	0644	edit dl rm
worker_threads.md	33883	0644	edit dl rm
zlib.html	90124	0644	edit dl rm
zlib.json.gz	10569	0644	edit dl rm
zlib.md	35697	0644	edit dl rm

Edit: /usr/share/doc/nodejs/api/domain.html (36301B)

<!doctype html>
<html lang="en">
<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width">
 <meta name="nodejs.org:node-version" content="v12.20.0">
 <title>Domain | Node.js v12.20.0 Documentation</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic&display=fallback">
 <link rel="stylesheet" href="assets/style.css">
 <link rel="stylesheet" href="assets/hljs.css">
 <link rel="canonical" href="https://nodejs.org/api/domain.html">
</head>
<body class="alt apidoc" id="api-section-domain">
 <div id="content" class="clearfix">
 <div id="column2" class="interior">
 <div id="intro" class="interior">
 <a href="/" title="Go back to the home page">
 Node.js
 </a>
 </div>
 <ul>
<li><a href="documentation.html" class="nav-documentation">About this documentation</a></li>
<li><a href="synopsis.html" class="nav-synopsis">Usage and example</a></li>
</ul>
<hr class="line">
<ul>
<li><a href="assert.html" class="nav-assert">Assertion testing</a></li>
<li><a href="async_hooks.html" class="nav-async_hooks">Async hooks</a></li>
<li><a href="buffer.html" class="nav-buffer">Buffer</a></li>
<li><a href="addons.html" class="nav-addons">C++ Addons</a></li>
<li><a href="n-api.html" class="nav-n-api">C/C++ Addons with N-API</a></li>
<li><a href="embedding.html" class="nav-embedding">C++ Embedder API</a></li>
<li><a href="child_process.html" class="nav-child_process">Child Processes</a></li>
<li><a href="cluster.html" class="nav-cluster">Cluster</a></li>
<li><a href="cli.html" class="nav-cli">Command line options</a></li>
<li><a href="console.html" class="nav-console">Console</a></li>
<li><a href="crypto.html" class="nav-crypto">Crypto</a></li>
<li><a href="debugger.html" class="nav-debugger">Debugger</a></li>
<li><a href="deprecations.html" class="nav-deprecations">Deprecated APIs</a></li>
<li><a href="dns.html" class="nav-dns">DNS</a></li>
<li><a href="domain.html" class="nav-domain active">Domain</a></li>
<li><a href="errors.html" class="nav-errors">Errors</a></li>
<li><a href="events.html" class="nav-events">Events</a></li>
<li><a href="fs.html" class="nav-fs">File system</a></li>
<li><a href="globals.html" class="nav-globals">Globals</a></li>
<li><a href="http.html" class="nav-http">HTTP</a></li>
<li><a href="http2.html" class="nav-http2">HTTP/2</a></li>
<li><a href="https.html" class="nav-https">HTTPS</a></li>
<li><a href="inspector.html" class="nav-inspector">Inspector</a></li>
<li><a href="intl.html" class="nav-intl">Internationalization</a></li>
<li><a href="modules.html" class="nav-modules">Modules: CommonJS modules</a></li>
<li><a href="esm.html" class="nav-esm">Modules: ECMAScript modules</a></li>
<li><a href="module.html" class="nav-module">Modules: <code>module</code> API</a></li>
<li><a href="packages.html" class="nav-packages">Modules: Packages</a></li>
<li><a href="net.html" class="nav-net">Net</a></li>
<li><a href="os.html" class="nav-os">OS</a></li>
<li><a href="path.html" class="nav-path">Path</a></li>
<li><a href="perf_hooks.html" class="nav-perf_hooks">Performance hooks</a></li>
<li><a href="policy.html" class="nav-policy">Policies</a></li>
<li><a href="process.html" class="nav-process">Process</a></li>
<li><a href="punycode.html" class="nav-punycode">Punycode</a></li>
<li><a href="querystring.html" class="nav-querystring">Query strings</a></li>
<li><a href="readline.html" class="nav-readline">Readline</a></li>
<li><a href="repl.html" class="nav-repl">REPL</a></li>
<li><a href="report.html" class="nav-report">Report</a></li>
<li><a href="stream.html" class="nav-stream">Stream</a></li>
<li><a href="string_decoder.html" class="nav-string_decoder">String decoder</a></li>
<li><a href="timers.html" class="nav-timers">Timers</a></li>
<li><a href="tls.html" class="nav-tls">TLS/SSL</a></li>
<li><a href="tracing.html" class="nav-tracing">Trace events</a></li>
<li><a href="tty.html" class="nav-tty">TTY</a></li>
<li><a href="dgram.html" class="nav-dgram">UDP/datagram</a></li>
<li><a href="url.html" class="nav-url">URL</a></li>
<li><a href="util.html" class="nav-util">Utilities</a></li>
<li><a href="v8.html" class="nav-v8">V8</a></li>
<li><a href="vm.html" class="nav-vm">VM</a></li>
<li><a href="wasi.html" class="nav-wasi">WASI</a></li>
<li><a href="worker_threads.html" class="nav-worker_threads">Worker threads</a></li>
<li><a href="zlib.html" class="nav-zlib">Zlib</a></li>
</ul>
<hr class="line">
<ul>
<li><a href="https://github.com/nodejs/node" class="nav-https-github-com-nodejs-node">Code repository and issue tracker</a></li>
</ul>
 </div>

<div id="column1" data-id="domain" class="interior">
 <header>
 <h1>Node.js v12.20.0 Documentation</h1>
 <div id="gtoc">
 <ul>
 <li>
 <a href="index.html">Index</a>
 </li>
 <li>
 <a href="all.html">View on single page</a>
 </li>
 <li>
 <a href="domain.json">View as JSON</a>
 </li>
 
 <li class="version-picker">
 <a href="#">View another version &#x25bc;</a>
 <ol class="version-picker"><li><a href="https://nodejs.org/docs/latest-v15.x/api/domain.html">15.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v14.x/api/domain.html">14.x LTS</a></li>
<li><a href="https://nodejs.org/docs/latest-v13.x/api/domain.html">13.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v12.x/api/domain.html">12.x LTS</a></li>
<li><a href="https://nodejs.org/docs/latest-v11.x/api/domain.html">11.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v10.x/api/domain.html">10.x LTS</a></li>
<li><a href="https://nodejs.org/docs/latest-v9.x/api/domain.html">9.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v8.x/api/domain.html">8.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v7.x/api/domain.html">7.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v6.x/api/domain.html">6.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v5.x/api/domain.html">5.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v4.x/api/domain.html">4.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v0.12.x/api/domain.html">0.12.x</a></li>
<li><a href="https://nodejs.org/docs/latest-v0.10.x/api/domain.html">0.10.x</a></li></ol>
 </li>
 
 <li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/domain.md"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg>Edit on GitHub</a></li>
 </ul>
 </div>
 <hr>
 </header>

<div id="toc">
 <h2>Table of Contents</h2>
 <ul>
<li><a href="#domain_domain">Domain</a>
<ul>
<li><a href="#domain_warning_don_t_ignore_errors">Warning: Don't ignore errors!</a></li>
<li><a href="#domain_additions_to_error_objects">Additions to <code>Error</code> objects</a></li>
<li><a href="#domain_implicit_binding">Implicit binding</a></li>
<li><a href="#domain_explicit_binding">Explicit binding</a></li>
<li><a href="#domain_domain_create"><code>domain.create()</code></a></li>
<li><a href="#domain_class_domain">Class: <code>Domain</code></a>
<ul>
<li><a href="#domain_domain_members"><code>domain.members</code></a></li>
<li><a href="#domain_domain_add_emitter"><code>domain.add(emitter)</code></a></li>
<li><a href="#domain_domain_bind_callback"><code>domain.bind(callback)</code></a></li>
<li><a href="#domain_domain_enter"><code>domain.enter()</code></a></li>
<li><a href="#domain_domain_exit"><code>domain.exit()</code></a></li>
<li><a href="#domain_domain_intercept_callback"><code>domain.intercept(callback)</code></a></li>
<li><a href="#domain_domain_remove_emitter"><code>domain.remove(emitter)</code></a></li>
<li><a href="#domain_domain_run_fn_args"><code>domain.run(fn[, ...args])</code></a></li>
</ul>
</li>
<li><a href="#domain_domains_and_promises">Domains and promises</a></li>
</ul>
</li>
</ul>
 </div>

<div id="apicontent">
 <h1>Domain<a class="mark" href="#domain_domain" id="domain_domain">#</a></h1>
<div class="api_metadata">
<details class="changelog"><summary>History</summary>
<table>
<tbody><tr><th>Version</th><th>Changes</th></tr>
<tr><td>v8.8.0</td>
<td>Any <code>Promise</code>s created in VM contexts no longer have a <code>.domain</code> property. Their handlers are still executed in the proper domain, however, and <code>Promise</code>s created in the main context still possess a <code>.domain</code> property.</td></tr>
<tr><td>v8.0.0</td>
<td>Handlers for <code>Promise</code>s are now invoked in the domain in which the first promise of a chain was created.</td></tr>
<tr><td>v1.4.2</td>
<td>Deprecated since: v1.4.2</td></tr>
</tbody></table>
</details>
</div>

<div class="api_stability api_stability_0"><a href="documentation.html#documentation_stability_index">Stability: 0</a> - Deprecated</div>
Source Code: <a href="https://github.com/nodejs/node/blob/v12.20.0/lib/domain.js">lib/domain.js</a>
This module is pending deprecation. Once a replacement API has been
finalized, this module will be fully deprecated. Most developers should
not have cause to use this module. Users who absolutely must have
the functionality that domains provide may rely on it for the time being
but should expect to have to migrate to a different solution
in the future.
Domains provide a way to handle multiple different IO operations as a
single group. If any of the event emitters or callbacks registered to a
domain emit an <code>'error'</code> event, or throw an error, then the domain object
will be notified, rather than losing the context of the error in the
<code>process.on('uncaughtException')</code> handler, or causing the program to
exit immediately with an error code.
<h2>Warning: Don't ignore errors!<a class="mark" href="#domain_warning_don_t_ignore_errors" id="domain_warning_don_t_ignore_errors">#</a></h2>

Domain error handlers are not a substitute for closing down a
process when an error occurs.
By the very nature of how <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw"><code>throw</code></a> works in JavaScript, there is almost
never any way to safely "pick up where it left off", without leaking
references, or creating some other sort of undefined brittle state.
The safest way to respond to a thrown error is to shut down the
process. Of course, in a normal web server, there may be many
open connections, and it is not reasonable to abruptly shut those down
because an error was triggered by someone else.
The better approach is to send an error response to the request that
triggered the error, while letting the others finish in their normal
time, and stop listening for new requests in that worker.
In this way, <code>domain</code> usage goes hand-in-hand with the cluster module,
since the master process can fork a new worker when a worker
encounters an error. For Node.js programs that scale to multiple
machines, the terminating proxy or service registry can take note of
the failure, and react accordingly.
For example, this is not a good idea:
<pre><code class="language-js">// XXX WARNING! BAD IDEA!

const cluster = require('cluster');
const PORT = +process.env.PORT || 1337;

if (cluster.isMaster) {
 // A more realistic scenario would have more than 2 workers,
 // and perhaps not put the master and worker in the same file.
 //
 // It is also possible to get a bit fancier about logging, and
 // implement whatever custom logic is needed to prevent DoS
 // attacks and other bad behavior.
 //
 // See the options in the cluster documentation.
 //
 // The important thing is that the master does very little,
 // increasing our resilience to unexpected errors.

cluster.fork();
  cluster.fork();

cluster.on('disconnect', (worker) => {
 console.error('disconnect!');
 cluster.fork();
 });

} else {
 // the worker
 //
 // This is where we put our bugs!

const domain = require('domain');

// See the cluster documentation for more details about using
 // worker processes to serve requests. How it works, caveats, etc.

const server = require('http').createServer((req, res) => {
 const d = domain.create();
 d.on('error', (er) => {
 console.error(`error ${er.stack}`);

// We're in dangerous territory!
 // By definition, something unexpected occurred,
 // which we probably didn't want.
 // Anything can happen now! Be very careful!

try {
 // Make sure we close down within 30 seconds
 const killtimer = setTimeout(() => {
 process.exit(1);
 }, 30000);
 // But don't keep the process open just for that!
 killtimer.unref();

// Stop taking new requests.
 server.close();

// Let the master know we're dead. This will trigger a
 // 'disconnect' in the cluster master, and then it will fork
 // a new worker.
 cluster.worker.disconnect();

// Try to send an error to the request that triggered the problem
 res.statusCode = 500;
 res.setHeader('content-type', 'text/plain');
 res.end('Oops, there was a problem!\n');
 } catch (er2) {
 // Oh well, not much we can do at this point.
 console.error(`Error sending 500! ${er2.stack}`);
 }
 });

// Because req and res were created before this domain existed,
 // we need to explicitly add them.
 // See the explanation of implicit vs explicit binding below.
 d.add(req);
 d.add(res);

// Now run the handler function in the domain.
 d.run(() => {
 handleRequest(req, res);
 });
 });
 server.listen(PORT);
}

// This part is not important. Just an example routing thing.
// Put fancy application logic here.
function handleRequest(req, res) {
 switch (req.url) {
 case '/error':
 // We do some async stuff, and then...
 setTimeout(() => {
 // Whoops!
 flerb.bark();
 }, timeout);
 break;
 default:
 res.end('ok');
 }
}</code></pre>
<h2>Additions to <code>Error</code> objects<a class="mark" href="#domain_additions_to_error_objects" id="domain_additions_to_error_objects">#</a></h2>

Any time an <code>Error</code> object is routed through a domain, a few extra fields
are added to it.
<ul>
<li><code>error.domain</code> The domain that first handled the error.</li>
<li><code>error.domainEmitter</code> The event emitter that emitted an <code>'error'</code> event
with the error object.</li>
<li><code>error.domainBound</code> The callback function which was bound to the
domain, and passed an error as its first argument.</li>
<li><code>error.domainThrown</code> A boolean indicating whether the error was
thrown, emitted, or passed to a bound callback function.</li>
</ul>
<h2>Implicit binding<a class="mark" href="#domain_implicit_binding" id="domain_implicit_binding">#</a></h2>

If domains are in use, then all new <code>EventEmitter</code> objects (including
Stream objects, requests, responses, etc.) will be implicitly bound to
the active domain at the time of their creation.
Additionally, callbacks passed to lowlevel event loop requests (such as
to <code>fs.open()</code>, or other callback-taking methods) will automatically be
bound to the active domain. If they throw, then the domain will catch
the error.
In order to prevent excessive memory usage, <code>Domain</code> objects themselves
are not implicitly added as children of the active domain. If they
were, then it would be too easy to prevent request and response objects
from being properly garbage collected.
To nest <code>Domain</code> objects as children of a parent <code>Domain</code> they must be
explicitly added.
Implicit binding routes thrown errors and <code>'error'</code> events to the
<code>Domain</code>'s <code>'error'</code> event, but does not register the <code>EventEmitter</code> on the
<code>Domain</code>.
Implicit binding only takes care of thrown errors and <code>'error'</code> events.
<h2>Explicit binding<a class="mark" href="#domain_explicit_binding" id="domain_explicit_binding">#</a></h2>

Sometimes, the domain in use is not the one that ought to be used for a
specific event emitter. Or, the event emitter could have been created
in the context of one domain, but ought to instead be bound to some
other domain.
For example, there could be one domain in use for an HTTP server, but
perhaps we would like to have a separate domain to use for each request.
That is possible via explicit binding.
<pre><code class="language-js">// Create a top-level domain for the server
const domain = require('domain');
const http = require('http');
const serverDomain = domain.create();

serverDomain.run(() => {
 // Server is created in the scope of serverDomain
 http.createServer((req, res) => {
 // Req and res are also created in the scope of serverDomain
 // however, we'd prefer to have a separate domain for each request.
 // create it first thing, and add req and res to it.
 const reqd = domain.create();
 reqd.add(req);
 reqd.add(res);
 reqd.on('error', (er) => {
 console.error('Error', er, req.url);
 try {
 res.writeHead(500);
 res.end('Error occurred, sorry.');
 } catch (er2) {
 console.error('Error sending 500', er2, req.url);
 }
 });
 }).listen(1337);
});</code></pre>
<h2><code>domain.create()</code><a class="mark" href="#domain_domain_create" id="domain_domain_create">#</a></h2>
<ul>
<li>Returns: <a href="domain.html#domain_class_domain" class="type">&#x3C;Domain></a></li>
</ul>
<h2>Class: <code>Domain</code><a class="mark" href="#domain_class_domain" id="domain_class_domain">#</a></h2>
<ul>
<li>Extends: <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a></li>
</ul>
The <code>Domain</code> class encapsulates the functionality of routing errors and
uncaught exceptions to the active <code>Domain</code> object.
To handle the errors that it catches, listen to its <code>'error'</code> event.
<h3><code>domain.members</code><a class="mark" href="#domain_domain_members" id="domain_domain_members">#</a></h3>
<ul>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&#x3C;Array></a></li>
</ul>
An array of timers and event emitters that have been explicitly added
to the domain.
<h3><code>domain.add(emitter)</code><a class="mark" href="#domain_domain_add_emitter" id="domain_domain_add_emitter">#</a></h3>
<ul>
<li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="timers.html#timers_timers" class="type">&#x3C;Timer></a> emitter or timer to be added to the domain</li>
</ul>
Explicitly adds an emitter to the domain. If any event handlers called by
the emitter throw an error, or if the emitter emits an <code>'error'</code> event, it
will be routed to the domain's <code>'error'</code> event, just like with implicit
binding.
This also works with timers that are returned from <a href="timers.html#timers_setinterval_callback_delay_args"><code>setInterval()</code></a> and
<a href="timers.html#timers_settimeout_callback_delay_args"><code>setTimeout()</code></a>. If their callback function throws, it will be caught by
the domain <code>'error'</code> handler.
If the Timer or <code>EventEmitter</code> was already bound to a domain, it is removed
from that one, and bound to this one instead.
<h3><code>domain.bind(callback)</code><a class="mark" href="#domain_domain_bind_callback" id="domain_domain_bind_callback">#</a></h3>
<ul>
<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The bound function</li>
</ul>
The returned function will be a wrapper around the supplied callback
function. When the returned function is called, any errors that are
thrown will be routed to the domain's <code>'error'</code> event.
<pre><code class="language-js">const d = domain.create();

function readSomeFile(filename, cb) {
 fs.readFile(filename, 'utf8', d.bind((er, data) => {
 // If this throws, it will also be passed to the domain.
 return cb(er, data ? JSON.parse(data) : null);
 }));
}

d.on('error', (er) => {
 // An error occurred somewhere. If we throw it now, it will crash the program
 // with the normal line number and stack message.
});</code></pre>
<h3><code>domain.enter()</code><a class="mark" href="#domain_domain_enter" id="domain_domain_enter">#</a></h3>
The <code>enter()</code> method is plumbing used by the <code>run()</code>, <code>bind()</code>, and
<code>intercept()</code> methods to set the active domain. It sets <code>domain.active</code> and
<code>process.domain</code> to the domain, and implicitly pushes the domain onto the domain
stack managed by the domain module (see <a href="#domain_domain_exit"><code>domain.exit()</code></a> for details on the
domain stack). The call to <code>enter()</code> delimits the beginning of a chain of
asynchronous calls and I/O operations bound to a domain.
Calling <code>enter()</code> changes only the active domain, and does not alter the domain
itself. <code>enter()</code> and <code>exit()</code> can be called an arbitrary number of times on a
single domain.
<h3><code>domain.exit()</code><a class="mark" href="#domain_domain_exit" id="domain_domain_exit">#</a></h3>
The <code>exit()</code> method exits the current domain, popping it off the domain stack.
Any time execution is going to switch to the context of a different chain of
asynchronous calls, it's important to ensure that the current domain is exited.
The call to <code>exit()</code> delimits either the end of or an interruption to the chain
of asynchronous calls and I/O operations bound to a domain.
If there are multiple, nested domains bound to the current execution context,
<code>exit()</code> will exit any domains nested within this domain.
Calling <code>exit()</code> changes only the active domain, and does not alter the domain
itself. <code>enter()</code> and <code>exit()</code> can be called an arbitrary number of times on a
single domain.
<h3><code>domain.intercept(callback)</code><a class="mark" href="#domain_domain_intercept_callback" id="domain_domain_intercept_callback">#</a></h3>
<ul>
<li><code>callback</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The callback function</li>
<li>Returns: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a> The intercepted function</li>
</ul>
This method is almost identical to <a href="#domain_domain_bind_callback"><code>domain.bind(callback)</code></a>. However, in
addition to catching thrown errors, it will also intercept <a href="errors.html#errors_class_error"><code>Error</code></a>
objects sent as the first argument to the function.
In this way, the common <code>if (err) return callback(err);</code> pattern can be replaced
with a single error handler in a single place.
<pre><code class="language-js">const d = domain.create();

function readSomeFile(filename, cb) {
 fs.readFile(filename, 'utf8', d.intercept((data) => {
 // Note, the first argument is never passed to the
 // callback since it is assumed to be the 'Error' argument
 // and thus intercepted by the domain.

// If this throws, it will also be passed to the domain
 // so the error-handling logic can be moved to the 'error'
 // event on the domain instead of being repeated throughout
 // the program.
 return cb(null, JSON.parse(data));
 }));
}

d.on('error', (er) => {
 // An error occurred somewhere. If we throw it now, it will crash the program
 // with the normal line number and stack message.
});</code></pre>
<h3><code>domain.remove(emitter)</code><a class="mark" href="#domain_domain_remove_emitter" id="domain_domain_remove_emitter">#</a></h3>
<ul>
<li><code>emitter</code> <a href="events.html#events_class_eventemitter" class="type">&#x3C;EventEmitter></a> | <a href="timers.html#timers_timers" class="type">&#x3C;Timer></a> emitter or timer to be removed from the domain</li>
</ul>
The opposite of <a href="#domain_domain_add_emitter"><code>domain.add(emitter)</code></a>. Removes domain handling from the
specified emitter.
<h3><code>domain.run(fn[, ...args])</code><a class="mark" href="#domain_domain_run_fn_args" id="domain_domain_run_fn_args">#</a></h3>
<ul>
<li><code>fn</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&#x3C;Function></a></li>
<li><code>...args</code> <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Data_types" class="type">&#x3C;any></a></li>
</ul>
Run the supplied function in the context of the domain, implicitly
binding all event emitters, timers, and lowlevel requests that are
created in that context. Optionally, arguments can be passed to
the function.
This is the most basic way to use a domain.
<pre><code class="language-js">const domain = require('domain');
const fs = require('fs');
const d = domain.create();
d.on('error', (er) => {
 console.error('Caught error!', er);
});
d.run(() => {
 process.nextTick(() => {
 setTimeout(() => { // Simulating some various async stuff
 fs.open('non-existent file', 'r', (er, fd) => {
 if (er) throw er;
 // proceed...
 });
 }, 100);
 });
});</code></pre>
In this example, the <code>d.on('error')</code> handler will be triggered, rather
than crashing the program.
<h2>Domains and promises<a class="mark" href="#domain_domains_and_promises" id="domain_domains_and_promises">#</a></h2>
As of Node.js 8.0.0, the handlers of promises are run inside the domain in
which the call to <code>.then()</code> or <code>.catch()</code> itself was made:
<pre><code class="language-js">const d1 = domain.create();
const d2 = domain.create();

let p;
d1.run(() => {
 p = Promise.resolve(42);
});

d2.run(() => {
 p.then((v) => {
 // running in d2
 });
});</code></pre>
A callback may be bound to a specific domain using <a href="#domain_domain_bind_callback"><code>domain.bind(callback)</code></a>:
<pre><code class="language-js">const d1 = domain.create();
const d2 = domain.create();

let p;
d1.run(() => {
 p = Promise.resolve(42);
});

d2.run(() => {
 p.then(p.domain.bind((v) => {
 // running in d1
 }));
});</code></pre>
Domains will not interfere with the error handling mechanisms for
promises. In other words, no <code>'error'</code> event will be emitted for unhandled
<code>Promise</code> rejections.
 
 </div>
 </div>
 </div>
</body>
</html>

cmd: