Vanilla JS

// Errors

try {
var a = b + 1;
} catch (error) {
console.log('Ошибка!');
}

try {
setTimeout(function () {throw new Error('Эта ошибка не будет перехвачена');}, 1000);
} catch (error) {
console.log('Ошибки внутри асинхронных функций не могут быть перехвачены с помощью try-catch.');
}

myObserver.on('error', function (error) {console.log('Ошибка!');});
myObserver.emit('error', new Error('Произошла ошибка'));

process.on('uncaughtException', function (error) {console.log('Ошибка!');});

// Stack trace

var error = new Error('message text');
console.log(error.message); // message text
console.log(error.stack);

var myObject = {};
Error.captureStackTrace(myObject);
myObject.stack; // подобно new Error().stack;

function MyError () {
Error.captureStackTrace(this, MyError);
}
new MyError().stack;

console.log(Error.stackTraceLimit);

// Domain

var domain = require('domain');

var dom = domain.create();

dom.on('error', function (error) {
console.log('error: ' + error.message);
});

function asyncFunction () {
setTimeout(function () {throw new Error('Произошла ошибка!');}, 1000);
}

dom.add(asyncFunction);

dom.run(function () {
setTimeout(function () {throw new Error('Произошла еще одна ошибка!');}, 1000);
});

console.log(dom.members);

dom.remove(asyncFunction);

dom.enter();
dom.exit();

dom.dispose();

function asyncReadSomeFile (filePath, callback) {
fs.readFile(filePath, 'utf8', dom.intrcept(function (data) {
return callback(JSON.parse(data));
}));
}

// Assert

var assert = require('assert');
assert.ok(1 > 2, 'Ошибка! 1 должно быть меньше 2.');
assert.deepStrictEqual({a: {b: 1}}, {a: {b: '1'}}, 'Ошибка! Объекты не равны.');

// Console

console.log('message1', 'message2', 'message3');
console.info('message %d', 4);
console.warn('Danger!', 'Danger!', 'Danger!');
console.error('Error', 5);
console.assert(1 > 2, 'Ошибка!');
console.dir({a: 1, b: 2}, {showHidden: true, depth: 3, colors: true});

console.time('100-elements');
for (var i = 0; i < 100; i++) {/* some code */}
console.endTime('100-elements');

console.trace('Show me my stack trace');

var logger = new console.Console(fs.createWriteStream('./stdout.log'), fs.createWriteStream('./stderr.log'));
logger.log('message');

// Global

global.somVar = 1;

Buffer

__dirname; console.log(__dirname); // /Users/work/
__filename; console.log(__filename); // /Users/work/example.js

console.log('message');

var lib = require('./path/to/lib.js');

exports.value = value;
module.exports = function () {};

var fileName = require.resolve('./path/to/lib.js');

console.log(require.cache);

require.extensions['.sjs'] = require.extensions['.js'];

// Modules

// Пути для загрузи модулей
// '/' - абсолютный путь
// './' - текущая папка
// '../' - переход на папку выше

// Раширения модулей
// 'file-name'
// 'file-name.js'
// 'file-name.json'
// 'file-name.node'

var lib = require('./lib.js');
lib.square(4);

exports.circle = function () {};
exports.cube = function () {};
module.exports = function () {
return {
square: function () {}
}:
};

(function (exports, require, __filename, __dirname) {
// по факту весь код модуля обернут в эту функции и находится здесь
});

// Определение загружен ли модуль внутри другого модуля или его код выполняется отдельно

if (require.main === module) {
console.log('standalone module');
} else {
console.log('this module is loaded by require("./lib.js")');
}

var moduleEntryPoint = require.main.filename;

// Перечень значений, содержащихся в объект module

module = {...};
module.id = 'id';
module.filename = 'filename';
module.loaded = true; // if (module.loaded) {}
module.parent = {};
module.children = [...];
module.exports = exports = {...};

var lib = module.require('id');

// Timers

var timeout = setTimeout(function (a, b) {}, 1000, a, b);
var interval = setInterval(function (a, b) {}, 1000, a, b);
var immediate = setImmediate(function (a, b) {}, a, b);

clearTimeout(timeout);
clearInterval(interval);
clearImmediate(immediate);

timeout.ref();
timeout.unref();

process.nextTick(function () {});

// Util

var util = require('util');

util.inherits(constructorFunction, superConstructorFunction);

var result = util.format('string: %s, number: %d, json: %j', 'text', 123, {a: 1}); // 'string: text, number: 123, json: {"a": 1}'

util.inspect({a: 1, b: 2}, {showHidden: true, depth: null}); // '{a: 1, b: 2}'

var obj = {name: 'John'};
obj.inspect = function (depth) {return 'My name is ' + this.name;};
util.inspect(obj); // 'My name is John'

util.isString('text'); // true
util.isObject({a: 1}); // true
util.isRegExp(/abc/); // true

// OS

var os = require('os');

writeStream.write(data + os.EOL); // os.EOL - \n on POSIX, \r\n on Windows

console.log(os.userinfo({encoding: 'utf8'}));

console.log(os.arch); // arm, arm64, ia32, mips, mipsel, ppc
console.log(os.platform()); // aix, darwin, freebsd, linux, openbsd, sunos, win32
console.log(os.type()); // Linux, Darwin, Windows_NT

console.log(os.release()); // 6.1.7601

console.log(os.constants);

console.log(os.cpus());
console.log(os.cpus().length);

console.log(os.endianness()); // BE for big endian and LE for little endian

console.log(os.homedir());
console.log(os.tmpdir());
console.log(os.hostname());

console.log(os.loadavg()); // [0, 0, 0] - minutes load averages
console.log(os.uptime()); // 399711.205897

console.log(os.networkInterfaces());

console.log(os.totalmem()); // 1952432128
console.log(os.freemem()); // 196345856

// Process

if (process.mainModule) {}

process.nextTick(function () {});

console.log(process.argv); // ['C:\\work\\node.exe', 'server.js', '--start']
process.argv.forEach(function (arg) {console.log(arg);});
console.log(process.argv0);
console.log(process.execArgv); // ['--harmony']
console.log(process.execPath); // 'C:\work\node.exe

console.log(process.hrtime()); // [1159384, 69735025]

process.env.someValue = 1;
console.log(process.env);
delete process.env.someValue;

console.log(process.cwd()); // C:\work
process.chdir('/path/to/directory');

process.stdin.setEncoding();
process.stdin.on('readable', function () {
var chunk = process.stdin.read();
if (chunk !== null) {
process.stdout.write('data: ' + chunk);
}
});
process.stdin.on('end', function () {
process.stdout.end('done');
});

console.log = function (message) {process.stdout.write('' + message + '\n');};

console.log(process.stdin);
console.log(process.stdout);
console.log(process.stderr);

process.stdin.pause();
process.stdin.resume();

process.abort();

process.on('beforeExit', function () {});
process.on('exit', function () {});
process.exit(1);
if (process.exitCode === 1) {}

process.on('message', function () {});
process.send(message, sendHandle, options, callback);

process.on('disconnect', function () {});
process.disconnect();

if (process.connected) {}

process.on('unheldedRejection', function () {});
process.on('heldedRejection', function () {});

process.on('warning', function (warning) {
console.log(warning.name);
console.log(warning.message);
console.log(warning.stack);
});
process.emitWarning('Something happened', 'Custom warning');

process.on('SIGINT', function () {});
process.on('SIGHUP', function () {});
process.kill(process.pid, 'SIGHUP');

console.log(process.pid);

console.log(process.platform); // darwin, freebsd, linux, sunos, win32
console.log(process.arch); // ia32
console.log(process.release); // {name: 'node'}
console.log(process.version);
console.log(process.versions);

console.log(process.config);

console.log(process.cpuUsage(previousCpuUsageValue));
console.log(process.memoryUsage());
console.log(process.uptime());

console.log(process.title); // C:\WINDOWS\system32\cmd.exe - node.exe

process.unmask(0o022);

// Child Process

var child_process = require('child_process');

// Выполнить файл и получить результат выполнения сразу через значения stdout и stderr
child_process.execFile('node.exe', ['--version'], {encoding: 'utf8'}, function (error, stdout, stderr) {
if (error) {
console.log('exec file error: ' + error);
return;
}
console.log('stdout: ' + stdout); // v6.2.2
console.log('stderr: ' + stderr);
});

// Выполнить файл и получить поток его выполнения
var spawnProcessStream = child_process.spawn('dir', ['/L'], {shell: true, stdin: 'ignore'});
spawnProcessStream.stdout.on('data', function (data) {console.log('stdout: ' + data);});
spawnProcessStream.stderr.on('data', function (data) {console.log('stderr: ' + data);});
spawnProcessStream.on('close', function (code) {console.log('spawn process exited with code ' + code);});
spawnProcessStream.on('error', function (error) {console.log('Spawn process failed');});

// Выполнить команду в консоли командной строки и получить результат выполнения сразу через значения stdout и stderr
child_process.exec('file.bat', {encoding: 'utf8'}, function (error, stdout, stderr) {
if (error) {
console.log('exec file error: ' + error);
return;
}
console.log('stdout: ' + stdout);
console.log('stderr: ' + stderr);
});

// Выполнить код JavaScript-файла в отдельном процессе Node.js
child_process.fork('./work/server.js', ['127.0.0.1', '80'], {cwd: null, env: process.env});

// Child Process STDIN, STDOUT, STDERR

childProcess.stdin.on('data', function (data) {});
childProcess.stdio.on('data', function (data) {});
childProcess.stdout.on('data', function (data) {});
childProcess.stderr.on('data', function (data) {});

// Child Process Events

childProcess.on('disconnect', function () {});
childProcess.disconnect();

childProcess.on('close', function (code, signal) {
console.log('child process closed with code: ' + code + ' and signal ' + signal);
});

childProcess.on('exit', function (code, signal) {
console.log('child process exit with code: ' + code + ' and signal ' + signal);
});

childProcess.on('error', function (error) {});

childProcess.kill('SIGHUP');

childProcess.on('message', function (message, sendHandler) {
console.log(message);
sendHandler(); // <Handle> netSocket or netServer object or undefined
});

childProcess.send({hello: 'workd'}, require('net').createServer(), {keepOpen: true}, function (error) {
if (error) {throw error;}
console.log('Message sent');
});

if (process.connected) {
process.send('message');
}

console.log(childProcess.pid);

// Cluster

var cluster = require('cluster');

var createServer = require('./server.js');

var numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
var worker;
for (var i = 0; i < numCPUs; i++) {
worker = cluster.fork();
worker.send('hi');
// Навешиваем события на воркеры
var numReqs = 0;
Object.keys(cluster.workers).forEach(function (id) {
cluster.workers[id].on('message', function (message) {
if (message.cmd && message.cmd === 'notifyRequest') {
numReqs++;
}
});
});
cluster.on('exit', function (worker, code, signal) {
console.log('worker ' + worker.process.pid + ' died');
console.log('starting new worker');
cluster.fork();
});
var timeout;
Object.keys(cluster.workers).forEach(function (id) {
var worker = cluster.workers[id];
worker.on('listening', function (address) {
worker.send('shutdown');
worker.disconnect();
timeout = setTimeout(function () {
worker.kill();
}, 2000);
});
worker.on('disconnect', function () {
clearTimeout(timeout);
});
});
}
} else if (cluster.isWorker) {
createServer(function (request, response) {
response.writeHead(200);
response.end('hello world');
// notify master about the request
process.send({cmd: 'notifyRequest'});
});
process.on('message', function (message) {
if (message === 'shutdown') {
// initiate graceful close of any connection to server
}
if (message === 'hi') {
process.send('bye');
}
});
cluster.on('exit', function (worker, code, signal) {
if (worker.exitedAfterDisconnect === true) { // Set by calling .kill() or .disconnect(). Until then, it is undefined.
console.log('It was voluntary - no need to worry');
}
});
}

// Cluster events

cluster.on('fork', function (worker) {});

cluster.on('setup', function () {});

cluster.on('online', function (worker) {console.log('worker responded after it was forked');});

cluster.on('listening', function (worker, address) {console.log('worker connected to ' + address.address + ':' + address.port);});

cluster.on('mesage'), function (worker, message, handle) {
if (arguments.length === 2) {
handle = message;
message = worker;
worker = undefined;
}
});

cluster.on('disconnect', function (worker) {console.log('worker ' + worker.id + ' disconnected');});

cluster.on('exit', function (worker, code, signal) {
console.log('worker ' + worker.process.pid + ' died ' + (signal || code) + '. Restaring...');
cluster.fork();
});

// Cluster status and methods

if (cluster.isMaster) {
// cluster code
console.log('I am master');
cluster.fork();
cluster.fork();
} else if (cluster.isWorker) {
// worker code
console.log('I am worker ' + cluster.worker.id);
}

var worker = cluster.fork({env});

cluster.disconnect(function () {});

cluster.shedulingPolicy;

cluster.settings;

cluster.setupMaster({exec: 'worker.js', args: ['--use', 'http']});
cluster.fork(); // http worker

cluster.setupMaster({exec: 'worker.js', args: ['--use', 'https', silent: true]});
cluster.fork(); // https worker

// Worker events

var worker = cluster.fork();

worker.on('online', function () {console.log('worker is online');});

worker.on('listening', function (address) {console.log('worker is listening');});

worker.on('message', function (message) {
if (message.cmd && message.cmd === 'notifyRequest') {
requestNumber++;
}
});
var requestNumber = 0;
process.send({cmd: 'notifyRequest'});

worker.on('disconnect', function () {console.log('Worker has disconnected');});
worker.disconnect();

worker.on('exit', function (code, signal) {
if (signal) {
console.log('worker was killed by signal: ' + signal);
} else if (code !== 0) {
console.log('worker exited with cocde: ' + code);
} else {
console.log('worker success');
}
});

worker.on('error', function (error) {console.log('Error in worker process');});

// Worker status and methods

worker.kill('SIGTERM');
worker.send(message, sendHandle, callback);

if (worker.isDead()) {}
if (worker.isDisconnected()) {}
if (worker.exitedAfterDisconnect) {}

console.log(worker.id);
console.log(worker.process.pid);

// Пройтись по всем созданным worker

function forEachWorker (callback) {
for (var id in cluster.workers) {
callback(cluster.workers[id]);
}
}

forEachWorker(function (worker) {
worker.send('message to all workers');
});

// V8

var v8 = require('v8');

console.log(v8.getHeapStatistics());
console.log(v8.getHeapSpaceStatistics());
v8.setFlagsFromString('--trace_gc');

// VM

var vm = require('vm');

var script = new vm.Script('var a = 1; console.log(a);');
script.runInThisContext(); // 1

var sandbox = {globalVar: 1};
var script = new vm.Script('globalVar *= 2;');
script.runInNewContext(sandbox);
console.log(sandbox); // {globalVar: 2}

eval('var b = 3;');
console.log('b = ' + b); // b = 3

// REPL

var repl = require('repl');

repl.start('>>> ').context.m = 'Привет!'; // >>> 'Привет!'

// Debugger

debugger;

// Пример.

var x = 5;
setTimeout(function () {
debugger;
console.log('world');
}, 1000);
console.log('Hello');

// Events

var events = require('events');

class Observer extends events.EventEmitter {}

var myObserver= new Observer();

myObserver.addListener('click', function firstClick (a, b) {console.log('First event: ' + a + ', ' + b);});
myObserver.prependListener('click', function zeroClick () {console.log('Zero event');});
myObserver.on('click', secondClick); function secondClick () {console.log('Second event');}
myObserver.once('keyup', function () {console.log('First keyup event'); console.log(this);});
myObserver.prependOnceListener('keyup', function () {console.log('Zero keyup event');});

myObserver.emit('click', 1, 2); // | Zero event | First event: 1, 2 | Second event |
myObserver.emit('keyup'); // | Zero keyup event | First keyup event |

myObserver.removeListener('click', secondClick);
myObserver.removeAllListeners('keyup');

myObserver.on('error', function (error) {console.log('Произошла ошибка: ' + error);});
myObserver.emit('error', new Error('Ошибка!')); // Произошла ошибка!
process.on('uncaughtException', function (error) {console.log('Где-то произошла ошибка!');});

console.log(myObserver.eventNames()); // ['click', 'error']

console.log(myObserver.listeners('click')); // [[Function: zeroClick], [Function: firstClick]]

console.log(myObserver.listenerCount('click')); // 2

console.log(events.EventEmitter.defaultMaxListeners); // 10

myObserver.setMaxListeners(20);
console.log(myObserver.getMaxListeners()); // 20

// Stream

// Readable - читает информацию из источника
// Writable - записывает информацию
// Duplex - читает информацию из источника и записывает её далее
// Transform - преобразует информацию из источника

// Readable streams:
// http.Client.Response
// fs.createReadStream
// process.stdin
// child.process.stdout

var fs = require('fs');

var readFileStream = fs.createReadStream('input.txt', {encoding: 'utf8', hightWaterMark: 2});
var data = '';
readFileStream.on('readable', function () {
data += readFileStream.read();
});
readFileStream.on('error', function (error) {
console.log('Ошибка');
});

// 2 режима чтения потока:
// Flowing Mode - поток информации течет непрерывно и автоматически обрабатывается как можно скорее
// Paused Mode - информация получается с через вызов метода read()

// Flowing Mode
readStream.on('data', function (data) {});
readStream.pipe(writeStream);
readStream.resume();

// Paused Mode
readStream.removeAllListeners('data');
readStream.unpipe(writeStream);
readStream.pause();

// Events
readStream.on('readable', function () {result += readStream.read();}); // как только будет доступна следующая часть данных
readStream.on('data', function (data) {result += data;}); // как только будет автоматически прочитана часть данных
readStream.on('end', function () {console.log('чтение данных завершено');}); // как только больше не будет новых частей данных
readStream.on('close', function () {}); // как только поток для чтения будет закрыт
readStream.on('error', function (error) {}); // как только произойдет ошибка в процессе чтения данных

// Данные читаются в формате string или buffer.

// Пример.

var stream = require('stream');

class TemperatureReadableStream extends stream.Readable {
constructor (options) {
super(options);
this.items = 0;
this.maxItems = 10;
}
_read () {
if (this.items++ < this.maxItems) {
this.push({
date: new Date(2015, 9, this.items + 1)
, temperature: Math.floor(Math.random() * 1000 - 273) + 'C'
});
} else {
this.push(null);
}
}
}

var readTemperatureStream = new TemperatureReadableStream({objectMode: true});
var temperatureObject;
readTemperatureStream.on('readable', function () {
temperatureObject = readTemperatureStream.read();
while (temperatureObject !== null) {
console.log(JSON.stringify(temperatureObject));
temperatureObject = readTemperatureStream.read();
}
});

// Дополнительный пример.

var readableStream = getReadableStreamSomehow();

readableStream.on('readable', function () {console.log('Теперь данные можно прочитать'); readableStream.read();});
readableStream.on('data', function (chunk) {console.log(chunk.length);});
readableStream.on('end', function () {console.log('Все данные успешно прочитаны.'); writableStream.end('Goodbye')});
readableStream.on('close', function () {console.log('Поток чтения данных закрыт.');});
readableStream.on('error', function (error) {console.log('Ошибка!');});

readableStream.pause();
if (readableStream.isPaused()) {
console.log('поток чтения роставлен на паузу');
}
readableStream.resume();

readableStream.setEncoding('utf8');

readableStream.read();
readableStream.end();

readerStream.pipe(writableStream);
readerStream.unpipe(writableStream);

// Writable streams:
// http.Client.Rerquest
// fs.createWriteStream
// process.stdout
// child_process.stdin

var fs = require('fs');

var writeFileStream = fs.createWriteStream('output.txt');
for (var i = 0; i < 10; i++) {
writeFileStream.write('chunk ' + i);
}
writeFileStream.end('Done');

// Events
writeStream.on('drain', function () {}); // как только метод write() вернул значение false, событие drain сообщает о том, что поток готов принять новые данных для записи
writeStream.on('finish', function () {}); // как только поток закончит записывать данные
writeStream.on('close', function () {}); // как только поток для записи данных будет закрыт
writeStream.on('error', function () {}); // как только произойдет ошибка в процессе записи данных
writeStream.on('pipe', function () {}); // как только поток чтения будет подключен к потоку записи данных
writeStream.on('unpipe', function () {}); // как только поток чтения будет отключен от потока записи данных

// Пример.

var stream = require('stream');

class WriteStream extends stream.Writable {
_write (chunk, encoding, callback) {
console.log('write: ' + chunk.toString());
callback();
}
}

var writeStream = new WriteStream();
for (var i = 0; i < 10; i++) {
writeStream.write('chink ' + 1);
}
writeStream.end();

// Buffering
writeStream.cork(); // поместить все данные в буфер памяти для дозирования потока
writeStream.uncork(); // очистить данные из буфера памяти

// Пример.

var writeStream = fs.createWriteStream('output.txt');

writeStream.write('Start');

writeStream.cork();

for (var i = 0; i < 10; i++) {
writeStream.write('chunk ' + i);
}
setTimeout(function () {

writeStream.uncork();

writeStream.end('Done');

}, 2000);

// Дополнительный пример.

var writableStream = getWritableStreamSomehow();

writableStream.on('drain', function writeData () {
writableStream.write('some data', 'utf8');
});
writableStream.on('pipe', function (source) {console.log('Что-то подключилось к потоку записи данных.');});
writableStream.on('unpipe', function (source) {console.log('Что-то отключилось от потока записи данных.');});
writableStream.on('finish', function () {console.log('Все данные успешно записаны.');});
writableStream.on('close', function () {console.log('Поток записи данных закрыт.');}});
writableStream.on('error', function (error) {console.log('Ошибка!');});

writableStream.setDefaultEncoding('utf8');
writableStream.write('some data', 'utf8', function () {console.log('Writing...');});
writableStream.write('some more data', 'utf8', function () {console.log('Writing...');});
writableStream.end('done writing data', 'utf8', function () {console.log('Done');});

readerStream.pipe(writableStream);
readerStream.unpipe(writableStream);

writableStream.cork(); // поместить все данные в буфер памяти для дозирования потока
writableStream.uncork(); // очистить данные из буфера памяти

// Piping

var fs = require('fs');

var readStrem = fs.createReadStream('input.txt');
var writeStream = fs.createWriteStream('output.txt');

writeStream.on('pipe', function () {
console.log('read stream piped to write stream');
});

readStream.pipe(writeStream);

// Duplex streams:
// tcp sockets
// zlib streams
// crypto streams

var stream = require('stream');

class DuplexStream extends stream.Duplex {
_read (size) {...}
_write (chunk, encoding, callback) {...}
}

// Transform streams
// Трансформирует поток чтения по заданным правилам и передает его в поток записи

var fs = require('fs');
var readStream = fs.createReadStream('input.txt');
var writeStream = fs.createWriteStream('output.txt');

var stream = require('stream');

class ToUpperCaseStream extends stream.Transform {
_transform (chunk, encoding, callback) {
this.push(chunk.toString().toUpperCase());
callback();
}
}

var toUpperCaseStream = new ToUpperCaseStream();

readStream.pipe(toUpperCaseStream).pipe(writeStream);

// _flush(callback) - вызывается как только все данные будут потреблены прямо перед событием end

// Path

var path = require('path');

if (path.posix) {var root = path.parse('/home/user/dir/file.txt').root; // '/'
} else if (path.win32) {var root = path.parse('C:\\path\\dir\\file.txt').root; // 'C:\'
}

path.dirname('/foo/bar/baz/asdf/quux'); // return '/foo/bar/baz/asdf'

path.basename('/foo/bar/baz/asdf/quux.html'); // return 'quux.html'
path.basename('/foo/bar/baz/asdf/quux.html', 'html'); // return 'quux'

path.extname('index.coffee.md'); // return '.md'
path.extname('index.'); // return '.'
path.extname('index'); // return ''

path.delimiter; // ; for Windows and : for POSIX
process.env.PATH.split(path.delimiter); // ['C\\Windows\\system32', 'C\\Windows', 'C:\\Program Files\\node\\']

path.sep; // \ on Windows and / on POSIX
'foo/bar/baz'.split(path.sep); // return ['foo', 'bar', 'baz']

path.parse('/home/user/dir/file.txt'); // return {root: '/', dir: '/home/user/dir', base: 'file.txt', name: 'file', ext: '.txt'}

path.format({root: '/', base: 'file.txt'}); // return '/file.txt'
path.format({root: '/', name: 'file', ext: '.txt'}); // return '/file.txt'
path.format({base: 'file.txt'}); // return 'file.txt'
path.format({dir: '/home/user/dir', base: 'file.txt'}); // return '/home/user/dir/file.txt'
path.format({root: 'C:\\', dir: 'C:\\path\\dir', base: 'file.txt', name: 'file', ext: '.txt'}); // return 'C:\\path\\dir\\file.txt'

path.normalize('/foo//bar//baz//asdf/quux'); // return '/foo/bar/baz/asdf/quux'
path.normalize('C:\\temp\\\\foo\\bar'); // return 'C:\\temp\\foo\\bar''

path.join('/foo', 'bar', 'baz/asdf', 'quux'); // return '/foo/bar/baz/asdf/quux'

path.resolve('/foo/bar', './baz'); // return '/foo/bar/baz'
path.resolve('/foo/bar', '/tmp/file'); // return '/tmp/file'
path.resolve('www', 'static_files/png/', '../gif/image.gif'); // Current Working Directory is '/home/user/node' -> return '/home/user/node/www/static_files/gif/image.png'

path.relative(from, to);
path.relative('data/orandea/text/aaa', '/data/ornadea/impl/bbb'); // return '../../impl/bbb'

path.isAbsolute('C:/foo/'); // true
path.isAbsolute('/foo/bar'); // true
path.isAbsolute('quux/'); // false
path.isAbsolute('.'); // false

// File System

var fs = require('fs');

// Константы

fs.constants.F_OK - файл виден текущему процессу
fs.constants.R_OK - файл может быть прочитан
fs.constants.W_OK - файл может быть записан
fs.constants.X_OK - файл может быть выполнен

// Открытие файла для чтения

fs.open('/dir/file.txt', 'r', function (error, fileDescriptor) { // fileDescriptor - переменная, хранящая в себе ссылку на открытый файл - число
if (error) {
if (error.code === 'ENOENT') {
console.log('Файл не существует');
return;
} else {
throw error;
}
}
readMyData(fileDescriptor);
});

// Открытие файла для записи

fs.open('/dir/file.txt', 'wx', function (error, fileDescriptor) { // fileDescriptor - переменная, хранящая в себе ссылку на открытый файл - число
if (error) {
if (error.code === 'EEXIST') {
console.log('Файл уже существует');
return;
} else {
throw error;
}
}
writeMyData(fileDescriptor);
});

// Закрыть открытый файл

fs.close(fileDescriptor); // fileDescriptor - переменная, хранящая в себе ссылку на открытый файл - число

// Прочитать данные

fs.read(fileDescriptor, buffer, offset, length, position, function (error, bytesRead, buffer) {});

// Прочитать данные из файла

fs.readFile('path/to/file.txt', {encoding: 'utf8', flags: 'r'}, function (error, data) {
if (error) {throw error;}
console.log(data);
});

// Записать данные

fs.write(fileDescriptor, buffer, offset, length, position, function (error, written, buffer) {});
fs.write(fileDescriptor, 'data', postion, 'utf8', function (error, writte, string) {});

// Записать данные в файл или создать новй файл

fs.writeFile('path/to/file.txt', 'some text', {encoding: 'utf8', mode: 0o666, flag: 'w'}, function (error) {
if (error) {throw error;}
console.log('Данные в файл записаны');
});

// Запись данных в конец файла

fs.appendFile('/dir/file.txt', 'data to append', 'utf8', function (error) {
if (error) {throw error;}
console.log('Данные успешно записаны в конец файла');
});

// Обрезать файл

fs.truncate('path/to/file.txt', 10, function (error) {});

fs.ftruncate(fileDescriptor, 10, function (error) {
if (error) {throw error;}
console.log('Файл обрезан до 10 байт');
});

// Удаление файла

fs.unlink('/dir/file.txt', function (error) {
if (error) {
console.log('Файл не найден');
return;
}
console.log('Файл успешно удален');
});

fs.unlinkSync('/dir/file.txt');
console.log('Файл успешно удален');

// Переименование или перемещение файла в другую директорию

fs.rename('/dir/file-1.txt', '/dir/file-2.txt', function (error) {
if (error) {
console.log('Невозможно переименовать файл');
return;
}
console.log('Файл успешно переименован');
});

// Получение информации о файле

fs.stat('/dir/file.txt', function (error, stats) {
if (error) {
console.log('Файл не найден');
return;
}
if (stats.isFile()) { // some code
} else if (stats.isDirectory()) { // some code
} else if (stats.isBlockDevice()) { // some code
} else if (stats.isCharacterDevice()) { // some code
} else if (stats.isSymbolicLink()) { // some code
} else if (stats.isFIFO()) { // some code
} else if (stats.isSocket()) { // some code
}
console.log('Информация о файле: ' + JSON.stringify(stats));
});

// Опеределния возможности доступа к файлу

fs.access('path/to/file.txt', fs.constants.R_OK | fs.constants.W_OK, function (error) {
if (error) {
console.log('К файлу не доступа');
} else {
console.log('Файл доступен для чтения и записи');
}
});

// Отслеживание изменения файла

fs.watch('/dir/file.txt', {persistent: true, recursive: true, encoding: 'buffer'}, function (eventType, filename) {
console.log('event type: ' + eventType);
if (filename) {
console.log(filename); // Prints: <Buffer ...>
} else {
console.log('filename not provided');
}
});

fs.watchFile('/dir/file.txt', function (curr, prev) {
console.log('current mtime: ' + curr.mtime);
console.log('previous mtime: ' + prev.mtime);
});

var watcher = fs.watch();
watcher.on('change', function () {});
watcher.on('error', function (error) {});
watcher.close();

// Отменить отслеживание измнения файла

fs.unwatch('filename', listener);

// Изменение прав доступа к файлу

fs.chmod('path/to/file.txt', 777, function (error) {});

// Изменение владельца файла

fs.chown('path/to/file.txt', uid, gid, function (error) {});

// Прочитать ссылку на файл

fs.readlink('path/to/file.txt', {encoding: 'utf8'}, function (error, linkString) {});

// Создать ссылку на файл

fs.link('path/to/file.txt', 'path/to/dstfile.txt', function (error) {});

fs.symlink('./foo', './new-port');

// Получить реальный путь до файла

fs.realpath('path/to/file.txt', {encoding: 'utf8'}, function (error, resolvedPath) {});

// Создание директории

fs.mkdir('path/to/directory', 777, function (error) {});

// Удаление директории

fs.rmdir('path/to/directory', function (error) {});

// Создание директории для временных файлов

fs.mkdtemp('/tmp/foo', function (error, folder) {
if (error) {throw error;}
console.log(folder);
});

// Создание потока чтения

var readStream = fs.readStream();

readStream.on('open', function () {});
readStream.on('close', function () {});

console.log(readStream.bytesRead);
console.log(readStream.path);

// Создание потока записи

var writeStream = fs.writeStream();

writeStream.on('open', function () {});
writeStream.on('close', function () {});

console.log(writeStream.bytesWritten);
console.log(writeStream.path);

// Создание потока чтения из файла

var readFileStream = fs.createReadStream('/dir/file.txt', {flags: 'r', encoding: 'utf8', fs: null, mode: 0o666, autoClose: true, start: 90, end: 99});
var data = '';
readFileStream.on('readable', function () {
data += readFileStream.read();
});
readFileStream.on('error', function (error) {
console.log('Ошибка');
});

// Создание потока записи в файл

var writeFileStream = fs.createWriteStream('/dir/file.txt', {flags: 'w', defaultEncoding: 'utf8', fs: null, mode: 0o666, autoClose: true, start: 15});
for (var i = 0; i < 10; i++) {
writeFileStream.write('chunk ' + i);
}
writeFileStream.end('Done');

// Readline - чтение по строке за раз из потока чтения

var readline = require('readline');

readline.clearLine(stream, dir);
readline.clearScreenDown(stream);

readline.cursorTo(stream, x, y);
readline.moveCursor(strean, dx, dy);

readline.emitKeypressEvents(stream, interface);
readline.emitKeypressEvents(procecss.stdin);
if (process.stdin.isTTY) {
process.stdinsetRawMode(true);
}

var readLine = readline.createInterface({
input: process.stdin
, output: process.stdout
});

readLine.on('line', function (line) {
console.log('Received: ' + line);
});

readLine.question('What do you think?', function (answer) {
// write answer in Database
console.log('Thank you for your feedback: ' + answer);
readLine.close();
});

// Events

readLine.on('line', function (input) {console.log('Received: ' + input);});
readLine.on('pause', function () {console.log('Paused');});
readLine.on('resume', function () {console.log('Resumed');});
readLine.on('close', function () {});

readLine.on('SIGCONT', function () {
readLine.prompt(); // "prompt" will automatically resume the stream
});

readLine.on('SIGINT', function () {
readLine.question('Are you sure you want to exit?', function (answer) {
if (answer.match(/^y(es)$/i)) {
readLine.pause();
}
});
});

readLine.on('SIGTSTP', function () {
console.log('Caught SIGTSTP');
});

// Methods

readLine.pause();
readLine.resume();
readLine.close();

readLine.question('What is your name?', function (answer) {console.log('Your name is ' + answer);});
readLine.prompt(preserveCursor);
readLine.setPrompt(prompt);

readLine.write(data, key);
readLine.write('Delete this!');
readLine.write(null, {ctrl: true, name: 'u'}); // Similar Ctrl+u to delete the line written previously

// Completer function

function completer (line) {
var completions = '.help .error .exit .quit .q'.split(' ');
var hits = completions.filter(function (c) {
return c.indexOf(line) === 0;
});
return [hits.length ? hits : completions, line]; // show all completions if none found
}

funciton completer (linePartial, callback) {
callback(null, [['123'], linePartial]);
}

// Пример Tiny CLI

var readline = require('readline');

var readLine = readline.createInterface({
input: process.stdin
, output: process.stdout
, prompt: '>>> '
});

readLine.on('line', function (line) {
switch (line.trim()) {
case 'hello': console.log('world'); break;
default: console.log('Say something.');
}
line.prompt();
});

readLine.on('close', function () {
console.log('Goodbye');
process.exit(0);
});

readLine.prompt();

// Пример чтения из потока файла линия за линией

var readline = require('readline');
var fs = require('fs');

var readLine = readline.createInterface({
input: fs.createReadStream('./file.txt')
});

readLine.on('line', function (line) {
console.log('Line from file: ' + line);
});

// TTY

var tty = require('tty');

if (process.stdout.isTTY) {}

// tty.ReadStream

if (readStream.isRaw) {}
readStream.setRawMode(mode);

// tty.WriteStream

process.stdout.on('resize', function () {
console.log('screen size has changed');
console.log(process.stdout.columns + 'x' + process.stdout.rows);
});

var columns = writeStream.columns;
var rows = writeStream.rows;

if (tty.isatty(fileDescriptor)) {}

// Buffer

console.log(buffer.INSPECT_MAX_BYTES); // 50
console.log(buffer.kMaxLength); // ~ 1GB

var buf = new Buffer([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); // deprecated
var buf = new Buffer(new Buffer('buffer')); // deprecated
var buf = new Buffer(new Uint16Array(2), 0, 2); // deprecated
var buf = new Buffer(10); // deprecated
var buf = new Buffer('text', 'utf8'); // deprecated

var buf = new SlowBuffer(size); // deprecated

var buf = Buffer.alloc(10, 'a' , 'utf8');
var buf = Buffer.allocUnsafe(10)
var buf = Buffer.allocUnsafeSlow(10);

var str = '0123456789';
for (var index = 0; index < str.length; index++) {
buf[index] = str.charAt(index);
}

var buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
var buf = Buffer.from(new Buffer('buffer'));
var buf = Buffer.from(new Uint16Array(2), 0, 2);
var buf = Buffer.from('text', 'utf8');

var isBuffer = Buffer.isBuffer(new Buffer('buffer'));

var isBufferEncodingUTF8 = Buffer.isEncoding('utf8');

var bytesLength = Buffer.bytesLength('text', 'utf8');

var buf = Buffer.alloc(5);
console.log(buf.length);

var result = buf.toString('base64', start, end);
var result = buf.toJSON();

var isEqual = Buffer.compare(Buffer.form(['1234']), Buffer.form(['0123']));
var isEqual = buf1.compare(buf2, targetStart, targetEnd, sourceStart, sourceEnd);
var isEqual = buf1.equals(buf2);

buf.write('text', offest, length, 'utf8');
buf.writeInt8(2, offset, false);
buf.writeUInt8(0x3, offset, false);
buf.writeFloatBE(0xcafebabe, offset, false);
buf.writeDoubleBE(0xdeadbeefcafebabe, offset, false);

var buf = Buffer.concat([buf1, buf2, buf3], buf1.length + buf2.length + buf3.length);

buf1.copy(buf2, targetStart, sourceStart, sourceEnd);

var buf2 = buf1.slice(0, 3);

var index = buf.indexOf('abc', byteOffset, 'utf8');
var lastIndex = buf.lastIndexOf('abc', byteOffest, 'utf8');

var includes = buf.includes('abc', byteOffset, 'utf8');

var poolSize = Buffer.poolSize; // 8192

var buf = Buffer.from('buffer');
for (var pair of buf.entries()) {
console.log(pair); // [0, 98]
}

var buf = Buffer.from('buffer');
for (var key of buf.keys()) {
console.log(key); // 0
}

var buf = Buffer.from('buffer');
for (var value of buf.values()) {
console.log(value); // 98
}

var buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
console.log(buf); // <Buffer 01 02 03 04 05 06 07 08>
buf.swap16();
console.log(buf); // <Buffer 02 01 04 03 06 05 08 07>
buf.swap16();
buf.swap32();
buf.swap64();

var result = buf.readInt8(offset, false);
var result = buf.readUInt8(offset, false);
var result = buf.readFloatBE(offset, false);
var result = buf.readDoubleBE(offset, false);

// StringDecoder

var StringDecoder = require('string_decoder').StringDecoder;

var decoder = new StringDecoder('utf8');
decoder.write(buffer);
decoder.end(buffer);

var cent = Buffer.from([0xC2, 0xA2]);
console.log(decoder.write(cent));

var euro = Buffer.from([0xE2, 0x82, 0xAC]);
console.log(decoder.write(euro));

decoder.write(Buffer.from([0xE2]));
decoder.write(Buffer.from([0x82]));
console.log(decoder.end(Buffer.from([0xAC])));

// Punycode - deprecated

var punycode = require('punycode');

console.log(punycode.version); // 1.2.0

punycode.decode('maana-pta'); // 'mahana'
punycode.decode('--dqo34k'); // ':)' - смайлик

punycode.encode('mahana.com'); // 'xn--maana-pta.com'
punycode.encode(':).com'); // 'xn----dqo34k.com'

punycode.toASCII('mahana.com'); // 'xn--maana-pta.com'
punycode.toASCII(':).com'); // 'xn----dqo34k.com'

punycode.toUnicode('xn----maana-pta.com'); // 'mahana.com'
punycode.toUnicode('xn--dqo34k.com'); // ':).com'

punycode.ucs2.decode('abc'); // [0x61, 0x62, 0x63]
punycode.ucs2.decode('\uD834\uDF06'); // [0x1D306] - сурогатная пара

punycode.ucs2.encode([0x61, 0x62, 0x63]); // 'abc'
punycode.ucs2.encode([0x1D306]); // '\uD834\uDF06' - сурогатная пара

// URL

var url = require('url');

Escapes characters: < > " ` \r \n \t {} | \ ^ '

var urlObject = url.parse('http://username:password@host.com/8080/p/a/t/h?query=string#hash', parseQueryString, slashesDenoteHost);

urlObject.href; // 'http://username:password@host.com/8080/p/a/t/h?query=string#hash'
urlObject.protocol; // 'http'
if (urlObject.slashes) {} // true если требуется, чтобы за двоеточием (:) в протоколе следовало 2 прямых слэша (//)
urlObject.auth; // 'username:password'
urlObject.host; // 'host.com:8080'
urlObject.hostname; // 'host.com'
urlObject.port; // '8080'
urlObject.path; // '/p/a/t/h?query=string'
urlObject.pathname; // '/p/a/t/h'
urlObject.search; // '?query=string'
urlObject.query; // 'query=string' или {query: 'string'}
urlObject.hash; // '#hash'

url.format(urlObject); // 'http://username:password@host.com/8080/p/a/t/h?query=string#hash'

url.resolve(from, to);
url.resolve('/one/two/three', 'four'); // 'one/two/four'
url.resolve('http://example.com', '/one'); // 'http://example.com/one'
url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'

// Query String

var querystring = require('querystring');

querystring.parse('w=%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82&foo=bar', null, null, {decodeURIComponent: gbkDecodeURIComponent});
querystring.stringify({w: 'привет', foo: 'bar'}, null, null, {encodeURIComponent: gbkEncodeURIComponent});

querystring.escape('w=привет&foo=bar');
querystring.unescape('w=%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82&foo=bar');

// DNS

var dns = require('dns');

dns.lookup('google.com', {family: 4, hints: dns.ADDRCONFIG | dns.V4MAPPED, all: false}, function (error, addresses, family) {
console.log('addresses: ' + addresses);
});

dns.lookupService('127.0.0.1', 22, function (error, hostname, service) {
console.log(hostname, service); // localhost ssh
});

dns.resolve('google.com', 'TXT', function (error, addresses) {});

dns.resolve4('google.com', function (error, addresses) {
if (error) {throw error;}
console.log('addresses: ' + JSON.stringify(addresses));
addresses.forEach(function (a) {
dns.reverse(a, function (error, hostnames) {
if (error) {throw error;}
console.log('reverse for ' + a ':' + JSON.stringify(hostnames));
});
});
});

dns.reverse(ip, function (error, hostnames) {});

// HTTP

http.METHODS
http.STATUS_CODES

http.globalAgent

http.get('http://www.google.com/index.html', function (response) {
console.log('Got response: ' + response.statusCode);
response.resume();
}).on('error', function (error) {
console.log('Got error: ' + error.message);
});

http.createClient(80, '127.0.0.1'); // deprecated

var request = http.request({
hostname: 'www.google.com'
, port: 80
, path: '/'
, method: 'POST'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': Buffer.byteLength(querystring.stringify({msg: 'Hello World!'}))
}
}, function (response) {
console.log('STATUS: ' + response.statusCode);
console.log('HEADERS: ' + JSON.stringify(response.headers));
response.setEncoding('utf8');
response.on('data', function (chunk) {console.log('BODY: ' + chunk);});
response.on('end', function () {console.log('Node more data in response');});
});
request.on('error', function (error) {console.log('Problem with request: ' + error.message);});
request.write(querystring.stringify({msg: 'Hello World!'}));
request.end();

var server = http.createServer(function (request, response) {
response.writeHead(200, 'OK');
response.write('Hello');
response.end('World');
});
server.listen(80);

// http.get

http.get({
hostname: 'localhost'
, port: 80
, path: '/'
, agent: false // create a new agent just for this one request
}, function (response) {
// Do stuff with response
}).on('socket', function (socket) {
socket.emit('agentRemove');
});

// http.Agent

var http = require('http');

var keepAliveAgent = new http.Agent({keepAlive: true});

http.request({
hostname: 'localhost'
, port: 80
, path: '/'
, agent: keepAliveAgent
}, function (request, response) {
// Do stuff with response
});

agent.createConnection(options, function (error, stream) {});
agent.destroy();
agent.getName(options); // return host:port:localAddress
agent.freeSockets;
agent.maxFreeSockets = 256;
agent.maxSockets;
agent.requests;
agent.sockets;

// http.ClientRequest

request.on('response', function (response) {});
request.on('socket', function (socket) {});
request.on('continue', function () {});
request.on('abort', function () {});
request.on('aborted', function () {});
request.on('checkExpectation', function (request, response) {});
request.on('upgrade', function (response, socket, head) {});

// Create HTTP tunneling proxy

var http = require('http');
var net = require('net');
var url = require('url');

var proxy = http.createServer(function (request, response) {
response.writeHead(200, {'Content-Type': 'text/plain'});
response.end('ok');
});

proxy.on('connect', function (response, clientSocket, head) {
// connect to origin server
var serverUrl = url.parse('http://' + request.url);
var serverSocket = net.connect(serverUrl.port, serverUrl.hostname, function () {
clientSocket.write('HTTP/1.1 200 Connection Established\r\nProxy-agent: Node.js-Proxy\r\n\r\n');
serverSocket.write(head);
serverSocket.pipe(clientSocket);
clientSocket.pipe(serverSocket);
});
});

// now that proxy is running
proxy.listen(1337, '127.0.0.1', function () {
// make request to tunneling proxy
var request = http.request({
hostname: '127.0.0.1'
, port: 1337
, path: 'www.google.com:80'
, method: 'CONNECT'
});
request.end();
request.on('connect', function (response, socket, head) {
console.log('got connected!');
// make request over HTTP tunnel
socket.write('GET / HTTP/1.1\r\nHost: www.google.com:80\r\nConnection: close\r\n\r\n');
socket.on('data', function (chunk) {console.log(chunk.toString());});
socket.on('end', function () {proxy.close();});
});
});

// http.createServer

var http = require('http');

var server = http.createServer(function (request, response) {
response.writeHead(200, {'Content-Type': 'text/plain'});
response.write('Hello');
response.end('World');
});

server.on('upgrade', function (request, socket, head) {
socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\nUpgrade: WebSocket\r\nConnection: Upgrade\r\n\r\n');
socket.pipe(socket); // echo back
});

// now that server is running
server.listen(1337, '127.0.0.1', function () {
// make request
var request = http.request({
hostname: '127.0.0.1'
, port: 1337
, headers: {
'Connection': 'Upgarde'
, 'Upgrade': 'websocket'
}
});
request.end();
request.on('upgrade', function (response, socket, upgradeHead) {
console.log('got upgraded!');
socket.end();
process.exit(0);
});
});

request.flushHeaders();
request.write('some text', 'utf8', function () {});
request.end('some text', 'utf8', function () {});
request.abort();
request.setNoDelay(noDelay);
request.setSocketKeepAlive(enable, initialDelay);
request.setTimeout(1500, function () {});

// http.Server

// Events

server.on('connect', function (request, socket, head) {});
server.on('connection', function (socket) {});
server.on('request', function (request, response) {});
server.on('upgrade', function (request, socket, head) {});
server.on('checkContinue', function (request, response) {});
server.on('close', function () {});
server.on('clientError', function (exception, socket) {});

var http = require('http');
var server = http.createServer(function (request, response) {response.end();});
server.on('clientError', function (error, socket) {socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');});
server.listen(8000);

// Methods

server.listen(handle, function () {});
server.listen('127.0.0.1', function () {});
server.listen(80, '127.0.0.1', backlog, function () {});
if (server.listening) {}
server.close(function () {});

server.maxHeadersCount = 1000;
server.setTimeout(1500, function () {});
server.timeout = 120000;

// http.ServerResponse

// Events

respose.on('finish', function () {});
respose.on('close', function () {});

// Methods

response.writeHead(200, 'OK', {'Content-Length': Buffer.byteLength('hello'), 'Content-Type': 'text/plain', 'Trailer': 'Content-MD5'});
response.write('some text', 'utf8', function () {});
response.writeContinue(); // send HTTP/1.1 100 Continue message to the client
response.end('some text', 'utf8', function () {});

respose.addTrailers({'Content-MD5': '7895b5573b623g62l62qw'});

response.statusCode = 404;
response.statusMessage = 'Not Found';

response.setTimeout(1500, function () {});

response.setHeader('Content-Type', 'text/html');
response.setHeader('Set-Cookie', ['type=ninjs', 'language=javasript']);

var contentType = respose.getHeader('content-type');

respose.removeHeader('Content-Encoding');

if (respose.headersSend()) {}

console.log(response.sendDate);

if (response.finished) {}

var server = http.createServer(function (request, response) {
response.setHeader('Content-Type', 'text/html');
response.setHeader('X-Foo', 'bar');
response.writeHead(200, {'Content-Type': 'text/plain'});
response.write('Hello');
response.end('World'); // return content-type = text/plain
});

// http.IncomingMessage

// Events

message.on('aborted', function () {});
message.on('close', function () {});

// Methods

message.setTimeout(1500, function () {});
message.destroy();
message.statusCode = 404;
message.statusMessage = 'Not Found';
console.log(message.rawHeaders); // ['user-agent', 'this is invalid because there can be only one', 'User-Agent', 'curl/7.22.0', 'Host', '127.0.0.1:8000', 'ACCEPT', '*/*']
console.log(message.headers); // {'user-agent': 'curl/7.22.0', host: '127.0.0.1:8000', accept: '*/*'}
console.log(message.httpVersion);
console.log(message.url); // '/status?name=ryan'
console.log(message.method);
console.log(message.rawTrailers);
console.log(message.trailers);
console.log(message.sockets);

// HTTPS

// https.globalAgent

// https.get

var https = require('https');

https.get('https://encrypted.google.com/', function (response) {
console.log('Status code: ' + response.statusCode);
console.log('Header: ' + response.headers);
response.on('data', function (data) {process.stdout.write(data);});
}).on('error', function (error) {
console.error(error);
});

// https.request

var https = require('https');
var fs = require('fs');

var request = https.request({
hostname: 'encrypted.google.com'
, port: 443
, path: '/'
, method: 'GET'
, key: fs.readFileSync('test/keys/agent2-key.pem')
, cert: fs.readFileSync('test/keys/agent2-cert.pem')
, agent: new https.Agent(options) // или false
}, function (response) {
console.log('Status code' + response.statusCode);
console.log('Headers: ' + response.headers);
response.on('data', function (data) {process.stdout.write(data);});
});
request.end();
request.on('error', function (error) {console.error(error);});

// https.createServer

var https = require('https');
var fs = require('fs');

var httpsServer = https.createServer({
key: fs.readFileSync('test/keys/agent2-key.pem')
, cert: fs.readFileSync('test/keys/agent2-cert.pem')
// , pfx: fs.readFileSync('server.pfx')
}, function (request, response) {
response.writeHead(200);
response.write('Hello');
response.end('World');
});
httpsServer.listen(8000);

// Method

httpsServer.listen(handle, function () {});
httpsServer.listen(path, function () {});
httpsServer.listen(80, '127.0.0.1', backlog function () {});

httpsServer.close();

httpsServer.setTimeout(1500, function () {});
httpsServer.timeout;

// Net

var net = require('net');

var server = net.Server();

// Events

server.on('listening', function () {});
server.on('connection', function () {});
server.on('close', function () {});
server.on('error', function () {});

// Method

var address = server.address();

var server = net.createServer(function (socket) {
socket.end('bye');
}).on('error', function (error) {throw error;});

// grab random port
server.listen(function () {
console.log('opened server on ' + server.address()); // don't call server.address() until the 'listening' event has been emitted
});

server.listen(handle, backlog, callback);
server.listen(options, callback);
server.listen(path, backlog, callback);
server.listen(port, hostname, backlog, callback);
server.listen({host: 'localhost', port: 80, exclusive: true});
net.createServer().listen(path.join('\\\\?\\pipe', process.cwd(), 'myctl'));

if (server.listening) {}

server.close();

console.log(server.connections); // deprecated
server.getConnections(function (error, count) {
console.log('Connections number: ' = count);
});

console.log(server.maxConnections);

server.on('error', function (error) {
if (error.code === 'EADDRINUSE') {
console.log('Address in use, retrying...');
setTimeout(function () {
server.close();
server.listen(PORT, HOST);
}, 1000);
}
});

server.ref();
server.unref();

// net.Socket

var socket = new http.Socket({
fs: null
, allowHalfOpen: false
, redable: false
, writable: false
});

// Events

socket.on('connect', function () {});
socket.on('lookup', function () {});
socket.on('drain', function () {});
socket.on('data', function () {});
socket.on('end', function () {});
socket.on('close', function () {});
socket.on('timeout', function () {});
socket.on('error', function () {});

// Methods

var address = socket.address(); // return {port: 1234, family: 'IPv4', address: '127.0.0.1'}

socket.bufferSize;
socket.bytesRead;
socket.bytesWritten;

socket.connect(options, connectListener);
socket.connect(path, connectListener);
socket.connect(port, host, connectListener);

if (socket.connectiong) {}

socket.destroy(exception);
if (socket.destroyed) {}

socket.write(data, 'utf8', function () {});
socket.end(data, 'utf8');

socket.remoteAddress(); // '74.125.127.100'
socket.remoteFamily(); // 'IPv6'
socket.remotePosrt(); // 80

socket.localAddress; // '192.168.1.1'
socket.localPort; // 80

socket.pause();
socket.resume();

socket.setEncoding('utf8');
socket.setKeepAlive(ebable, initialDelay);
socket.setNoDelay(noDelay);

socket.setTimeout(1500, function () {});

socket.ref();
socket.unref();

// connect

net.connect(options, connectListener);
net.connect(path, connectListener);
net.connect(port, host, connectListener);

var net = require('net');

var client = net.connect({port: 8124}, function () {
// 'connect' listener
console.log('connected to server');
client.write('world');
});
client.on('data', function (data) {
console.log(data.toString());
client.end();
});
client.on('end', function () {
console.log('desconnected from server');
});

// createConnection

net.createConnection(options, connectListener);
net.createConnection(path, connectListener);
net.createConnection(port, host, connectListener);

var net = require('net');

var client = net.createConnection({port: 8124}, function () {
// 'connect' listener
console.log('connected to server');
client.write('world');
});
client.on('data', function (data) {
console.log(data.toString());
client.end();
});
client.on('end', function () {
console.log('desconnected from server');
});

// createServer

net.createServer({
allowHalfOpen: false
, pauseOnConnect: false
}, connectionListener);

var net = require('net');

var server = net.createServer(function (connection) {
// 'connection' listener
console.log('client connected');
connection.on('end', function () {
console.log('client diconnected');
});
connection.write('hello');
connection.pipe(connection);
});

server.on('error', function (error) {throw error;});
server.listen(8124, function () {console.log('server bound');});

>>> telnet localhost 8124

// net.isIPv4

if (net.isIP('input')) {}
if (net.isIPv4('input')) {}
if (net.isIPv6('input')) {}

// UDP / Datagaram Sockets

var dgram = require('dgram');

dgram.createSocket(options, function () {});
dgram.createSocket(type, function () {});

var server = dgram.createServer('udp4');

server.on('listening', function () {
var address = server.address();
console.log('server listening ' + address.address + ':' + address.port);
});

server.on('message', function (message, rinfo) {
console.log('server got: ' + message + ' from ' + rinfo.address + ':' + rinfo.port);
});

server.on('error', function (error) {
console.log('server error: ' + error.stack);
server.close();
});

server.bind(41234); // server listening: 0.0.0.0:41234

server.bind({
address: 'localhost'
, port: 8000
, exclusive: true
});

dgram.Socket

// Events

dgram.on('listening', function () {});
dgram.on('message', function (message, rinfo) {console.log('Received ' + msg.length + ' bytes from: ' + rinfo.address + ':' + rinfo.port);});
dgram.on('close', function () {});
dgram.on('error', function (error) {});

// Methods

socket.addMembership(mulitcastAdddress, multicastInterface);
socket.dropMembership(mulitcastAdddress, multicastInterface);

socket.address();

socket.bind(port, address, function () {});
socket.bind(otions, function () {});

socket.send(Buffer.from('some bytes'), offest, length, 41234, 'localhost', function (error) {socket.close();});

socket.setBroadcast(flag);
socket.setMulticastLoopback(flag);
socket.setMulticastTTL(ttl);
sockeet.setTTL(ttl);

socket.close(function () {});

socket.ref();
spcket.unref();

// Change to asynchronous socket.bind() behavior

var socket = dgram.createSocket('udp4');

socket.bind(1234);
socket.addMembership('224.0.0.114');

var socket = dgram.createSocket('udp4');

socket.bind(1234, function () {
socket.addMembership('224.0.0.114');
});

// Transport Layer Security - TLS and Secure Socket Layer - SSL

var tls = require('tls');

// tls.Server

// Events

tlsServer.on('newSession', function (sessionId, sessionData, callback) {});
tlsServer.on('resumeSession', function (sessionId, callback) {});
tlsServer.on('secureConnection', function (tlsSocket) {});
tlsServer.on('OCSPRequest', function (certificate, issuer, callback) {});
tlsServer.on('tlsClientError', function (exception, tlsSocket) {});

var tlsSessionStore = {};
server.on('newSession', function (id, data, callback) {
tlsSessionStore[id.toString('hex')] = data;
callback();
});
server.on('resumeSession', function (id, callback) {
callback(null, tlsSessionStore[id.toString('hex')] || null);
});

// Methods

server.listen(port, hostname, callback);
var connectionsNumber = server.connections;
server.addContext(hostname, context);
server.address();
server.setTicketKeys(keys);
server.getTicketKeys();
server.close(callback);

// tls.TLSSocket

new tls.TLSSocket(socket, options);

// Events

tlsSocket.on('OCSPResponse', function (response) {});
tlsSocket.on('secureConnect', function () {});

// Methods

tlsSocket.address(); // {port: 12346, family: 'IPv4', address: '127.0.0.1'}
tlsSocket.getCipher(); // {name: 'AES256-SHA', version: 'TLSv1/SSLv3'}
tlsSocket.getEphemeralKeyInfo(); // {type: 'ECDH', name: 'prime256v1', size: 256}
tlsSocket.getPeerCertificate(detailed);
tlsSocket.getProtocol(); // SSLv3, TLSv1, TLSv1.1, TLSv1.2, unknown
tlsSocket.getSession();
tlsSocket.getTLSTicket();
tlsSocket.renegotiate(options, function () {});
tlsSocket.setMaxSendFragment(16384);

tlsSocket.localAddress; // local IP address
tlsSocket.localPort; // local port

tlsSocket.remoteAddress; // '74.125.127.100'
tlsSocket.remoteFamily; // 'IPv4' or 'IPv6'
tlsSocket.remotePort; // 443

if (tlsSocket.authorized) {}
if (tlsSocket.authorizationError) {}
if (tlsSocket.encrypted) {}

// connect

tls.connect(options, callback);
tls.connect(port, host, options, function () {});

var tls = require('tls');
var fs = require('fs');

var options = {
// Necessary only if using the client certificate authentication
key: fs.readFileSync('client-key.pem')
, cert: fs.readFileSync('client-cert.pem')

// Necessary only if the server uses the self-signed certificate
, ca: [fs.readFileSync('server-cert.pem')]
};

var socket = tls.connect(8000, options, function () {
console.log('client connected', socket.authorized ? 'authorized' : 'unauthorized');
process.stdin.pipe(socket);
process.stdin.resume();
});
socket.setEncoding('utf8');
socket.on('data', function(data) {console.log(data);});
socket.on('end', function () {server.close();});

var tls = require('tls');
var fs = require('fs');

var options = {
pfx: fs.readFileSync('client.pfx')
};

var socket = tls.connect(8000, options, function () {
console.log('client connected', socket.authorized ? 'authorized' : 'unauthorized');
process.stdin.pipe(socket);
process.stdin.resume();
});
socket.setEncoding('utf8');
socket.on('data', function (data) {console.log(data);});
socket.on('end', function () {server.close();});

// createServer

tls.createSecureContext(options);
tls.createServer(options, secureConnectionListener);

var tls = require('tls');
var fs = require('fs');

var options = {
key: fs.readFileSync('server-key.pem')
, cert: fs.readFileSync('server-cert.pem')

// This is necessary only if using the client certificate authentication.
, requestCert: true

// This is necessary only if the client uses the self-signed certificate.
, ca: [ fs.readFileSync('client-cert.pem') ]
};

var server = tls.createServer(options, function (socket) {
console.log('server connected', socket.authorized ? 'authorized' : 'unauthorized');
socket.write('welcome!\n');
socket.setEncoding('utf8');
socket.pipe(socket);
});
server.listen(8000, function () {console.log('server bound');});

var tls = require('tls');
var fs = require('fs');

var options = {
pfx: fs.readFileSync('server.pfx')

// This is necessary only if using the client certificate authentication.
, requestCert: true
};

var server = tls.createServer(options, function (socket) {
console.log('server connected', socket.authorized ? 'authorized' : 'unauthorized');
socket.write('welcome!\n');
socket.setEncoding('utf8');
socket.pipe(socket);
});
server.listen(8000, function () {console.log('server bound');});

openssl s_client -connect 127.0.0.1:8000

// getCiphers

tls.getCiphers();
console.log(tls.getCiphers()); // ['AES128-SHA', 'AES256-SHA', ...]

// Deprecated APIs

// CryptoStream
cryptoStream.bytesWritten

// SecurePair

// Events
securePair.on('secure', function () {});

// Methods

tls.createSecurePair(context, isServer, requestCert, rejectUnauthorized, options);

pair = tls.createSecurePair(...);
pair.encrypted.pipe(socket);
socket.pipe(pair.encrypted);

secure_socket = tls.TLSSocket(socket, options);

// Crypto

// Determining if crypto support is unavailable

var crypto;

try {
crypto = require('crypto');
} catch (error) {
console.log('crypto support is disabled!');
}

if (crypto) {
var secret = 'abcdefg';
var hash = crypto.createHmac('sha256', secret)
.update('I love cupcakes')
.digest('hex');
console.log(hash); // Prints: c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
}

// Certificate

var crypto = require('crypto');
var cert1 = new crypto.Certificate();
var cert2 = crypto.Certificate();

var cert = require('crypto').Certificate();
var spkac = getSpkacSomehow();
var challenge = cert.exportChallenge(spkac);
console.log(challenge.toString('utf8')); // Prints the challenge as a UTF8 string

var cert = require('crypto').Certificate();
var spkac = getSpkacSomehow();
var publicKey = cert.exportPublicKey(spkac);
console.log(publicKey); // Prints the public key as <Buffer ...>

var cert = require('crypto').Certificate();
var spkac = getSpkacSomehow();
console.log(cert.verifySpkac(Buffer.from(spkac))); // Prints true or false

// Cipher

var crypto = require('crypto');
var cipher = crypto.createCipher('aes192', 'a password');

var encrypted = '';
cipher.on('readable', function () {
var data = cipher.read();
if (data) {
encrypted += data.toString('hex');
}
});
cipher.on('end', function () {
console.log(encrypted); // Prints: ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504
});

cipher.write('some clear text data');
cipher.end();

var crypto = require('crypto');
var fs = require('fs');
var cipher = crypto.createCipher('aes192', 'a password');

var input = fs.createReadStream('test.js');
var output = fs.createWriteStream('test.enc');

input.pipe(cipher).pipe(output);

var crypto = require('crypto');
var cipher = crypto.createCipher('aes192', 'a password');

var encrypted = cipher.update('some clear text data', 'utf8', 'hex');
encrypted += cipher.final('hex');
console.log(encrypted); // Prints: ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504

cipher.final('base64');
cipher.setAAD(buffer);
cipher.getAuthTag();
cipher.setAutoPadding(false);
cipher.update('some text', 'ascii', 'utf8');

// Decipher

var crypto = require('crypto');
var decipher = crypto.createDecipher('aes192', 'a password');

var decrypted = '';
decipher.on('readable', function () {
var data = decipher.read();
if (data) {decrypted += data.toString('utf8');}
});
decipher.on('end', function () {
console.log(decrypted); // Prints: some clear text data
});

var encrypted = 'ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504';
decipher.write(encrypted, 'hex');
decipher.end();

var crypto = require('crypto');
var fs = require('fs');
var decipher = crypto.createDecipher('aes192', 'a password');

var input = fs.createReadStream('test.enc');
var output = fs.createWriteStream('test.js');

input.pipe(decipher).pipe(output);

var crypto = require('crypto');
var decipher = crypto.createDecipher('aes192', 'a password');

var encrypted = 'ca981be48e90867604588e75d04feabb63cc007a8f8ad89b10616ed84d815504';
var decrypted = decipher.update(encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
console.log(decrypted); // Prints: some clear text data

decipher.final('base64');
decipher.setAAD(buffer);
decipher.setAuthTag(buffer);
decipher.setAutoPadding(false);
decipher.update('some text', 'base64', 'utf8');

// DiffieHellman

var crypto = require('crypto');
var assert = require('assert');

// Generate Alice's keys...
var alice = crypto.createDiffieHellman(2048);
var alice_key = alice.generateKeys();

// Generate Bob's keys...
var bob = crypto.createDiffieHellman(alice.getPrime(), alice.getGenerator());
var bob_key = bob.generateKeys();

// Exchange and generate the secret...
var alice_secret = alice.computeSecret(bob_key);
var bob_secret = bob.computeSecret(alice_key);

assert.equal(alice_secret.toString('hex'), bob_secret.toString('hex')); // OK

diffieHellman.computeSecret(other_public_key, 'hex', 'base64');
diffieHellman.generateKeys('base64');
diffieHellman.getGenerator('base64');
diffieHellman.getPrime('base64');
diffieHellman.getPrivateKey('base64');
diffieHellman.getPublicKey('base64');
diffieHellman.setPrivateKey('some key', 'base64');
diffieHellman.setPublicKey('some key', 'base64');
diffieHellman.verifyError = DH_CHECK_P_NOT_SAFE_PRIME';

// ECDH

var crypto = require('crypto');
var assert = require('assert');

// Generate Alice's keys...
var alice = crypto.createECDH('secp521r1');
var alice_key = alice.generateKeys();

// Generate Bob's keys...
var bob = crypto.createECDH('secp521r1');
var bob_key = bob.generateKeys();

// Exchange and generate the secret...
var alice_secret = alice.computeSecret(bob_key);
var bob_secret = bob.computeSecret(alice_key);

assert(alice_secret, bob_secret); // OK

ecdh.computeSecret(other_public_key, 'hex', 'base64');
ecdh.generateKeys('base64', 'compressed');
ecdh.getPrivateKey('base64');
ecdh.getPublicKey('base64', 'compressed');
ecdh.setPrivateKey('some key', 'base64');

ecdh.setPublicKey('some key', 'base64'); // deprecated

var crypto = require('crypto');
var alice = crypto.createECDH('secp256k1');
var bob = crypto.createECDH('secp256k1');

// Note: This is a shortcut way to specify one of Alice's previous private
// keys. It would be unwise to use such a predictable private key in a real
// application.
alice.setPrivateKey(
crypto.createHash('sha256').update('alice', 'utf8').digest()
);

// Bob uses a newly generated cryptographically strong
// pseudorandom key pair bob.generateKeys();

var alice_secret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
var bob_secret = bob.computeSecret(alice.getPublicKey(), null, 'hex');

// alice_secret and bob_secret should be the same shared secret value
console.log(alice_secret === bob_secret);

// Hash

var crypto = require('crypto');
var hash = crypto.createHash('sha256');

hash.on('readable', function () {
var data = hash.read();
if (data) {
console.log(data.toString('hex')); // Prints: 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
}
});

hash.write('some data to hash');
hash.end();

var crypto = require('crypto');
var fs = require('fs');
var hash = crypto.createHash('sha256');

var input = fs.createReadStream('test.js');
input.pipe(hash).pipe(process.stdout);

var crypto = require('crypto');
var hash = crypto.createHash('sha256');

hash.update('some data to hash');
console.log(hash.digest('hex')); // Prints: 6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50

hash.digest('base64');
hash.update('some text', 'utf8');

// Hmac

var crypto = require('crypto');
var hmac = crypto.createHmac('sha256', 'a secret');

hmac.on('readable', function () {
var data = hmac.read();
if (data) {
console.log(data.toString('hex')); // Prints: 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
}
});

hmac.write('some data to hash');
hmac.end();

var crypto = require('crypto');
var fs = require('fs');
var hmac = crypto.createHmac('sha256', 'a secret');

var input = fs.createReadStream('test.js');
input.pipe(hmac).pipe(process.stdout);

var crypto = require('crypto');
var hmac = crypto.createHmac('sha256', 'a secret');

hmac.update('some data to hash');
console.log(hmac.digest('hex')); // Prints: 7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e

hmac.digest('base64');
hmac.update('some text', 'utf8');

// Sign

var crypto = require('crypto');
var sign = crypto.createSign('RSA-SHA256');

sign.write('some data to sign');
sign.end();

var private_key = getPrivateKeySomehow();
console.log(sign.sign(private_key, 'hex')); // Prints the calculated signature

var crypto = require('crypto');
var sign = crypto.createSign('RSA-SHA256');

sign.update('some data to sign');

var private_key = getPrivateKeySomehow();
console.log(sign.sign(private_key, 'hex')); // Prints the calculated signature

var crypto = require('crypto');
var sign = crypto.createSign('sha256');

sign.update('some data to sign');

var private_key = '-----BEGIN EC PRIVATE KEY-----\n' +
'MHcCAQEEIF+jnWY1D5kbVYDNvxxo/Y+ku2uJPDwS0r/VuPZQrjjVoAoGCCqGSM49\n' +
'AwEHoUQDQgAEurOxfSxmqIRYzJVagdZfMMSjRNNhB8i3mXyIMq704m2m52FdfKZ2\n' +
'pQhByd5eyj3lgZ7m7jbchtdgyOF8Io/1ng==\n' +
'-----END EC PRIVATE KEY-----\n';

console.log(sign.sign(private_key).toString('hex'));

sign.sign('some key', 'base64');
sign.update('some text', 'utf8');

// Verify

var crypto = require('crypto');
var verify = crypto.createVerify('RSA-SHA256');

verify.write('some data to sign');
verify.end();

var public_key = getPublicKeySomehow();
var signature = getSignatureToVerify();
console.log(verify.verify(public_key, signature)); // Prints true or false

var crypto = require('crypto');
var verify = crypto.createVerify('RSA-SHA256');

verify.update('some data to sign');

var public_key = getPublicKeySomehow();
var signature = getSignatureToVerify();
console.log(verify.verify(public_key, signature)); // Prints true or false

verifier.update('some text', 'utf8');
verifier.verify({object}, 'hex', signature_format);

// Crypto module methods and properties

let constants = crypto.constants;
crypto.constants.ENGINE_METHOD_RSA
crypto.constants.ENGINE_METHOD_DSA
crypto.constants.ENGINE_METHOD_DH
crypto.constants.ENGINE_METHOD_RAND
crypto.constants.ENGINE_METHOD_ECDH
crypto.constants.ENGINE_METHOD_ECDSA
crypto.constants.ENGINE_METHOD_CIPHERS
crypto.constants.ENGINE_METHOD_DIGESTS
crypto.constants.ENGINE_METHOD_STORE
crypto.constants.ENGINE_METHOD_PKEY_METHS
crypto.constants.ENGINE_METHOD_PKEY_ASN1_METHS
crypto.constants.ENGINE_METHOD_ALL
crypto.constants.ENGINE_METHOD_NONE

let encoding = crypto.DEFAULT_ENCODING;

if (crypto.fips) {}

crypto.createCipher(algorithm, password);
crypto.createCipheriv(algorithm, key, iv);
crypto.createCredentials(details); // deprecated
crypto.createDecipher(algorithm, password);
crypto.createDecipheriv(algorithm, key, iv);
crypto.createDiffieHellman(prime, prime_encoding, generator, generator_encoding);
crypto.createDiffieHellman(prime_length, generator);
crypto.createECDH(curve_name);

crypto.createHash(algorithm);

onst filename = process.argv[2];
var crypto = require('crypto');
var fs = require('fs');

var hash = crypto.createHash('sha256');

var input = fs.createReadStream(filename);
input.on('readable', function () {
var data = input.read();
if (data) {
hash.update(data);
} else {
console.log(`${hash.digest('hex')} ${filename}`);
}
});

crypto.createHmac(algorithm, key);

var filename = process.argv[2];
var crypto = require('crypto');
var fs = require('fs');

var hmac = crypto.createHmac('sha256', 'a secret');

var input = fs.createReadStream(filename);
input.on('readable', function () {
var data = input.read();
if (data)
hmac.update(data);
else {
console.log(`${hmac.digest('hex')} ${filename}`);
}
});

crypto.createSign(algorithm);
crypto.createVerify(algorithm);

crypto.getCiphers();

var ciphers = crypto.getCiphers();
console.log(ciphers); // ['aes-128-cbc', 'aes-128-ccm', ...]

crypto.getCurves();

var curves = crypto.getCurves();
console.log(curves); // ['secp256k1', 'secp384r1', ...]

crypto.getDiffieHellman(group_name);

var crypto = require('crypto');
var alice = crypto.getDiffieHellman('modp14');
var bob = crypto.getDiffieHellman('modp14');

alice.generateKeys();
bob.generateKeys();

var alice_secret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
var bob_secret = bob.computeSecret(alice.getPublicKey(), null, 'hex');

/* alice_secret and bob_secret should be the same */
console.log(alice_secret == bob_secret);

crypto.getHashes();

var hashes = crypto.getHashes();
console.log(hashes); // ['sha', 'sha1', 'sha1WithRSAEncryption', ...]

crypto.pbkdf2(password, salt, iterations, keylen, digest, callback);

var crypto = require('crypto');
crypto.pbkdf2('secret', 'salt', 100000, 512, 'sha512', (err, key) => {
if (err) throw err;
console.log(key.toString('hex')); // 'c5e478d...1469e50'
});

crypto.pbkdf2Sync(password, salt, iterations, keylen, digest);

var crypto = require('crypto');
var key = crypto.pbkdf2Sync('secret', 'salt', 100000, 512, 'sha512');
console.log(key.toString('hex')); // 'c5e478d...1469e50'

crypto.privateDecrypt(private_key, buffer);
crypto.timingSafeEqual(a, b);
crypto.privateEncrypt(private_key, buffer);
crypto.publicDecrypt(public_key, buffer);
crypto.publicEncrypt(public_key, buffer);

crypto.randomBytes(size, callback);

// Asynchronous
var crypto = require('crypto');
crypto.randomBytes(256, (err, buf) => {
if (err) throw err;
console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
});

// Synchronous
var buf = crypto.randomBytes(256);
console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);

crypto.setEngine(engine, flags);

// Zlib

var zlib = require('zlib');

var gzip = zlib.createGzip();
var fs = require('fs');
var inp = fs.createReadStream('input.txt');
var out = fs.createWriteStream('input.txt.gz');

inp.pipe(gzip).pipe(out);

var input = '.................................';
zlib.deflate(input, (err, buffer) => {
if (!err) {
console.log(buffer.toString('base64'));
} else {
// handle error
}
});

var buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');
zlib.unzip(buffer, (err, buffer) => {
if (!err) {
console.log(buffer.toString());
} else {
// handle error
}
});

// Compressing HTTP requests and responses

// client request example
var zlib = require('zlib');
var http = require('http');
var fs = require('fs');
var request = http.get({
host: 'example.com'
, port: 80
, path: '/'
, headers: {'Accept-Encoding': 'gzip,deflate'}
});
request.on('response', function (response) {
var output = fs.createWriteStream('example.com_index.html');
switch (response.headers['content-encoding']) {
// or, just use zlib.createUnzip() to handle both cases
case 'gzip':
response.pipe(zlib.createGunzip()).pipe(output);
break;
case 'deflate':
response.pipe(zlib.createInflate()).pipe(output);
break;
default:
response.pipe(output);
break;
}
});

// server example
// Running a gzip operation on every request is quite expensive.
// It would be much more efficient to cache the compressed buffer.
var zlib = require('zlib');
var http = require('http');
var fs = require('fs');
http.createServer(function (request, response){
var raw = fs.createReadStream('index.html');
var acceptEncoding = request.headers['accept-encoding'];
if (!acceptEncoding) {
acceptEncoding = '';
}
// Note: this is not a conformant accept-encoding parser.
// See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3
if (acceptEncoding.match(/\bdeflate\b/)) {
response.writeHead(200, { 'Content-Encoding': 'deflate' });
raw.pipe(zlib.createDeflate()).pipe(response);
} else if (acceptEncoding.match(/\bgzip\b/)) {
response.writeHead(200, { 'Content-Encoding': 'gzip' });
raw.pipe(zlib.createGzip()).pipe(response);
} else {
response.writeHead(200, {});
raw.pipe(response);
}
}).listen(1337);

// This is a truncated version of the buffer from the above examples
var buffer = Buffer.from('eJzT0yMA', 'base64');

zlib.unzip(buffer, {finishFlush: zlib.Z_SYNC_FLUSH}, function (err, buffer) {
if (!err) {
console.log(buffer.toString());
} else {
// handle error
}
});

// Memory Usage Tuning

(1 << (windowBits+2)) + (1 << (memLevel+9))

{windowBits: 14, memLevel: 7}

1 << windowBits

// Flushing

var zlib = require('zlib');
var http = require('http');

http.createServer((request, response) => {
// For the sake of simplicity, the Accept-Encoding checks are omitted.
response.writeHead(200, { 'content-encoding': 'gzip' });
var output = zlib.createGzip();
output.pipe(response);
setInterval(function () {
output.write(`The current time is ${Date()}\n`, function () {
// The data has been passed to zlib, but the compression algorithm may
// have decided to buffer the data for more efficient compression.
// Calling .flush() will make the data available as soon as the client
// is ready to receive it.
output.flush();
});
}, 1000);
}).listen(1337);

Constants

zlib.Z_NO_FLUSH
zlib.Z_PARTIAL_FLUSH
zlib.Z_SYNC_FLUSH
zlib.Z_FULL_FLUSH
zlib.Z_FINISH
zlib.Z_BLOCK
zlib.Z_TREES

zlib.Z_OK
zlib.Z_STREAM_END
zlib.Z_NEED_DICT
zlib.Z_ERRNO
zlib.Z_STREAM_ERROR
zlib.Z_DATA_ERROR
zlib.Z_MEM_ERROR
zlib.Z_BUF_ERROR
zlib.Z_VERSION_ERROR

// Class Options:
- flush (default: zlib.Z_NO_FLUSH)
- finishFlush (default: zlib.Z_FINISH)
- chunkSize (default: 16*1024)
- windowBits
- level (compression only)
- memLevel (compression only)
- strategy (compression only)
- dictionary (deflate/inflate only, empty dictionary by default)

Class: zlib.Deflate
Class: zlib.DeflateRaw
Class: zlib.Gunzip
Class: zlib.Gzip
Class: zlib.Inflate
Class: zlib.InflateRaw
Class: zlib.Unzip
Class: zlib.Zlib

zlib.flush(kind, function () {});
zlib.params(level, strategy, function () {});
zlib.reset();
zlib.constants
zlib.createDeflate(options);
zlib.createDeflateRaw(options);
zlib.createGunzip(options);
zlib.createGzip(options);
zlib.createInflate(options);
zlib.createInflateRaw(options);
zlib.createUnzip(options);

// Convenience Methods

zlib.deflate(buf, options, function () {});
zlib.deflateSync(buf, options);
zlib.deflateRaw(buf, options, function () {});
zlib.deflateRawSync(buf, options);
zlib.gunzip(buf, options, function () {});
zlib.gunzipSync(buf, options);
zlib.gzip(buf, options, function () {});
zlib.gzipSync(buf, options);
zlib.inflate(buf, options, function () {});
zlib.inflateSync(buf, options);
zlib.inflateRaw(buf, options, function () {});
zlib.inflateRawSync(buf, options);
zlib.unzip(buf, options, function () {});
zlib.unzipSync(buf, options);

Vanilla JS

понедельник, 17 октября 2016 г.

Node.js Quick Docs Help

NPM and Yarn Cheat Sheet

понедельник, 17 октября 2016 г.

Node.js Quick Docs Help

NPM and Yarn Cheat Sheet

понедельник, 17 октября 2016 г.