Craig Condon
538 lines
21 KiB
HTML
538 lines
21 KiB
HTML
<!doctype html>
|
|
<html lang="en">
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<title>process Node.js v0.8.14 Manual & Documentation</title>
|
|
<link rel="stylesheet" href="assets/style.css">
|
|
<link rel="stylesheet" href="assets/sh.css">
|
|
<link rel="canonical" href="http://nodejs.org/api/process.html">
|
|
</head>
|
|
<body class="alt apidoc" id="api-section-process">
|
|
<div id="intro" class="interior">
|
|
<a href="/" title="Go back to the home page">
|
|
<img id="logo" src="http://nodejs.org/images/logo-light.png" alt="node.js">
|
|
</a>
|
|
</div>
|
|
<div id="content" class="clearfix">
|
|
<div id="column2" class="interior">
|
|
<ul>
|
|
<li><a href="/" class="home">Home</a></li>
|
|
<li><a href="/download/" class="download">Download</a></li>
|
|
<li><a href="/about/" class="about">About</a></li>
|
|
<li><a href="http://search.npmjs.org/" class="npm">npm Registry</a></li>
|
|
<li><a href="http://nodejs.org/api/" class="docs current">Docs</a></li>
|
|
<li><a href="http://blog.nodejs.org" class="blog">Blog</a></li>
|
|
<li><a href="/community/" class="community">Community</a></li>
|
|
<li><a href="/logos/" class="logos">Logos</a></li>
|
|
<li><a href="http://jobs.nodejs.org/" class="jobs">Jobs</a></li>
|
|
</ul>
|
|
<p class="twitter"><a href="http://twitter.com/nodejs">@nodejs</a></p>
|
|
</div>
|
|
|
|
<div id="column1" class="interior">
|
|
<header>
|
|
<h1>Node.js v0.8.14 Manual & Documentation</h1>
|
|
<div id="gtoc">
|
|
<p>
|
|
<a href="index.html" name="toc">Index</a> |
|
|
<a href="all.html">View on single page</a> |
|
|
<a href="process.json">View as JSON</a>
|
|
</p>
|
|
</div>
|
|
<hr>
|
|
</header>
|
|
|
|
<div id="toc">
|
|
<h2>Table of Contents</h2>
|
|
<ul>
|
|
<li><a href="#process_process">process</a><ul>
|
|
<li><a href="#process_event_exit">Event: 'exit'</a></li>
|
|
<li><a href="#process_event_uncaughtexception">Event: 'uncaughtException'</a></li>
|
|
<li><a href="#process_signal_events">Signal Events</a></li>
|
|
<li><a href="#process_process_stdout">process.stdout</a></li>
|
|
<li><a href="#process_process_stderr">process.stderr</a></li>
|
|
<li><a href="#process_process_stdin">process.stdin</a></li>
|
|
<li><a href="#process_process_argv">process.argv</a></li>
|
|
<li><a href="#process_process_execpath">process.execPath</a></li>
|
|
<li><a href="#process_process_abort">process.abort()</a></li>
|
|
<li><a href="#process_process_chdir_directory">process.chdir(directory)</a></li>
|
|
<li><a href="#process_process_cwd">process.cwd()</a></li>
|
|
<li><a href="#process_process_env">process.env</a></li>
|
|
<li><a href="#process_process_exit_code">process.exit([code])</a></li>
|
|
<li><a href="#process_process_getgid">process.getgid()</a></li>
|
|
<li><a href="#process_process_setgid_id">process.setgid(id)</a></li>
|
|
<li><a href="#process_process_getuid">process.getuid()</a></li>
|
|
<li><a href="#process_process_setuid_id">process.setuid(id)</a></li>
|
|
<li><a href="#process_process_version">process.version</a></li>
|
|
<li><a href="#process_process_versions">process.versions</a></li>
|
|
<li><a href="#process_process_config">process.config</a></li>
|
|
<li><a href="#process_process_kill_pid_signal">process.kill(pid, [signal])</a></li>
|
|
<li><a href="#process_process_pid">process.pid</a></li>
|
|
<li><a href="#process_process_title">process.title</a></li>
|
|
<li><a href="#process_process_arch">process.arch</a></li>
|
|
<li><a href="#process_process_platform">process.platform</a></li>
|
|
<li><a href="#process_process_memoryusage">process.memoryUsage()</a></li>
|
|
<li><a href="#process_process_nexttick_callback">process.nextTick(callback)</a></li>
|
|
<li><a href="#process_process_umask_mask">process.umask([mask])</a></li>
|
|
<li><a href="#process_process_uptime">process.uptime()</a></li>
|
|
<li><a href="#process_process_hrtime">process.hrtime()</a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
|
|
</div>
|
|
|
|
<div id="apicontent">
|
|
<h1>process<span><a class="mark" href="#process_process" id="process_process">#</a></span></h1>
|
|
<!-- type=global -->
|
|
|
|
<p>The <code>process</code> object is a global object and can be accessed from anywhere.
|
|
It is an instance of <a href="events.html#events_class_events_eventemitter">EventEmitter</a>.
|
|
|
|
|
|
</p>
|
|
<h2>Event: 'exit'<span><a class="mark" href="#process_event_exit" id="process_event_exit">#</a></span></h2>
|
|
<p>Emitted when the process is about to exit. This is a good hook to perform
|
|
constant time checks of the module's state (like for unit tests). The main
|
|
event loop will no longer be run after the 'exit' callback finishes, so
|
|
timers may not be scheduled.
|
|
|
|
</p>
|
|
<p>Example of listening for <code>exit</code>:
|
|
|
|
</p>
|
|
<pre><code>process.on('exit', function () {
|
|
process.nextTick(function () {
|
|
console.log('This will not run');
|
|
});
|
|
console.log('About to exit.');
|
|
});</code></pre>
|
|
<h2>Event: 'uncaughtException'<span><a class="mark" href="#process_event_uncaughtexception" id="process_event_uncaughtexception">#</a></span></h2>
|
|
<p>Emitted when an exception bubbles all the way back to the event loop. If a
|
|
listener is added for this exception, the default action (which is to print
|
|
a stack trace and exit) will not occur.
|
|
|
|
</p>
|
|
<p>Example of listening for <code>uncaughtException</code>:
|
|
|
|
</p>
|
|
<pre><code>process.on('uncaughtException', function (err) {
|
|
console.log('Caught exception: ' + err);
|
|
});
|
|
|
|
setTimeout(function () {
|
|
console.log('This will still run.');
|
|
}, 500);
|
|
|
|
// Intentionally cause an exception, but don't catch it.
|
|
nonexistentFunc();
|
|
console.log('This will not run.');</code></pre>
|
|
<p>Note that <code>uncaughtException</code> is a very crude mechanism for exception
|
|
handling and may be removed in the future.
|
|
|
|
</p>
|
|
<p>Don't use it, use <a href="domain.html">domains</a> instead. If you do use it, restart
|
|
your application after every unhandled exception!
|
|
|
|
</p>
|
|
<p>Do <em>not</em> use it as the node.js equivalent of <code>On Error Resume Next</code>. An
|
|
unhandled exception means your application - and by extension node.js itself -
|
|
is in an undefined state. Blindly resuming means <em>anything</em> could happen.
|
|
|
|
</p>
|
|
<p>Think of resuming as pulling the power cord when you are upgrading your system.
|
|
Nine out of ten times nothing happens - but the 10th time, your system is bust.
|
|
|
|
</p>
|
|
<p>You have been warned.
|
|
|
|
</p>
|
|
<h2>Signal Events<span><a class="mark" href="#process_signal_events" id="process_signal_events">#</a></span></h2>
|
|
<!--type=event-->
|
|
<!--name=SIGINT, SIGUSR1, etc.-->
|
|
|
|
<p>Emitted when the processes receives a signal. See sigaction(2) for a list of
|
|
standard POSIX signal names such as SIGINT, SIGUSR1, etc.
|
|
|
|
</p>
|
|
<p>Example of listening for <code>SIGINT</code>:
|
|
|
|
</p>
|
|
<pre><code>// Start reading from stdin so we don't exit.
|
|
process.stdin.resume();
|
|
|
|
process.on('SIGINT', function () {
|
|
console.log('Got SIGINT. Press Control-D to exit.');
|
|
});</code></pre>
|
|
<p>An easy way to send the <code>SIGINT</code> signal is with <code>Control-C</code> in most terminal
|
|
programs.
|
|
|
|
|
|
</p>
|
|
<h2>process.stdout<span><a class="mark" href="#process_process_stdout" id="process_process_stdout">#</a></span></h2>
|
|
<p>A <code>Writable Stream</code> to <code>stdout</code>.
|
|
|
|
</p>
|
|
<p>Example: the definition of <code>console.log</code>
|
|
|
|
</p>
|
|
<pre><code>console.log = function (d) {
|
|
process.stdout.write(d + '\n');
|
|
};</code></pre>
|
|
<p><code>process.stderr</code> and <code>process.stdout</code> are unlike other streams in Node in
|
|
that writes to them are usually blocking. They are blocking in the case
|
|
that they refer to regular files or TTY file descriptors. In the case they
|
|
refer to pipes, they are non-blocking like other streams.
|
|
|
|
|
|
</p>
|
|
<h2>process.stderr<span><a class="mark" href="#process_process_stderr" id="process_process_stderr">#</a></span></h2>
|
|
<p>A writable stream to stderr.
|
|
|
|
</p>
|
|
<p><code>process.stderr</code> and <code>process.stdout</code> are unlike other streams in Node in
|
|
that writes to them are usually blocking. They are blocking in the case
|
|
that they refer to regular files or TTY file descriptors. In the case they
|
|
refer to pipes, they are non-blocking like other streams.
|
|
|
|
|
|
</p>
|
|
<h2>process.stdin<span><a class="mark" href="#process_process_stdin" id="process_process_stdin">#</a></span></h2>
|
|
<p>A <code>Readable Stream</code> for stdin. The stdin stream is paused by default, so one
|
|
must call <code>process.stdin.resume()</code> to read from it.
|
|
|
|
</p>
|
|
<p>Example of opening standard input and listening for both events:
|
|
|
|
</p>
|
|
<pre><code>process.stdin.resume();
|
|
process.stdin.setEncoding('utf8');
|
|
|
|
process.stdin.on('data', function (chunk) {
|
|
process.stdout.write('data: ' + chunk);
|
|
});
|
|
|
|
process.stdin.on('end', function () {
|
|
process.stdout.write('end');
|
|
});</code></pre>
|
|
<h2>process.argv<span><a class="mark" href="#process_process_argv" id="process_process_argv">#</a></span></h2>
|
|
<p>An array containing the command line arguments. The first element will be
|
|
'node', the second element will be the name of the JavaScript file. The
|
|
next elements will be any additional command line arguments.
|
|
|
|
</p>
|
|
<pre><code>// print process.argv
|
|
process.argv.forEach(function (val, index, array) {
|
|
console.log(index + ': ' + val);
|
|
});</code></pre>
|
|
<p>This will generate:
|
|
|
|
</p>
|
|
<pre><code>$ node process-2.js one two=three four
|
|
0: node
|
|
1: /Users/mjr/work/node/process-2.js
|
|
2: one
|
|
3: two=three
|
|
4: four</code></pre>
|
|
<h2>process.execPath<span><a class="mark" href="#process_process_execpath" id="process_process_execpath">#</a></span></h2>
|
|
<p>This is the absolute pathname of the executable that started the process.
|
|
|
|
</p>
|
|
<p>Example:
|
|
|
|
</p>
|
|
<pre><code>/usr/local/bin/node</code></pre>
|
|
<h2>process.abort()<span><a class="mark" href="#process_process_abort" id="process_process_abort">#</a></span></h2>
|
|
<p>This causes node to emit an abort. This will cause node to exit and
|
|
generate a core file.
|
|
|
|
</p>
|
|
<h2>process.chdir(directory)<span><a class="mark" href="#process_process_chdir_directory" id="process_process_chdir_directory">#</a></span></h2>
|
|
<p>Changes the current working directory of the process or throws an exception if that fails.
|
|
|
|
</p>
|
|
<pre><code>console.log('Starting directory: ' + process.cwd());
|
|
try {
|
|
process.chdir('/tmp');
|
|
console.log('New directory: ' + process.cwd());
|
|
}
|
|
catch (err) {
|
|
console.log('chdir: ' + err);
|
|
}</code></pre>
|
|
<h2>process.cwd()<span><a class="mark" href="#process_process_cwd" id="process_process_cwd">#</a></span></h2>
|
|
<p>Returns the current working directory of the process.
|
|
|
|
</p>
|
|
<pre><code>console.log('Current directory: ' + process.cwd());</code></pre>
|
|
<h2>process.env<span><a class="mark" href="#process_process_env" id="process_process_env">#</a></span></h2>
|
|
<p>An object containing the user environment. See environ(7).
|
|
|
|
|
|
</p>
|
|
<h2>process.exit([code])<span><a class="mark" href="#process_process_exit_code" id="process_process_exit_code">#</a></span></h2>
|
|
<p>Ends the process with the specified <code>code</code>. If omitted, exit uses the
|
|
'success' code <code>0</code>.
|
|
|
|
</p>
|
|
<p>To exit with a 'failure' code:
|
|
|
|
</p>
|
|
<pre><code>process.exit(1);</code></pre>
|
|
<p>The shell that executed node should see the exit code as 1.
|
|
|
|
|
|
</p>
|
|
<h2>process.getgid()<span><a class="mark" href="#process_process_getgid" id="process_process_getgid">#</a></span></h2>
|
|
<p>Note: this function is only available on POSIX platforms (i.e. not Windows)
|
|
|
|
</p>
|
|
<p>Gets the group identity of the process. (See getgid(2).)
|
|
This is the numerical group id, not the group name.
|
|
|
|
</p>
|
|
<pre><code>if (process.getgid) {
|
|
console.log('Current gid: ' + process.getgid());
|
|
}</code></pre>
|
|
<h2>process.setgid(id)<span><a class="mark" href="#process_process_setgid_id" id="process_process_setgid_id">#</a></span></h2>
|
|
<p>Note: this function is only available on POSIX platforms (i.e. not Windows)
|
|
|
|
</p>
|
|
<p>Sets the group identity of the process. (See setgid(2).) This accepts either
|
|
a numerical ID or a groupname string. If a groupname is specified, this method
|
|
blocks while resolving it to a numerical ID.
|
|
|
|
</p>
|
|
<pre><code>if (process.getgid && process.setgid) {
|
|
console.log('Current gid: ' + process.getgid());
|
|
try {
|
|
process.setgid(501);
|
|
console.log('New gid: ' + process.getgid());
|
|
}
|
|
catch (err) {
|
|
console.log('Failed to set gid: ' + err);
|
|
}
|
|
}</code></pre>
|
|
<h2>process.getuid()<span><a class="mark" href="#process_process_getuid" id="process_process_getuid">#</a></span></h2>
|
|
<p>Note: this function is only available on POSIX platforms (i.e. not Windows)
|
|
|
|
</p>
|
|
<p>Gets the user identity of the process. (See getuid(2).)
|
|
This is the numerical userid, not the username.
|
|
|
|
</p>
|
|
<pre><code>if (process.getuid) {
|
|
console.log('Current uid: ' + process.getuid());
|
|
}</code></pre>
|
|
<h2>process.setuid(id)<span><a class="mark" href="#process_process_setuid_id" id="process_process_setuid_id">#</a></span></h2>
|
|
<p>Note: this function is only available on POSIX platforms (i.e. not Windows)
|
|
|
|
</p>
|
|
<p>Sets the user identity of the process. (See setuid(2).) This accepts either
|
|
a numerical ID or a username string. If a username is specified, this method
|
|
blocks while resolving it to a numerical ID.
|
|
|
|
</p>
|
|
<pre><code>if (process.getuid && process.setuid) {
|
|
console.log('Current uid: ' + process.getuid());
|
|
try {
|
|
process.setuid(501);
|
|
console.log('New uid: ' + process.getuid());
|
|
}
|
|
catch (err) {
|
|
console.log('Failed to set uid: ' + err);
|
|
}
|
|
}</code></pre>
|
|
<h2>process.version<span><a class="mark" href="#process_process_version" id="process_process_version">#</a></span></h2>
|
|
<p>A compiled-in property that exposes <code>NODE_VERSION</code>.
|
|
|
|
</p>
|
|
<pre><code>console.log('Version: ' + process.version);</code></pre>
|
|
<h2>process.versions<span><a class="mark" href="#process_process_versions" id="process_process_versions">#</a></span></h2>
|
|
<p>A property exposing version strings of node and its dependencies.
|
|
|
|
</p>
|
|
<pre><code>console.log(process.versions);</code></pre>
|
|
<p>Will output:
|
|
|
|
</p>
|
|
<pre><code>{ node: '0.4.12',
|
|
v8: '3.1.8.26',
|
|
ares: '1.7.4',
|
|
ev: '4.4',
|
|
openssl: '1.0.0e-fips' }</code></pre>
|
|
<h2>process.config<span><a class="mark" href="#process_process_config" id="process_process_config">#</a></span></h2>
|
|
<p>An Object containing the JavaScript representation of the configure options
|
|
that were used to compile the current node executable. This is the same as
|
|
the "config.gypi" file that was produced when running the <code>./configure</code> script.
|
|
|
|
</p>
|
|
<p>An example of the possible output looks like:
|
|
|
|
</p>
|
|
<pre><code>{ target_defaults:
|
|
{ cflags: [],
|
|
default_configuration: 'Release',
|
|
defines: [],
|
|
include_dirs: [],
|
|
libraries: [] },
|
|
variables:
|
|
{ host_arch: 'x64',
|
|
node_install_npm: 'true',
|
|
node_install_waf: 'true',
|
|
node_prefix: '',
|
|
node_shared_v8: 'false',
|
|
node_shared_zlib: 'false',
|
|
node_use_dtrace: 'false',
|
|
node_use_openssl: 'true',
|
|
node_shared_openssl: 'false',
|
|
strict_aliasing: 'true',
|
|
target_arch: 'x64',
|
|
v8_use_snapshot: 'true' } }</code></pre>
|
|
<h2>process.kill(pid, [signal])<span><a class="mark" href="#process_process_kill_pid_signal" id="process_process_kill_pid_signal">#</a></span></h2>
|
|
<p>Send a signal to a process. <code>pid</code> is the process id and <code>signal</code> is the
|
|
string describing the signal to send. Signal names are strings like
|
|
'SIGINT' or 'SIGUSR1'. If omitted, the signal will be 'SIGTERM'.
|
|
See kill(2) for more information.
|
|
|
|
</p>
|
|
<p>Note that just because the name of this function is <code>process.kill</code>, it is
|
|
really just a signal sender, like the <code>kill</code> system call. The signal sent
|
|
may do something other than kill the target process.
|
|
|
|
</p>
|
|
<p>Example of sending a signal to yourself:
|
|
|
|
</p>
|
|
<pre><code>process.on('SIGHUP', function () {
|
|
console.log('Got SIGHUP signal.');
|
|
});
|
|
|
|
setTimeout(function () {
|
|
console.log('Exiting.');
|
|
process.exit(0);
|
|
}, 100);
|
|
|
|
process.kill(process.pid, 'SIGHUP');</code></pre>
|
|
<h2>process.pid<span><a class="mark" href="#process_process_pid" id="process_process_pid">#</a></span></h2>
|
|
<p>The PID of the process.
|
|
|
|
</p>
|
|
<pre><code>console.log('This process is pid ' + process.pid);</code></pre>
|
|
<h2>process.title<span><a class="mark" href="#process_process_title" id="process_process_title">#</a></span></h2>
|
|
<p>Getter/setter to set what is displayed in 'ps'.
|
|
|
|
|
|
</p>
|
|
<h2>process.arch<span><a class="mark" href="#process_process_arch" id="process_process_arch">#</a></span></h2>
|
|
<p>What processor architecture you're running on: <code>'arm'</code>, <code>'ia32'</code>, or <code>'x64'</code>.
|
|
|
|
</p>
|
|
<pre><code>console.log('This processor architecture is ' + process.arch);</code></pre>
|
|
<h2>process.platform<span><a class="mark" href="#process_process_platform" id="process_process_platform">#</a></span></h2>
|
|
<p>What platform you're running on:
|
|
<code>'darwin'</code>, <code>'freebsd'</code>, <code>'linux'</code>, <code>'sunos'</code> or <code>'win32'</code>
|
|
|
|
</p>
|
|
<pre><code>console.log('This platform is ' + process.platform);</code></pre>
|
|
<h2>process.memoryUsage()<span><a class="mark" href="#process_process_memoryusage" id="process_process_memoryusage">#</a></span></h2>
|
|
<p>Returns an object describing the memory usage of the Node process
|
|
measured in bytes.
|
|
|
|
</p>
|
|
<pre><code>var util = require('util');
|
|
|
|
console.log(util.inspect(process.memoryUsage()));</code></pre>
|
|
<p>This will generate:
|
|
|
|
</p>
|
|
<pre><code>{ rss: 4935680,
|
|
heapTotal: 1826816,
|
|
heapUsed: 650472 }</code></pre>
|
|
<p><code>heapTotal</code> and <code>heapUsed</code> refer to V8's memory usage.
|
|
|
|
|
|
</p>
|
|
<h2>process.nextTick(callback)<span><a class="mark" href="#process_process_nexttick_callback" id="process_process_nexttick_callback">#</a></span></h2>
|
|
<p>On the next loop around the event loop call this callback.
|
|
This is <em>not</em> a simple alias to <code>setTimeout(fn, 0)</code>, it's much more
|
|
efficient.
|
|
|
|
</p>
|
|
<pre><code>process.nextTick(function () {
|
|
console.log('nextTick callback');
|
|
});</code></pre>
|
|
<h2>process.umask([mask])<span><a class="mark" href="#process_process_umask_mask" id="process_process_umask_mask">#</a></span></h2>
|
|
<p>Sets or reads the process's file mode creation mask. Child processes inherit
|
|
the mask from the parent process. Returns the old mask if <code>mask</code> argument is
|
|
given, otherwise returns the current mask.
|
|
|
|
</p>
|
|
<pre><code>var oldmask, newmask = 0644;
|
|
|
|
oldmask = process.umask(newmask);
|
|
console.log('Changed umask from: ' + oldmask.toString(8) +
|
|
' to ' + newmask.toString(8));</code></pre>
|
|
<h2>process.uptime()<span><a class="mark" href="#process_process_uptime" id="process_process_uptime">#</a></span></h2>
|
|
<p>Number of seconds Node has been running.
|
|
|
|
|
|
</p>
|
|
<h2>process.hrtime()<span><a class="mark" href="#process_process_hrtime" id="process_process_hrtime">#</a></span></h2>
|
|
<p>Returns the current high-resolution real time in a <code>[seconds, nanoseconds]</code>
|
|
tuple Array. It is relative to an arbitrary time in the past. It is not
|
|
related to the time of day and therefore not subject to clock drift. The
|
|
primary use is for measuring performance between intervals.
|
|
|
|
</p>
|
|
<p>You may pass in the result of a previous call to <code>process.hrtime()</code> to get
|
|
a diff reading, useful for benchmarks and measuring intervals:
|
|
|
|
</p>
|
|
<pre><code>var time = process.hrtime();
|
|
// [ 1800216, 927643717 ]
|
|
|
|
setTimeout(function () {
|
|
var diff = process.hrtime(time);
|
|
// [ 1, 6962306 ]
|
|
|
|
console.log('benchmark took %d seconds and %d nanoseconds',
|
|
diff[0], diff[1]);
|
|
// benchmark took 1 seconds and 6962306 nanoseconds
|
|
}, 1000);</code></pre>
|
|
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div id="footer">
|
|
<ul class="clearfix">
|
|
<li><a href="/">Node.js</a></li>
|
|
<li><a href="/download/">Download</a></li>
|
|
<li><a href="/about/">About</a></li>
|
|
<li><a href="http://search.npmjs.org/">npm Registry</a></li>
|
|
<li><a href="http://nodejs.org/api/">Docs</a></li>
|
|
<li><a href="http://blog.nodejs.org">Blog</a></li>
|
|
<li><a href="/community/">Community</a></li>
|
|
<li><a href="/logos/">Logos</a></li>
|
|
<li><a href="http://jobs.nodejs.org/">Jobs</a></li>
|
|
<li><a href="http://twitter.com/nodejs" class="twitter">@nodejs</a></li>
|
|
</ul>
|
|
|
|
<p>Copyright <a href="http://joyent.com/">Joyent, Inc</a>, Node.js is a <a href="/trademark-policy.pdf">trademark</a> of Joyent, Inc. View <a href="https://raw.github.com/joyent/node/v0.8.14/LICENSE">license</a>.</p>
|
|
</div>
|
|
|
|
<script src="../sh_main.js"></script>
|
|
<script src="../sh_javascript.min.js"></script>
|
|
<script>highlight(undefined, undefined, 'pre');</script>
|
|
<script>
|
|
window._gaq = [['_setAccount', 'UA-10874194-2'], ['_trackPageview']];
|
|
(function(d, t) {
|
|
var g = d.createElement(t),
|
|
s = d.getElementsByTagName(t)[0];
|
|
g.src = '//www.google-analytics.com/ga.js';
|
|
s.parentNode.insertBefore(g, s);
|
|
}(document, 'script'));
|
|
</script>
|
|
</body>
|
|
</html>
|
|
|