Jsndm.CommonJS (Jsndmc)
Jsndmc'overview
description::
Module is a-semantic-unit which
- can-be PART OF other modules and
- can-has AS PART other modules
with the-require()-function.
Like 'the-prototype-inheritance' mechanism which manages the GENERIC-SPECIFIC relations of the-semantic-units of an-API, modules is the-mechanism needed to manage the WHOLE-PART relations of the-semantic-units.
In contrast to objects, modules HAVE scope, ie its members see each other.
===
Modules actually are (implemented as) self-executing-functions that RETURN the-semantic-unit which contains the-public-members of the-module.
[HmnSgm.2016-07-25]
===
Do-NOT-confuse the-module-semantic-unit (this-concept), with the-module-object, which is a-member of any module-semantic-unit.
[HmnSgm.2016-07-23]
name::
* McsEngl.CJS-module!⇒Jsndmc,
* McsEngl.CommonJS-module!⇒Jsndmc,
* McsEngl.Jsndm.CommonJS!⇒Jsndmc,
* McsEngl.Jsndmc, {2021-05-02},
* McsEngl.Jsndmc!=Node.js-CommonJS-module,
* McsEngl.lagJsnd'CommonJS-module--semantic-unit!⇒Jsndmc,
* McsEngl.Node.js-CommonJS-module!⇒Jsndmc,
* McsEngl.Node.js-module!⇒Jsndmc,
===
NOTATION:
I name the-modules as 'm?Name' where ? = a,b,f,n,o,r,s denotes the-type of the-semantic-unit-they-export (public-member).
[HmnSgm.2016-12-01]
I name the-modules as 'mName' if they export objects and 'm?Name' where ? = a,b,f,n,r,s if they export other semantic-units.
[HmnSgm.2016-07-25]
generic::
* CommonJS-module,
description::
Module is an OBJECT importing/exporting from a file or directory code-structure.
It can have explicitly defined properties with 'exports.property' code
or it can be a single exported function/object with the 'module.exports' code.
[HmnSgm.2014-04-22]
===
Modules make it possible to include other Javascript files into your applications.
... Modules are crucial to building applications in Node, as they allow you to include external libraries, such as database access libraries - and they help in organizing your code into separate parts with limited responsibilities.
You should try to identify reusable parts in your own code and turn them into separate modules to reduce the amount of code per file and to make it easier to read and maintain your code.
[http://book.mixu.net/node/single.html]
===
Node has a simple module loading system.
In Node, files and modules are in one-to-one correspondence.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_modules]
===
Node.js uses a module architecture to simplify the creation of complex applications.
Modules are akin to libraries in C, or units in Pascal.
Each module contains a set of functions related to the “subject” of the module.
For example, the http module contains functions specific to HTTP.
Node.js provides a few core modules out of the box to help you access files on the file system, create HTTP and TCP/UDP servers, and perform other useful functions.
Including a module is easy; simply call the require() function, like this:
> var http = require('http');
The require() function returns the reference to the specified module.
In the case of this code, a reference to the http module is stored in the http variable.
[http://net.tutsplus.com/tutorials/Javascript-ajax/node-js-for-beginners/]
Jsndmc'caching
description::
Caching
Modules are cached after the first time they are loaded.
This means (among other things) that every call to require('foo') will get exactly the same object returned, if it would resolve to the same file.
Multiple calls to require('foo') may not cause the module code to be executed multiple times.
This is an important feature.
With it, "partially done" objects can be returned, thus allowing transitive dependencies to be loaded even when they would cause cycles.
If you want to have a module execute code multiple times, then export a function, and call that function.
Module Caching Caveats
Modules are cached based on their resolved filename.
Since modules may resolve to a different filename based on the location of the calling module (loading from node_modules folders), it is not a guarantee that require('foo') will always return the exact same object, if it would resolve to different files.
[http://nodejs.org/api/modules.html#modules_caching]
name::
* McsEngl.Jsndmc'caching,
Jsndmc'member
description::
Member-of-module is a-semantic-unit CONTAINED by the-module.
name::
* McsEngl.Jsndmc'member!⇒Jsndmmbr,
* McsEngl.Jsndmmbr,
Jsndmmbr'importing
description::
We can-import the-public-semantic-unit of a-module, in any other module.
To do it, we use the-function require().
name::
* McsEngl.Jsndmc'importing,
* McsEngl.Jsndmc'loading,
* McsEngl.Jsndmc'requiring,
* McsEngl.Jsndmc'using,
Jsndmmbr.PUBLIC
description::
Public-member-of-module is an-exported member, that we have access outside of the-module.
A-module, as a-self-executing-function, returns|exports ONLY ONE semantic-unit.
When we export many members like exports.member = value, we export one object with members the-ones we denote in exports.
name::
* McsEngl.Jsndmc'exported-member,
* McsEngl.Jsndmc'public-member,
* McsEngl.Jsndmc'member.public,
* McsEngl.Jsndmc'member.localNo,
* McsEngl.Jsndmc'member.privateNo,
* McsEngl.lagJsnd'mmbr.public,
Jsndmmbr.PUBLIC.NO
description::
If module-a is importing in module-b, the-public-member of module-a is publicNo-member in module-b.
===
Defining var something in a-module, is publicNo-member of it.
In browsers, the top-level scope is the global scope.
That means that in browsers if you're in the global scope var something will define a global variable.
In Node.js this is different.
The top-level scope is not the global scope; var something inside an Node.js module will be local to that module.
[https://nodejs.org/api/globals.html#globals_global]
name::
* McsEngl.Jsndmc'private-member,
* McsEngl.Jsndmc'member.private,
* McsEngl.Jsndmc'member.publicNo,
* McsEngl.Jsndmc'member.local,
specific::
* any defined non-exporting member,
* __dirname-string-member,
* __filename-string-member,
* module-object-member,
* require-function-member,
Jsndmmbr.__dirname-string
description::
__dirname
String
The name of the directory that the currently executing script resides in.
Example: running node example.js from /Users/mjr
console.log(__dirname);
// /Users/mjr
__dirname isn't actually a global but rather local to each module.
[https://nodejs.org/api/globals.html#globals_dirname]
name::
* McsEngl.__dirname-string-of-Node.js,
* McsEngl.Jsnd__dirname-string,
Jsndmmbr.__filename-string
description::
__filename
String
The filename of the code being executed.
This is the resolved absolute path of this code file.
For a main program this is not necessarily the same filename used in the command line.
The value inside a module is the path to that module file.
Example: running node example.js from /Users/mjr
console.log(__filename);
// /Users/mjr/example.js
__filename isn't actually a global but rather local to each module.
[https://nodejs.org/api/globals.html#globals_filename]
name::
* McsEngl.__filename-of-Node.js,
* McsEngl.Jsnd__filename-string,
Jsndmmbr.module-object (Jsndmobt)
description::
The module Object
Object
In each module, the module free variable is a reference to the object representing the current module.
For convenience, module.exports is also accessible via the exports module-global.
module isn't actually a global but rather local to each module.
[https://nodejs.org/api/modules.html#modules_the_module_object]
name::
* McsEngl.Jsndmc'module-object,
* McsEngl.lagJsnd'mobt-(module-object), {2016.07.26}
* McsEngl.module-object-of-Node.js,
===
The-name 'module' is ambiguous.
a) denotes the-module object, this concept.
b) denotes any module semantic-unit (ljnm).
whole-chain::
* module-sut,
* most-whole-object (global),
generic-chain::
* ?(Module.prototype) (module.__proto__ === Object.prototype //false),
* Object.prototype (module.__proto__.__proto__ === Object.prototype //true),
===
* module-sut-member,
Jsndmobt'member
member::
// Jsnd.6-2-2
> Object.getOwnPropertyNames(module).sort()
[ 'children', 'exports', 'filename', 'id', 'loaded', 'parent', 'paths' ]
> Object.getOwnPropertyNames(module.__proto__).sort()
[ '_compile', 'constructor', 'load', 'require' ]
> Object.getOwnPropertyNames(module.__proto__.__proto__).sort()
[ '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__', 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf' ]
Jsndmobt'member.module.exports-object
description::
module.exports holds the-public-member (exported) of a-module.
===
module.exports
Object
The module.exports object is created by the Module system.
Sometimes this is not acceptable; many want their module to be an instance of some class.
To do this, assign the desired export object to module.exports.
Note that assigning the desired object to exports will simply rebind the local exports variable, which is probably not what you want to do.
...
exports alias
The exports variable that is available within a module starts as a reference to module.exports.
As with any variable, if you assign a new value to it, it is no longer bound to the previous value.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_module_exports]
name::
* McsEngl.Jsndmc'module.exports-object,
Exporting-SINGLE-MEMBER
description::
To export a single semantic-unit we use the-code:
module.exports = value;
===
If you want the root of your module's export to be a function (such as a constructor) or if you want to export a complete object in one assignment instead of building it one property at a time, assign it to module.exports instead of exports.
[https://nodejs.org/api/modules.html#modules_modules]
name::
* McsEngl.Jsndmc'exporting-single-member,
* McsEngl.Jsndmc'exporting-single-semantic-unit,
* McsEngl.Jsndmc'module.exports,
* McsEngl.module.exports-of-Node.js,
Exporting-MANY-MEMBERS
description::
When we export many members, in fact we export ONE OBJECT with members these 'many' members.
To do this we use the-code:
module.exports.member = value;
or its alias
exports.member = value;
===
For convenience, module.exports is also accessible via the exports module-global.
[http://openmymind.net/2012/2/3/Node-Require-and-Exports/]
name::
* McsEngl.exports.member-of-Node.js,
* McsEngl.lagJsnd'exporting-many-members,
* McsEngl.lagJsnd'exports.member,
* McsEngl.Jsndmc'exporting-many-members,
* McsEngl.Jsndmc'module.exports.member,
Jsndmobt'member.paths-object
description::
> D:\Jsnd>node filStart
// module.paths
[ 'D:\\Jsnd\\node_modules' ]
name::
* McsEngl.Jsndmc.paths,
* McsEngl.module.paths-of-Node.js,
Jsndmmbr.require-function
description::
The-require-function IMPORTS modules into other modules.
When we import a-module, we import the-public-member[1] of the-module OR a-member of it[1] AND we execute the-code of the-module which could eg add a-global-member.
name::
* McsEngl.lagJsnd'require-function,
* McsEngl.lagJsnd-f.require,
whole-chain::
* module-semantic-unit,
* lagJsnd-most-whole-object (global),
generic-chain::
* Function.prototype,
* Object.prototype,
lagJsnd-require'Destructuring-assignment
description::
//destructuring-assignment
const {app, BrowserWindow} = require('electron');
//equivalent
const electron = require('electron');
const app = electron.app;
const BrowserWindow = electron.BrowserWindow;
name::
* McsEngl.lagJsnd'require-destructuring-assignment,
lagJsnd-require'Import-core-module
description::
//just write the-module's name
const moFs = require('fs');
const mfEvents = require('events');
===
Without a leading '/' or './' to indicate a file, the module is either a "core module" or is loaded from a node_modules folder.
[http://nodejs.org/api/modules.html#modules_file_modules]
name::
* McsEngl.lagJsnd'import-core-module,
* McsEngl.Jsndmc'import-core-module,
lagJsnd-require'Import-member-of-module
description::
const fDecoderString = require('string_decoder').StringDecoder;
var oDecoderString = new fDecoderString('utf8');
name::
* cpt'Jsnd'import-part-of-module,
* cpt'ljnm'import-part-of-module,
lagJsnd-require'Import-from-relative-path
description::
//from CURRENT directory
const mFoo = require('./filFoo');
//form SUBDIRECTORY
const mC = require ('./dirTest/filC');
//from PARENT directory
const mBar = require('../filBar');
name::
* cpt'Jsnd'import-module-from-relative-path,
* cpt'ljnm'import-module-from-relative-path,
lagJsnd-require'Import-from-absolute-path
description::
A module prefixed with '/' is an absolute path to the file.
For example, require('/home/marco/foo.js') will load the file at /home/marco/foo.js.
[http://nodejs.org/api/modules.html#modules_file_modules]
name::
* McsEngl.lagJsnd'import-module-from-absolute-path,
* McsEngl.Jsndmc'import-module-from-absolute-path,
lagJsnd-require'Import-by-searching
description::
There are three ways in which you can require() files:
- using a relative path: foo = require('./lib/bar.js');
- using an absolute path: foo = require('/home/foo/lib/bar.js')
- using a search: foo = require('bar')
The first two are easy to understand.
In the third case, Node starts at the current directory, and adds ./node_modules/, and attempts to load the module from that location.
If the module is not found, then it moves to the parent directory and performs the same check, until the root of the filesystem is reached.
[http://book.mixu.net/node/single.html]
name::
* McsEngl.lagJsnd'import-by-searching,
* McsEngl.lagJsnd'import-from-node-modules,
* McsEngl.Jsndmc'import-by-searching,
* McsEngl.Jsndmc'import-from-node-modules,
lagJsnd-require'Import-JSON-file
description::
Nodejs and browserify support importing JSON files.
> oJson = require('./test.json'),
name::
* McsEngl.lagJsnd'import-JSON-file,
* McsEngl.Jsndmc'import-JSON-file,
lagJsnd-require'Member
description::
> Object.getOwnPropertyNames(require).sort()
[ 'cache', 'extensions', 'length', 'main', 'name', 'prototype', 'resolve' ]
===
> require
{ [Function: require]
resolve: [Function: resolve],
main: undefined,
extensions: { '.js': [Function], '.json': [Function], '.node': [Function] },
cache: {} }
lagJsnd-require.main-object
description::
Accessing the main module
When a file is run directly from Node.js, require.main is set to its module.
That means that you can determine whether a file has been run directly by testing
require.main === module
For a file foo.js, this will be true if run via node foo.js, but false if run by require('./foo').
Because module provides a filename property (normally equivalent to __filename), the entry point of the current application can be obtained by checking require.main.filename [from any module].
[https://nodejs.org/api/modules.html#modules_accessing_the_main_module]
name::
* McsEngl.lagJsnd'require.main,
lagJsnd-require.resolve-function
description::
Use the internal require() machinery to look up the location of a module, but rather than loading the module, just return the resolved filename.
[https://nodejs.org/api/globals.html#globals_require_resolve]
name::
* McsEngl.lagJsnd'global.require.resolve,
* McsEngl.lagJsnd'require.resolve,
Code.Jsnd:
//on a-module with 'filB.js' on the-same directory
console.log(require.resolve('./filB'))
//D:\Jsnd\filB.js
Jsndmc'repository
name::
* McsEngl.Jsndmc'repository,
* McsEngl.Jsndmc'storage,
specific::
* public-repository,
* publicNo-repository,
===
* npmjs.org/
* node-modules.com/
* http://eirikb.github.io/nipster/
Jsndmc'npm-registry (npmjs.org)
description::
Join the modular development revolution
Every month, more than 4 million developers use npm to find, share, and reuse code — and assemble it in powerful new ways.
[https://www.npmjs.com/]
name::
* McsEngl.lagJsnd'npm-registry,
* McsEngl.lagJsnd'npmjs.org,
* McsEngl.lagJsnd'npmjs.org,
npm-tool (link)
addressWpg::
* https://www.npmjs.org/
Node Packaged Modules:
{2016.07}: 250,000 building blocks
{2014.02.16}: Total Packages: 59,377
Jsndmc'node_modules-directory
description::
Without a leading '/' or './' to indicate a file, the module is either a "core module" or is loaded from a node_modules folder.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_file_modules]
===
There are three ways in which you can require() files:
- using a relative path: foo = require('./lib/bar.js');
- using an absolute path: foo = require('/home/foo/lib/bar.js')
- using a search: foo = require('bar')
The first two are easy to understand.
In the third case, Node starts at the current directory, and adds ./node_modules/, and attempts to load the module from that location.
If the module is not found, then it moves to the parent directory and performs the same check, until the root of the filesystem is reached.
[http://book.mixu.net/node/single.html]
===
When you install a-module, with npm install 'module', it will-put it in node_modules-directory inside your current-directory.
name::
* McsEngl.lagJsnd'node-modules,
* McsEngl.lagJsnd'node-modules-directory,
* McsEngl.lagJsnd'node-modules-folder,
* McsEngl.node-modules.Jsnd,
* McsEngl.node-modules-directory,
* McsEngl.node-modules-folder,
Jsndmc'stability-index (0 - 3)
name::
* McsEngl.lagJsnd'stability-index,
description::
lagJsndstability0.Deprecated
This feature is known to be problematic, and changes are
planned. Do not rely on it. Use of the feature may cause warnings. Backwards
compatibility should not be expected.
lagJsndstability1.Experimental
This feature is subject to change, and is gated by a command line flag.
It may change or be removed in future versions.
lagJsndstability2.Stable
The API has proven satisfactory.
Compatibility with the npm ecosystem
is a high priority, and will not be broken unless absolutely necessary.
lagJsndstability3.Locked
Only fixes related to security, performance, or bug fixes will be accepted.
Please do not suggest API changes in this area; they will be refused.
[https://nodejs.org/api/documentation.html#documentation_stability_index]
===
The stability indices are as follows:
Stability: 0 - Deprecated
This feature is known to be problematic, and changes are
planned. Do not rely on it. Use of the feature may cause warnings. Backwards
compatibility should not be expected.
Stability: 1 - Experimental
This feature was introduced recently, and may change
or be removed in future versions. Please try it out and provide feedback.
If it addresses a use-case that is important to you, tell the node core team.
Stability: 2 - Unstable
The API is in the process of settling, but has not yet had
sufficient real-world testing to be considered stable.
Backwards-compatibility
will be maintained if reasonable.
Stability: 3 - Stable
The API has proven satisfactory, but cleanup in the underlying
code may cause minor changes. Backwards-compatibility is guaranteed.
Stability: 4 - API Frozen
This API has been tested extensively in production and is
unlikely to ever have to change.
Stability: 5 - Locked
Unless serious bugs are found, this code will not ever
change. Please do not suggest changes in this area; they will be refused.
[https://nodejs.org/docs/latest-v0.10.x/doc/api/documentation.html#documentation_stability_index]
Jsndmc'wraper
description::
Modules actually are (implemented as) self-executing-functions that RETURN the-semantic-unit which contains the-public-members of the-module.
[HmnSgm.2016-07-25]
===
The module wrapper
Before a module's code is executed, Node.js will wrap it with a function wrapper that looks like the following:
(function (exports, require, module, __filename, __dirname) {
// Your module code actually lives in here
});
By doing this, Node.js achieves a few things:
- It keeps top-level variables (defined with var, const or let) scoped to the module rather than the global object.
- It helps to provide some global-looking variables that are actually specific to the module, such as:
-- The module and exports objects that the implementor can use to export values from the module.
-- The convenience variables __filename and __dirname, containing the module's absolute filename and directory path.
[https://nodejs.org/api/modules.html#modules_the_module_wrapper]
name::
* McsEngl.Jsndmc'wrapper,
Jsndmc.SPECIFIC-DIVISION.public--semantic-unit
description::
Every module exports (has a-public) a-semantic-unit.
Usually it is an-object or a-function.
We can-classify modules on this attribute as:
* object-module,
* function-module,
...
[HmnSgm.2017-10-25]
name::
* McsEngl.lagJsnd'function-module,
* McsEngl.lagJsnd'object-module,
* McsEngl.Jsndmc.specifics-division--on--public-semantic-unit,
* McsEngl.Jsndmc.function,
* McsEngl.Jsndmc.object,
Jsndmc.CORE
description::
Core Modules
Node has several modules compiled into the binary.
These modules are described in greater detail elsewhere in this documentation.
The core modules are defined in node's source in the lib/ folder.
Core modules are always preferentially loaded if their identifier is passed to require().
For instance, require('http') will always return the built in HTTP module, even if there is a file by that name.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_core_modules]
name::
* McsEngl.lagJsnd'builtIn-module,
* McsEngl.lagJsnd'core-module,
* McsEngl.lagJsnd'customNo-module,
* McsEngl.lagJsnd'internal-module,
* McsEngl.lagJsnd'native-module,
* McsEngl.Jsndmc.builtIn,
* McsEngl.Jsndmc.customNo,
* McsEngl.Jsndmc.internal,
* McsEngl.Jsndmc.native,
specific::
* Jsndmc.assert,
* Jsndmc.child_process,
* Jsndmc.cluster,
* Jsndmc.crypto,
* Jsndmc.dns,
* Jsndmc.events,
* Jsndmc.fs,
* Jsndmc.http,
* Jsndmc.https,
* Jsndmc.net,
* Jsndmc.os,
* Jsndmc.path,
* Jsndmc.readline,
* Jsndmc.repl,
* Jsndmc.stream,
* Jsndmc.string_decoder,
* Jsndmc.tls,
* Jsndmc.tty,
* Jsndmc.url,
* Jsndmc.util,
* Jsndmc.vm,
* Jsndmc.zlib,
===
// Jsnd.6-3-1
repl> repl._builtinLibs
[ 'assert', 'buffer', 'child_process', 'cluster', 'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http', 'https', 'net', 'os', 'path', 'punycode', 'querystring', 'readline', 'repl', 'stream', 'string_decoder', 'tls', 'tty', 'url', 'util', 'v8', 'vm', 'zlib' ]
Jsndmc.core.assert-function (core 3.locked)
description::
The assert module provides a simple set of assertion tests that can be used to test invariants.
The module is intended for internal use by Node.js, but can be used in application code via require('assert').
However, assert is not a testing framework, and is not intended to be used as a general purpose assertion library.
The API for the assert module is Locked.
This means that there will be no additions or changes to any of the methods implemented and exposed by the module.
[https://nodejs.org/docs/v6.3.1/api/assert.html#assert_assert]
name::
* McsEngl.assert--Node.js-core-function-module,
* McsEngl.lagJsnd'assert-core-function-module,
* McsEngl.Jsndmc.assert-function,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Function.prototype (mfAssert.__proto__ === Function.prototype //true)
* Object.prototype,
member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(mfAssert).sort()
[ 'AssertionError', 'deepEqual', 'deepStrictEqual', 'doesNotThrow', 'equal', 'fail', 'ifError', 'length', 'name', 'notDeepEqual', 'notDeepStrictEqual', 'notEqual', 'notStrictEqual', 'ok', 'prototype', 'strictEqual', 'throws' ]
Jsndmc.core.events-function (core 2.stable)
description::
Much of the Node.js core API is built around an idiomatic asynchronous event-driven architecture in which certain kinds of objects (called "emitters") periodically emit named events that cause Function objects ("listeners") to be called.
For instance: a net.Server object emits an event each time a peer connects to it; a fs.ReadStream emits an event when the file is opened; a stream emits an event whenever data is available to be read.
All objects that emit events are instances of the EventEmitter class.
These objects expose an eventEmitter.on() function that allows one or more functions to be attached to named events emitted by the object.
Typically, event names are camel-cased strings but any valid JavaScript property key can be used.
When the EventEmitter object emits an event, all of the functions attached to that specific event are called synchronously.
Any values returned by the called listeners are ignored and will be discarded.
[https://nodejs.org/docs/v6.3.1/api/events.html#events_events]
name::
* McsEngl.events--Node.js-core-function-module,
* McsEngl.lagJsnd'events-core-function-module,
* McsEngl.lagJsnd'mfEvents,
* McsEngl.lagJsnd'events-core-function-module,
* McsEngl.Jsndmc.events,
* McsEngl.lagJsnd'mfEvents,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Function.prototype, (mfEvents.__proto__ === Function.prototype //true)
* Object.prototype, (mfEvents.__proto__.__proto__ === Object.prototype //true)
mfEvents'member
mfEvents'Member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(mfEvents).sort()
[ 'EventEmitter',
'defaultMaxListeners',
'init',
'length',
'listenerCount',
'name',
'prototype',
'usingDomains' ]
===
// mfEvents
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] }
mfEvents.EventEmitter-function
description::
events.EventEmitter === events
[HmnSgm.2016-07-02]
var events = require('events')
console.log(events.EventEmitter === events) //true
===
To access the EventEmitter class, require('events').EventEmitter.
When an EventEmitter instance experiences an error, the typical action is to emit an 'error' event.
Error events are treated as a special case in node.
If there is no listener for it, then the default action is to print a stack trace and exit the program.
All EventEmitters emit the event 'newListener' when new listeners are added and 'removeListener' when a listener is removed.
[https://nodejs.org/docs/v0.12.0/api/events.html#events_class_events_eventemitter]
name::
* McsEngl.lagJsnd'EventEmitter-function,
* McsEngl.lagJsnd'mfEvents'EventEmitter,
EventEmitter-object
name::
* McsEngl.lagJsnd'EventEmitter-object,
member::
// 1.7.9 Object.getOwnPropertyNames(new EventEmitter()).sort()).join(', '))
[_events, _eventsCount, _maxListeners, domain]
// Object.getOwnPropertyNames(new EventEmitter().__proto__).sort()).join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// Object.getOwnPropertyNames(new EventEmitter().__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]
mfEvents.prototype-object
member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(mfEvents.prototype).sort()
[ '_events', '_maxListeners', 'addListener', 'constructor', 'domain', 'emit', 'eventNames', 'getMaxListeners', 'listenerCount', 'listeners', 'on', 'once', 'prependListener', 'prependOnceListener', 'removeAllListeners', 'removeListener', 'setMaxListeners' ]
name::
* McsEngl.lagJsnd'events.prototype,
* McsEngl.lagJsnd'mfEvents.prototype,
mfEvents'listener-function
description::
Functions can then be attached to objects, to be executed when an event is emitted.
These functions are called listeners.
Inside a listener function, this refers to the EventEmitter that the listener was attached to.
[https://nodejs.org/docs/v0.12.0/api/events.html#events_events]
name::
* McsEngl.lagJsnd'event-listener,
Jsndmc.core.stream-function (core 2.stable)
description::
A stream is an abstract interface for working with streaming data in Node.js.
The stream module provides a base API that makes it easy to build objects that implement the stream interface.
There are many stream objects provided by Node.js.
For instance, a request to an HTTP server and process.stdout are both stream instances.
Streams can be readable, writable, or both.
All streams are instances of EventEmitter.
The stream module can be accessed using:
const stream = require('stream');
While it is important for all Node.js users to understand how streams works, the stream module itself is most useful for developer's that are creating new types of stream instances.
Developer's who are primarily consuming stream objects will rarely (if ever) have need to use the stream module directly.
[https://nodejs.org/api/stream.html#stream_stream]
name::
* McsEngl.lagJsnd'mfStream,
* McsEngl.lagJsnd'stream-core-function-module,
* McsEngl.Jsndmc.stream,
* McsEngl.lagJsnd'mfStream,
* McsEngl.stream--Node.js-core-function-module,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Function.prototype, (mfStream.__proto__ === Function.prototype //true)
* Object.prototype (mfStream.__proto__.__proto__ === Object.prototype //true)
member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(mfStream).sort()
[ 'Duplex', 'PassThrough', 'Readable', 'Stream', 'Transform', 'Writable', 'length', 'name', 'prototype', 'super_' ]
===
> stream
{ [Function: Stream]
super_:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
Readable:
{ [Function: Readable]
ReadableState: [Function: ReadableState],
super_: [Circular],
_fromList: [Function: fromList] },
Writable: { [Function: Writable] WritableState: [Function: WritableState], super_: [Circular] },
Duplex:
{ [Function: Duplex]
super_:
{ [Function: Readable]
ReadableState: [Function: ReadableState],
super_: [Circular],
_fromList: [Function: fromList] } },
Transform: { [Function: Transform] super_: { [Function: Duplex] super_: [Object] } },
PassThrough: { [Function: PassThrough] super_: { [Function: Transform] super_: [Object] } },
Stream: [Circular] }
lagJsnd'stream-object
description::
Stream-objects pass (pipe) some flow of data through a number of functions, which modify the-data and then pass the modified data to the next function.
name::
* McsEngl.lagJsnd'stream-object,
* McsEngl.stream-object.Jsnd,
description::
What are Streams?
Streams can be defined as a continuous flow of data that can be manipulated asynchronously as data comes in (or out).
In Node.js streams can be readable or writable.
A readable stream is an EventEmitter object that emits data events every time a chunk of data is received.
In our previous example a readable stream has been used to pipe the content of a file down to a HTTP client.
When the stream reaches the end of our file it emits an end event, indicating that no more data events will occur.
In addition a readable stream can be paused and resumed.
Writable streams, on the other hand, accept streams of data.
This type of stream inherits from the EventEmitter object too, and implements two methods: write() and end().
The first method writes data to a buffer and returns true if the data has been flushed correctly, or false if the buffer is full (in this case the data will be sent out later).The end() method simply indicates that the stream is finished.
[http://www.sitepoint.com/introduction-to-streams/]
member::
// 1.7.9 Object.getOwnPropertyNames(new stream()).sort()).join(', '))
[_events, _eventsCount, _maxListeners, domain]
// Object.getOwnPropertyNames(new stream().__proto__).sort()).join(', '))
[constructor, pipe]
// Object.getOwnPropertyNames(new stream().__proto__.__proto__).sort()).join(', '))
[_events, _maxListeners, addListener, constructor, domain, emit, eventNames, getMaxListeners, listenerCount, listeners, on, once, prependListener, prependOnceListener, removeAllListeners, removeListener, setMaxListeners]
// Object.getOwnPropertyNames(new stream().__proto__.__proto__.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]
Generic:
The-objects of mfStream are instances of mfEvents.prototype.
var oStream = new mfStream();
oStream.__proto__ === mfStream.prototype //true
oStream.__proto__.__proto__ === mfEvents.prototype //true
oStream.__proto__.__proto__.__proto__ === Object.prototype //true
===
All streams are instances of EventEmitter.
[https://nodejs.org/api/stream.html#stream_stream]
Streaming-algorithm (link)
Jsndmc.core.buffer-object (core 2.stable)
description::
The-buffer-module contains the-Buffer-function, which is and global-member.
===
The Buffer class is a global within Node.js, making it unlikely that one would need to ever use require('buffer').Buffer.
[https://nodejs.org/docs/v6.3.1/api/buffer.html#buffer_buffer]
name::
* McsEngl.buffer--Node.js-core-object-module,
* McsEngl.lagJsnd'buffer-core-object-module,
* McsEngl.lagJsnd'moBuffer,
* McsEngl.Jsndmc.buffer,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moBuffer.__proto__ === Object.prototype)
member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(moBuffer).sort()
[ 'Buffer', 'INSPECT_MAX_BYTES', 'SlowBuffer', 'kMaxLength' ]
Jsndmc.core.child_process-object (core 2=stable)
description::
Node provides a tri-directional popen(3) facility through the child_process module.
It is possible to stream data through a child's stdin, stdout, and stderr in a fully non-blocking way. (Note that some programs use line-buffered I/O internally.
That doesn't affect node.js but it means data you send to the child process is not immediately consumed.)
To create a child process use require('child_process').spawn() or require('child_process').fork().
The semantics of each are slightly different, and explained below.
[https://nodejs.org/docs/v0.12.0/api/child_process.html#child_process_child_process]
name::
* McsEngl.child-process--Node.js-core-object-module,
* McsEngl.lagJsnd'child-process-core-object-module,
* McsEngl.Jsndmc.child-process,
* McsEngl.lagJsnd'moChild-process,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moChild_process.__proto__ === Object.prototype //true)
API:
* Jsnd.last: https://nodejs.org/api/child_process.html,
Jsndmc.core.cluster-object (core 2=stable)
description::
A single instance of Node.js runs in a single thread.
To take advantage of multi-core systems the user will sometimes want to launch a cluster of Node.js processes to handle the load.
[https://nodejs.org/docs/v6.3.1/api/cluster.html#cluster_cluster]
name::
* McsEngl.cluster-module.Jsnd,
* McsEngl.cluster--Node.js-core-object-module,
* McsEngl.lagJsnd'cluster-core-object-module,
* McsEngl.lagJsnd'moCluster,
* McsEngl.Jsndmc.cluster,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* events.prototype (moCluster.__proto__ === mfEvents.prototype //true)
* Object.prototype (moCluster.__proto__.__proto__ === Object.prototype //true)
Jsndmc.core.crypto-object (core 2.stable)
description::
The crypto module provides cryptographic functionality that includes a set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign and verify functions.
Use require('crypto') to access this module.
[https://nodejs.org/api/crypto.html#crypto_crypto]
name::
* McsEngl.crypto--Node.js-core-object-module,
* McsEngl.lagJsnd'crypto-core-object-module,
* McsEngl.Jsndmc.crypto,
* McsEngl.lagJsnd'moCrypto,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype (moCrypto.__proto__ === Object.prototype //true)
member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(moCrypto).sort()
[ 'Certificate', 'Cipher', 'Cipheriv', 'Credentials', 'DEFAULT_ENCODING', 'Decipher', 'Decipheriv', 'DiffieHellman', 'DiffieHellmanGroup', 'Hash', 'Hmac', 'Sign', 'Verify', '_toBuf', 'constants', 'createCipher', 'createCipheriv', 'createCredentials', 'createDecipher', 'createDecipheriv', 'createDiffieHellman', 'createDiffieHellmanGroup', 'createECDH', 'createHash', 'createHmac', 'createSign', 'createVerify', 'fips', 'getCiphers', 'getCurves', 'getDiffieHellman', 'getHashes', 'pbkdf2', 'pbkdf2Sync', 'privateDecrypt', 'privateEncrypt', 'prng', 'pseudoRandomBytes', 'publicDecrypt', 'publicEncrypt', 'randomBytes', 'rng', 'setEngine' ]
Jsndmc.core.dns-object (core 2.stable)
description::
The dns module contains functions belonging to two different categories:
1) Functions that use the underlying operating system facilities to perform name resolution, and that do not necessarily perform any network communication. This category contains only one function: dns.lookup().
Developers looking to perform name resolution in the same way that other applications on the same operating system behave should use dns.lookup().
...
2) Functions that connect to an actual DNS server to perform name resolution, and that always use the network to perform DNS queries.
This category contains all functions in the dns module except dns.lookup().
These functions do not use the same set of configuration files used by dns.lookup() (e.g. /etc/hosts).
These functions should be used by developers who do not want to use the underlying operating system's facilities for name resolution, and instead want to always perform DNS queries.
[https://nodejs.org/api/dns.html#dns_dns]
name::
* McsEngl.dns--Node.js-core-object-module,
* McsEngl.lagJsnd'dns-core-object-module,
* McsEngl.lagJsnd'dns-core-object-module,
* McsEngl.Jsndmc.dns,
* McsEngl.lagJsnd'moDns,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype (moDns.__proto__ === Object.prototype //true)
lagJsnddns'Member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moDns).sort()
[ 'ADDRCONFIG', 'ADDRGETNETWORKPARAMS', 'BADFAMILY', 'BADFLAGS', 'BADHINTS', 'BADNAME', 'BADQUERY', 'BADRESP', 'BADSTR', 'CANCELLED', 'CONNREFUSED', 'DESTRUCTION', 'EOF', 'FILE', 'FORMERR', 'LOADIPHLPAPI', 'NODATA', 'NOMEM', 'NONAME', 'NOTFOUND', 'NOTIMP', 'NOTINITIALIZED', 'REFUSED', 'SERVFAIL', 'TIMEOUT', 'V4MAPPED', 'getServers', 'lookup', 'lookupService', 'resolve', 'resolve4', 'resolve6', 'resolveCname', 'resolveMx', 'resolveNaptr', 'resolveNs', 'resolvePtr', 'resolveSoa', 'resolveSrv', 'resolveTxt', 'reverse', 'setServers' ]
===
// moDns
{ lookup: [Function: lookup],
lookupService: [Function],
resolve4: [Function: query],
resolve6: [Function: query],
resolveCname: [Function: query],
resolveMx: [Function: query],
resolveNs: [Function: query],
resolveTxt: [Function: query],
resolveSrv: [Function: query],
resolvePtr: [Function: query],
resolveNaptr: [Function: query],
resolveSoa: [Function: query],
reverse: [Function: query],
resolve: [Function],
getServers: [Function],
setServers: [Function],
ADDRCONFIG: 1024,
V4MAPPED: 2048,
NODATA: 'ENODATA',
FORMERR: 'EFORMERR',
SERVFAIL: 'ESERVFAIL',
NOTFOUND: 'ENOTFOUND',
NOTIMP: 'ENOTIMP',
REFUSED: 'EREFUSED',
BADQUERY: 'EBADQUERY',
BADNAME: 'EBADNAME',
BADFAMILY: 'EBADFAMILY',
BADRESP: 'EBADRESP',
CONNREFUSED: 'ECONNREFUSED',
TIMEOUT: 'ETIMEOUT',
EOF: 'EOF',
FILE: 'EFILE',
NOMEM: 'ENOMEM',
DESTRUCTION: 'EDESTRUCTION',
BADSTR: 'EBADSTR',
BADFLAGS: 'EBADFLAGS',
NONAME: 'ENONAME',
BADHINTS: 'EBADHINTS',
NOTINITIALIZED: 'ENOTINITIALIZED',
LOADIPHLPAPI: 'ELOADIPHLPAPI',
ADDRGETNETWORKPARAMS: 'EADDRGETNETWORKPARAMS',
CANCELLED: 'ECANCELLED' }
Jsndmc.core.fs-object (core 3=stable)
description::
File I/O is provided by simple wrappers around standard POSIX functions.
To use this module do require('fs').
All the methods have asynchronous and synchronous forms.
The asynchronous form always take a completion callback as its last argument.
The arguments passed to the completion callback depend on the method, but the first argument is always reserved for an exception.
If the operation was completed successfully, then the first argument will be null or undefined.
When using the synchronous form any exceptions are immediately thrown.
You can use try/catch to handle exceptions or allow them to bubble up.
[https://nodejs.org/api/fs.html]
name::
* McsEngl.fs--Node.js-core-object-module,
* McsEngl.lagJsnd'file-system-core-object-module,
* McsEngl.lagJsnd'fs-core-object-module,
* McsEngl.lagJsnd'file-system-core-object-module,
* McsEngl.lagJsnd'fs-core-object-module,
* McsEngl.Jsndmc.fs,
* McsEngl.lagJsnd'moFs,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moFs.__proto__ === Object.prototype //true)
addressWpg::
* https://nodejs.org/api/fs.html,
moFs'Member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(moFs).sort()
[ 'F_OK', 'FileWriteStream', 'ReadStream', 'SyncWriteStream', 'WriteStream', '_stringToFlags', 'access', 'appendFile', 'chmod', 'chown', 'close', 'constants', 'createWriteStream', 'existsSync', 'fchmodSync', 'fchownSync', 'fdatasync', 'fdatasyncSync', 'fstat', 'fstatSync', 'fsync', 'fsyncSync', 'ftruncate', 'ftruncateSync', 'futimes', 'futimesSync', 'link', 'linkSync', 'lstat', 'lstatSync', 'mkdir', 'mkdirSync', 'mkdtemp', 'mkdtempSync', 'open', 'openSync', 'read', 'readFile', 'readFileSync', 'readSync', 'readdir', 'readdirSync', 'readlink', 'readlinkSync', 'realpath', 'realpathSync', 'rename', 'renameSync', 'rmdir', 'rmdirSync', 'stat', 'statSync', 'symlink', 'symlinkSync', 'truncate', 'truncateSync', 'unlink', 'unlinkSync', 'unwatchFile', 'utimes', 'utimesSync', 'watch', 'watchFile', 'write', 'writeFile', 'writeFileSync', 'writeSync' ]
===
moFs.ReadStream_Class
moFs.Stats_Class
moFs.WriteStream_Class
moFs.appendFile(filename, data, [options], callback)
moFs.appendFileSync(filename, data, [options])
moFs.chmod(path, mode, callback)
moFs.chmodSync(path, mode)
moFs.chown(path, uid, gid, callback)
moFs.chownSync(path, uid, gid)
moFs.close(fd, callback)
moFs.closeSync(fd)
moFs.createReadStream(path, [options])
moFs.createWriteStream(path, [options])
moFs.exists(path, callback)
moFs.existsSync(path)
moFs.fchmod(fd, mode, callback)
moFs.fchmodSync(fd, mode)
moFs.fchown(fd, uid, gid, callback)
moFs.fchownSync(fd, uid, gid)
moFs.fstat(fd, callback)
moFs.fstatSync(fd)
moFs.fsync(fd, callback)
moFs.fsyncSync(fd)
moFs.ftruncate(fd, len, callback)
moFs.ftruncateSync(fd, len)
moFs.futimes(fd, atime, mtime, callback)
moFs.futimesSync(fd, atime, mtime)
moFs.lchmod(path, mode, callback)
moFs.lchmodSync(path, mode)
moFs.lchown(path, uid, gid, callback)
moFs.lchownSync(path, uid, gid)
moFs.link(srcpath, dstpath, callback)
moFs.linkSync(srcpath, dstpath)
moFs.lstat(path, callback)
moFs.lstatSync(path)
moFs.mkdir(path, [mode], callback)
moFs.mkdirSync(path, [mode])
moFs.open(path, flags, [mode], callback)
moFs.openSync(path, flags, [mode])
moFs.read(fd, buffer, offset, length, position, callback)
moFs.readFile(filename, [options], callback)
moFs.readFileSync(filename, [options])
moFs.readSync(fd, buffer, offset, length, position)
moFs.readdir(path, callback)
moFs.readdirSync(path)
moFs.readlink(path, callback)
moFs.readlinkSync(path)
moFs.realpath(path, [cache], callback)
moFs.realpathSync(path, [cache])
moFs.rename(oldPath, newPath, callback)
moFs.renameSync(oldPath, newPath)
moFs.rmdir(path, callback)
moFs.rmdirSync(path)
moFs.stat(path, callback)
moFs.statSync(path)
moFs.symlink(srcpath, dstpath, [type], callback)
moFs.symlinkSync(srcpath, dstpath, [type])
moFs.truncate(path, len, callback)
moFs.truncateSync(path, len)
moFs.unlink(path, callback)
moFs.unlinkSync(path)
moFs.unwatchFile(filename, [listener])
moFs.utimes(path, atime, mtime, callback)
moFs.utimesSync(path, atime, mtime)
moFs.watch(filename, [options], [listener])
moFs.watchFile(filename, [options], listener)
moFs.write(fd, buffer, offset, length, position, callback)
moFs.writeFile(filename, data, [options], callback)
moFs.writeFileSync(filename, data, [options])
moFs.writeSync(fd, buffer, offset, length, position)
Jsndmc.core.http-object (core 2.stable)
description::
To use the HTTP server and client one must require('http').
The HTTP interfaces in Node are designed to support many features of the protocol which have been traditionally difficult to use.
In particular, large, possibly chunk-encoded, messages.
The interface is careful to never buffer entire requests or responses--the user is able to stream data.
HTTP message headers are represented by an object like this:
{ 'content-length': '123',
'content-type': 'text/plain',
'connection': 'keep-alive',
'host': 'mysite.com',
'accept': '*/*' }
Keys are lowercased.
Values are not modified.
In order to support the full spectrum of possible HTTP applications, Node's HTTP API is very low-level.
It deals with stream handling and message parsing only.
It parses a message into headers and body but it does not parse the actual headers or the body...
[https://nodejs.org/docs/v6.3.1/api/http.html#http_http]
name::
* McsEngl.http--Node.js-core-object-module,
* McsEngl.lagJsnd'http-core-object-module,
* McsEngl.lagJsnd'http-core-object-module,
* McsEngl.Jsndmc.http,
* McsEngl.lagJsnd'moHttp,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moHttp.__proto__ === Object.prototype //true)
moHttp'member
moHttp'Member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moHttp).sort()
[ 'Agent', 'Client', 'ClientRequest', 'IncomingMessage', 'METHODS', 'OutgoingMessage', 'STATUS_CODES', 'Server', 'ServerResponse', '_connectionListener', 'createClient', 'createServer', 'get', 'globalAgent', 'request' ]
moHttp.Agent-function
description::
Agent:
{ [Function: Agent]
super_:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] },
defaultMaxSockets: Infinity },
moHttp.Client Function: deprecated
description::
Client: [Function: deprecated],
moHttp.ClientRequest-function
description::
ClientRequest: { [Function: ClientRequest] super_: { [Function: OutgoingMessage] super_: [Object] } },
moHttp.IncomingMessage-function
description::
IncomingMessage:
{ [Function: IncomingMessage]
super_:
{ [Function: Readable]
ReadableState: [Function: ReadableState],
super_: [Object],
_fromList: [Function: fromList] } },
moHttp.METHODS-array
description::
METHODS:
[ 'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE' ],
moHttp.OutgoingMessage-function
description::
OutgoingMessage:
{ [Function: OutgoingMessage]
super_:
{ [Function: Stream]
super_: [Object],
Readable: [Object],
Writable: [Object],
Duplex: [Object],
Transform: [Object],
PassThrough: [Object],
Stream: [Circular] } },
moHttp.STATUS_CODES-object
description::
STATUS_CODES:
{ '100': 'Continue',
'101': 'Switching Protocols',
'102': 'Processing',
'200': 'OK',
'201': 'Created',
'202': 'Accepted',
'203': 'Non-Authoritative Information',
'204': 'No Content',
'205': 'Reset Content',
'206': 'Partial Content',
'207': 'Multi-Status',
'208': 'Already Reported',
'226': 'IM Used',
'300': 'Multiple Choices',
'301': 'Moved Permanently',
'302': 'Found',
'303': 'See Other',
'304': 'Not Modified',
'305': 'Use Proxy',
'307': 'Temporary Redirect',
'308': 'Permanent Redirect',
'400': 'Bad Request',
'401': 'Unauthorized',
'402': 'Payment Required',
'403': 'Forbidden',
'404': 'Not Found',
'405': 'Method Not Allowed',
'406': 'Not Acceptable',
'407': 'Proxy Authentication Required',
'408': 'Request Timeout',
'409': 'Conflict',
'410': 'Gone',
'411': 'Length Required',
'412': 'Precondition Failed',
'413': 'Payload Too Large',
'414': 'URI Too Long',
'415': 'Unsupported Media Type',
'416': 'Range Not Satisfiable',
'417': 'Expectation Failed',
'418': 'I\'m a teapot',
'421': 'Misdirected Request',
'422': 'Unprocessable Entity',
'423': 'Locked',
'424': 'Failed Dependency',
'425': 'Unordered Collection',
'426': 'Upgrade Required',
'428': 'Precondition Required',
'429': 'Too Many Requests',
'431': 'Request Header Fields Too Large',
'451': 'Unavailable For Legal Reasons',
'500': 'Internal Server Error',
'501': 'Not Implemented',
'502': 'Bad Gateway',
'503': 'Service Unavailable',
'504': 'Gateway Timeout',
'505': 'HTTP Version Not Supported',
'506': 'Variant Also Negotiates',
'507': 'Insufficient Storage',
'508': 'Loop Detected',
'509': 'Bandwidth Limit Exceeded',
'510': 'Not Extended',
'511': 'Network Authentication Required' },
moHttp.Server-function
description::
Server: { [Function: Server] super_: { [Function: Server] super_: [Object] } },
moHttp.ServerResponse-function
description::
ServerResponse: { [Function: ServerResponse] super_: { [Function: OutgoingMessage] super_: [Object] } },
moHttp._connectionListener-function
description::
_connectionListener: [Function: connectionListener],
moHttp.createClient Function: deprecated
description::
createClient: [Function: deprecated]
moHttp.createServer-function
description::
createServer: [Function],
moHttp.get-function
description::
get: [Function],
moHttp.globalAgent-object
description::
globalAgent:
Agent {
domain:
Domain {
domain: null,
_events: [Object],
_eventsCount: 1,
_maxListeners: undefined,
members: [] },
_events: { free: [Function] },
_eventsCount: 1,
_maxListeners: undefined,
defaultPort: 80,
protocol: 'http:',
options: { path: null },
requests: {},
sockets: {},
freeSockets: {},
keepAliveMsecs: 1000,
keepAlive: false,
maxSockets: Infinity,
maxFreeSockets: 256 },
moHttp.request-function
description::
request: [Function],
Jsndmc.core.https-object (core 2.stable)
description::
HTTPS is the HTTP protocol over TLS/SSL.
In Node.js this is implemented as a separate module.
[https://nodejs.org/docs/v6.3.1/api/https.html#https_https]
name::
* McsEngl.https--Node.js-core-object-module,
* McsEngl.lagJsnd'https-core-object-module,
* McsEngl.lagJsnd'moHttps,
* McsEngl.Jsndmc.https,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moHttps.__proto__ === Object.prototype //true)
moHttps'Member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moHttps).sort()
[ 'Agent',
'Server',
'createServer',
'get',
'globalAgent',
'request' ]
===
// moHttps
{ Server: { [Function: Server] super_: { [Function: Server] super_: [Object] } },
createServer: [Function],
globalAgent:
Agent {
domain:
Domain {
domain: null,
_events: [Object],
_eventsCount: 1,
_maxListeners: undefined,
members: [] },
_events: { free: [Function] },
_eventsCount: 1,
_maxListeners: undefined,
defaultPort: 443,
protocol: 'https:',
options: { path: null },
requests: {},
sockets: {},
freeSockets: {},
keepAliveMsecs: 1000,
keepAlive: false,
maxSockets: Infinity,
maxFreeSockets: 256,
maxCachedSessions: 100,
_sessionCache: { map: {}, list: [] } },
Agent:
{ [Function: Agent]
super_: { [Function: Agent] super_: [Object], defaultMaxSockets: Infinity } },
request: [Function],
get: [Function] }
Jsndmc.core.net-object (core 2.stable)
description::
The net module provides you with an asynchronous network wrapper.
It contains functions for creating both servers and clients (called streams).
You can include this module with require('net');.
[https://nodejs.org/docs/v6.3.1/api/net.html#net_net]
name::
* McsEngl.net--Node.js-core-object-module,
* McsEngl.lagJsnd'net-core-object-module,
* McsEngl.lagJsnd'net-core-object-module,
* McsEngl.Jsndmc.net,
* McsEngl.lagJsnd'moNet,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moNet.__proto__ === Object.prototype //true)
lagJsndnet'Member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moNet).sort()
[ 'Server', 'Socket', 'Stream', '_createServerHandle', '_normalizeConnectArgs', '_setSimultaneousAccepts', 'connect', 'createConnection', 'createServer', 'isIP', 'isIPv4', 'isIPv6' ]
===
// moNet
{ createServer: [Function],
createConnection: [Function],
connect: [Function],
_normalizeConnectArgs: [Function: normalizeConnectArgs],
Socket: { [Function: Socket] super_: { [Function: Duplex] super_: [Object] } },
Stream: { [Function: Socket] super_: { [Function: Duplex] super_: [Object] } },
Server:
{ [Function: Server]
super_:
{ [Function: EventEmitter]
EventEmitter: [Circular],
usingDomains: true,
defaultMaxListeners: [Getter/Setter],
init: [Function],
listenerCount: [Function] } },
_createServerHandle: [Function: createServerHandle],
isIP: [Function: isIP],
isIPv4: [Function],
isIPv6: [Function],
_setSimultaneousAccepts: [Function] }
Jsndmc.core.os-object (core 2.stable)
description::
The os module provides a number of operating system-related utility methods.
It can be accessed using:
const os = require('os');
[https://nodejs.org/docs/v6.3.1/api/os.html#os_os]
name::
* McsEngl.os--Node.js-core-object-module,
* McsEngl.lagJsnd'os-core-object-module,
* McsEngl.lagJsnd'os-core-object-module,
* McsEngl.Jsndmc.os,
* McsEngl.lagJsnd'moOs,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moOs.__proto__ === Object.prototype //true)
lagJsndos'Member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moOs).sort()
[ 'EOL', 'arch', 'cpus', 'endianness', 'freemem', 'getNetworkInterfaces', 'homedir', 'hostname', 'loadavg', 'networkInterfaces', 'platform', 'release', 'tmpDir', 'tmpdir', 'totalmem', 'type', 'uptime', 'userInfo' ]
===
// moOs
{ hostname: [Function: getHostname],
loadavg: [Function: getLoadAvg],
uptime: [Function: getUptime],
freemem: [Function: getFreeMem],
totalmem: [Function: getTotalMem],
cpus: [Function: getCPUs],
type: [Function: getOSType],
release: [Function: getOSRelease],
networkInterfaces: [Function: getInterfaceAddresses],
homedir: [Function: getHomeDirectory],
userInfo: [Function: getUserInfo],
arch: [Function],
platform: [Function],
tmpdir: [Function],
tmpDir: [Function],
getNetworkInterfaces: [Function: deprecated],
EOL: '\r\n',
endianness: [Function] }
Jsndmc.core.path-object (core 2.stable)
description::
The path module provides utilities for working with file and directory paths.
It can be accessed using:
const path = require('path');
[https://nodejs.org/docs/v6.3.1/api/path.html#path_path]
name::
* McsEngl.path--Node.js-core-object-module,
* McsEngl.lagJsnd'path-core-object-module,
* McsEngl.Jsndmc.path,
* McsEngl.lagJsnd'moPath,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moPath.__proto__ === Object.prototype //true)
member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moPath).sort()
[ '_makeLong', 'basename', 'delimiter', 'dirname', 'extname', 'format', 'isAbsolute', 'join', 'normalize', 'parse', 'posix', 'relative', 'resolve', 'sep', 'win32' ]
Jsndmc.core.readline-object (core 2.stable)
description::
The readline module provides an interface for reading data from a Readable stream (such as process.stdin) one line at a time.
It can be accessed using:
const readline = require('readline');
The following simple example illustrates the basic use of the readline module.
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
rl.question('What do you think of Node.js? ', (answer) => {
// TODO: Log the answer in a database
console.log('Thank you for your valuable feedback:', answer);
rl.close();
});
Note Once this code is invoked, the Node.js application will not terminate until the readline.Interface is closed because the interface waits for data to be received on the input stream.
[https://nodejs.org/docs/v6.3.1/api/readline.html#readline_readline]
name::
* McsEngl.readline--Node.js-core-object-module,
* McsEngl.lagJsnd'readline-core-object-module,
* McsEngl.Jsndmc.readline,
* McsEngl.lagJsnd'moReadline,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moReadline.__proto__ === Object.prototype //true)
member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moReadline).sort()
[ 'Interface', 'clearLine', 'clearScreenDown', 'codePointAt', 'createInterface', 'cursorTo', 'emitKeypressEvents', 'getStringWidth', 'isFullWidthCodePoint', 'moveCursor', 'stripVTControlCharacters' ]
Jsndmc.core.repl-object (core 2.stable) link,
Jsndmc.core.string_decoder-object (2.stable)
description::
The string_decoder module provides an API for decoding Buffer objects into strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16 characters.
It can be accessed using:
const StringDecoder = require('string_decoder').StringDecoder;
The following example shows the basic use of the StringDecoder class.
const StringDecoder = require('string_decoder').StringDecoder;
const decoder = new StringDecoder('utf8');
const cent = Buffer.from([0xC2, 0xA2]);
console.log(decoder.write(cent));
const euro = Buffer.from([0xE2, 0x82, 0xAC]);
console.log(decoder.write(euro));
[https://nodejs.org/docs/v6.3.1/api/string_decoder.html#string_decoder_stringdecoder]
name::
* McsEngl.string-decoder--Node.js--core-object-module,
* McsEngl.lagJsnd'string-decoder--core-object-module,
* McsEngl.Jsndmc.string-decoder,
* McsEngl.lagJsnd'moString-decoder,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moString_decoder.__proto__ === Object.prototype //true)
member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moString_decoder).sort()
[ 'StringDecoder' ]
Jsndmc.core.tls-object (core 2.stable)
description::
The tls module provides an implementation of the Transport Layer Security (TLS) and Secure Socket Layer (SSL) protocols that is built on top of OpenSSL.
The module can be accessed using:
const tls = require('tls');
[https://nodejs.org/docs/v6.3.1/api/tls.html#tls_tls_ssl]
name::
* McsEngl.tls--Node.js-core-object-module,
* McsEngl.lagJsnd'tls-core-object-module,
* McsEngl.Jsndmc.tls,
* McsEngl.lagJsnd'moTls,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moTls.__proto__ === Object.prototype //true)
member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moTls).sort()
[ 'CLIENT_RENEG_LIMIT', 'CLIENT_RENEG_WINDOW', 'DEFAULT_CIPHERS', 'DEFAULT_ECDH_CURVE', 'SLAB_BUFFER_SIZE', 'SecureContext', 'Server', 'TLSSocket', 'checkServerIdentity', 'connect', 'convertALPNProtocols', 'convertNPNProtocols', 'createSecureContext', 'createSecurePair', 'createServer', 'getCiphers', 'parseCertString' ]
Jsndmc.core.url-object (core 2.stable)
description::
The url module provides utilities for URL resolution and parsing.
It can be accessed using:
const url = require('url');
[https://nodejs.org/docs/v6.3.1/api/url.html#url_url]
name::
* McsEngl.url--Node.js-core-object-module,
* McsEngl.lagJsnd'url-core-object-module,
* McsEngl.Jsndmc.url,
* McsEngl.lagJsnd'moUrl,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moUrl.__proto__ === Object.prototype //true)
member::
// 7.9.0 Object.getOwnPropertyNames(moUrl).sort()).join(', '))
[URL, URLSearchParams, Url, domainToASCII, domainToUnicode, format, parse, resolve, resolveObject]
// Object.getOwnPropertyNames(moUrl.__proto__).sort()).join(', '))
[__defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__, __proto__, constructor, hasOwnProperty, isPrototypeOf, propertyIsEnumerable, toLocaleString, toString, valueOf]
===
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moUrl).sort()
[ 'Url', 'format', 'parse', 'resolve', 'resolveObject' ]
Example::
//const moUrl = require('url');
moUrl.resolve('/one/two/', 'four'); //'/one/two/four'
moUrl.resolve('/one/two/three', 'four'); //'/one/two/four'
addressWpg::
* Official-doc: https://nodejs.org/docs/latest/api/url.html,
Jsndmc.core.util-object (core 2.stable)
description::
These functions are in the module 'util'.
Use require('util') to access them.
[https://nodejs.org/api/util.html]
name::
* McsEngl.util--Node.js-core-object-module,
* McsEngl.lagJsnd'util-core-object-module,
* McsEngl.Jsndmc.util,
* McsEngl.lagJsnd'moUtil,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moUtil.__proto__ === Object.prototype //true)
lagJsndutil'member
lagJsndutil'Member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moUtil).sort()
[ '_errnoException', '_exceptionWithHostPort', '_extend', 'debug', 'debuglog', 'deprecate', 'error', 'format', 'inherits', 'inspect', 'isArray', 'isBoolean', 'isBuffer', 'isDate', 'isError', 'isFunction', 'isNull', 'isNullOrUndefined', 'isNumber', 'isObject', 'isPrimitive', 'isRegExp', 'isString', 'isSymbol', 'isUndefined', 'log', 'print', 'puts' ]
===
moUtil.format(format, [...])
moUtil.debug(string)
moUtil.error([...])
moUtil.puts([...])
moUtil.print([...])
moUtil.log(string)
moUtil.inspect(object, [options])
moUtil.isArray(object)
moUtil.isRegExp(object)
moUtil.isDate(object)
moUtil.isError(object)
moUtil.pump(readableStream, writableStream, [callback])
moUtil.inherits(constructor, superConstructor)
Jsndmc.core.vm-object (core 2.stable)
description::
The vm module provides APIs for compiling and running code within V8 Virtual Machine contexts.
It can be accessed using:
const vm = require('vm');
Javascript code can be compiled and run immediately or compiled, saved, and run later.
[https://nodejs.org/docs/v6.3.1/api/vm.html#vm_executing_Javascript]
name::
* McsEngl.vm--Node.js-core-object-module,
* McsEngl.lagJsnd'vm-core-object-module,
* McsEngl.Jsndmc.vm,
* McsEngl.lagJsnd'moVm,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moVm.__proto__ === Object.prototype //true)
lagJsnd-moVm'Member::
// Jsnd.6-2-2
// Object.getOwnPropertyNames(moVm).sort()
[ 'Script', 'createContext', 'createScript', 'isContext', 'runInContext', 'runInDebugContext', 'runInNewContext', 'runInThisContext' ]
Jsndmc.core.zlib-object (core 2.stable)
description::
The zlib module provides compression functionality implemented using Gzip and Deflate/Inflate.
It can be accessed using:
const zlib = require('zlib');
[https://nodejs.org/docs/v6.3.1/api/zlib.html#zlib_zlib]
name::
* McsEngl.zlib--Node.js-core-object-module,
* McsEngl.lagJsnd'zlib-core-object-module,
* McsEngl.Jsndmc.zlib,
* McsEngl.lagJsnd'moZlib,
whole-chain::
* module-instance,
* most-whole-object (global),
generic-chain::
* Object.prototype, (moZlib.__proto__ === Object.prototype //true)
member::
// Jsnd.6-3-1
// Object.getOwnPropertyNames(moZlib).sort()
[ 'Deflate', 'Gunzip', 'Inflate', 'Unzip', 'ZLIB_VERSION', 'Z_BEST_SPEED', 'Z_BUF_ERROR', 'Z_DEFAULT_CHUNK', 'Z_DEFAULT_LEVEL', 'Z_DEFAULT_STRATEGY', 'Z_ERRNO', 'Z_FINISH', 'Z_FULL_FLUSH', 'Z_MAX_CHUNK', 'Z_MAX_MEMLEVEL', 'Z_MEM_ERROR', 'Z_MIN_LEVEL', 'Z_MIN_WINDOWBITS', 'Z_NO_COMPRESSION', 'Z_OK', 'Z_RLE', 'Z_STREAM_ERROR', 'Z_VERSION_ERROR', 'codes', 'createDeflateRaw', 'createGzip', 'createInflateRaw', 'deflate', 'deflateRawSync', 'gunzip', 'gzip', 'inflate', 'inflateRawSync', 'unzip', 'unzipSync' ]
Jsndmc.DIRECTORY
description::
It is convenient to organize programs and libraries into self-contained directories, and then provide a single entry point to that library.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_folders_as_modules]
name::
* McsEngl.lagJsnd'directory-module,
* McsEngl.lagJsnd'folder-module,
* McsEngl.Jsndmc.directory,
* McsEngl.Jsndmc.folder,
description::
Folders as Modules
It is convenient to organize programs and libraries into self-contained directories, and then provide a single entry point to that library. There are three ways in which a folder may be passed to require() as an argument.
The first is to create a package.json file in the root of the folder, which specifies a main module.
An example package.json file might look like this:
{ "name" : "some-library",
"main" : "./lib/some-library.js" }
If this was in a folder at ./some-library, then require('./some-library') would attempt to load ./some-library/lib/some-library.js.
This is the extent of Node's awareness of package.json files.
Note: If the file specified by the "main" entry of package.json is missing and can not be resolved, Node.js will report the entire module as missing with the default error:
Error: Cannot find module 'some-library'
If there is no package.json file present in the directory, then node will attempt to load an index.js or index.node file out of that directory.
For example, if there was no package.json file in the above example, then require('./some-library') would attempt to load:
./some-library/index.js
./some-library/index.node
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_folders_as_modules]
===
Directories as modules
You can organize your modules into directories, as long as you provide a point of entry for Node.
The easiest way to do this is to create the directory ./node_modules/mymodulename/, and put an index.js file in that directory.
The index.js file will be loaded by default.
Alternatively, you can put a package.json file in the mymodulename folder, specifying the name and main file of the module:
{
"name": "mymodulename",
"main": "./lib/foo.js"
}
This would cause the file ./node_modules/mymodulename/lib/foo.js to be returned from require('mymodulename').
Generally, you want to keep a single ./node_modules folder in the base directory of your app.
You can install new modules by adding files or directories to ./node_modules.
The best way to manage these modules is to use npm, which is covered briefly in the next section.
[http://book.mixu.net/node/single.html]
Jsndmc.FILE
name::
* McsEngl.lagJsnd'file-module,
* McsEngl.Jsndmc.file,
description::
File Modules
If the exact filename is not found, then node will attempt to load the required filename with the added extension of .js, .json, and then .node.
.js files are interpreted as Javascript text files, and .json files are parsed as JSON text files.
.node files are interpreted as compiled addon modules loaded with dlopen.
A module prefixed with '/' is an absolute path to the file.
For example, require('/home/marco/foo.js') will load the file at /home/marco/foo.js.
A module prefixed with './' is relative to the file calling require().
That is, circle.js must be in the same directory as foo.js for require('./circle') to find it.
Without a leading '/' or './' to indicate a file, the module is either a "core module" or is loaded from a node_modules folder.
If the given path does not exist, require() will throw an Error with its code property set to 'MODULE_NOT_FOUND'.
[https://nodejs.org/docs/v6.3.1/api/modules.html#modules_file_modules]
Jsndmc.MAIN
description::
Main-module is a-module from which STARTS a-program or a-library.
name::
* McsEngl.lagJsnd'entry-point-module,
* McsEngl.lagJsnd'main-module,
* McsEngl.Jsndmc.main,
Accessing the-main-module:
(link)
Jsndmc.MAIN.NO
description::
Dependent-module is any module importing in another.
name::
* McsEngl.lagJsnd'dependent-module,
* McsEngl.lagJsnd'mainNo-module,
* McsEngl.Jsndmc.mainNo,
