Краткий перечень API Node.js

=======================================
| Cheat sheet small - краткая подсказка
=======================================

npm init
npm install --save gulp
npm uninstall --save gulp
npm update
npm list

global

require
export
module.exports

assert()

console.log()

process.argv
process.stdout.write()
porcess.stderr.write()
porcess.stdin
process.exit()
process.stdout.clearLine()
process.stdout.cursorTo()

child_porcess.spawn()
child_process.exec()

var emeitter = new events.EventEmitter();
emeitter.on()
emeitter.once()
emeitter.addListener()
emeitter.removeListener()
emeitter.emit()

setTimeout()
setInterval()
setImmediate()

Buffer
__filename
__dirname
path
fs.writeFile()
fs.appendFile()
fs.readFile()
fs.rename()
fs.unlink()
fs.stat.isFile()
fs.stat.isDirectory()

fs.readdir()
fs.mkdir()
fs.rename()
fd.rmdir

fs.createReadStream()
fs.createWriteStream()
writeStream.write()
readStream.pipe()

url.parse()
url.format()
querystring.parse(
querystring.stringify()
querystring.escape()
querystring.unescape()
http.request()
http.createServer()
bodyParser()

os

debugger

=======================================
| Cheat sheet big - большая подсказка
=======================================

// NPM

npm init
npm install --save gulp
npm uninstall --save gulp
npm update
npm list

// Global, __dirname, __filename

console.log(global); // аналог window

console.log(__dirname); // абсолютный путь до папки из которой запущен данный файл
console.log(__filename); // абсолютный путь до данного файла

console.log(process.argv); // массив аргументов

// Process, stdout, stderr, stdin

process.stdout.write(`\n\n\n${__filename}\n\n\n`); // аналог console.log()

process.stderr.write(`\n\n\n${__dirname}\n\n\n`); // аналог console.error()

process.stdin.on("data", function (data) {
    process.stdout.write(data.toString());
    process.exit();
});

process.on("exit", function () {
    process.stdout.write("Goodbye");
});

process.stdout.clearLine(); // очистить текущую строку выводы в окне терминала

process.stdout.cursorTo(0); // переместить курсор в окне терминала на позицию 0

// Дочерний процесс - выполнить команду для терминала - exec

var exec = require("child_process").exec; // выполнить команду для терминала

var command = "open http://www.goggle.com"; // команда для терминала

exec(command, function (error, stdout) {
    if (error) {throw error;}
    console.log("Done");
    console.log(stdout);
});

// Дочерний процесс - запустить дочерний процесс - spawn

var spawnProcess = require("child_process").spawn;

var terminalCommand = "node";

var options = ["script-file.js", "say", "hi!"];

var childProcess = spawn(terminalCommand, options);

childProcess.stdout.on("data", function (data) {
    console.log(data.toString());
});

childProcess.on("close", function () {
    console.log("Done");
    process.exit();
});

setTimeout(function(){
    childProcess.stdin.write("stop"); // выполнить команду в консоли дочернего процесса
}, 5000);

// Модули - require, export, module.exports

var moduleFile = require("moduleFile"); // пути: ./ - текущая папка, ../ - внешняя папка, / - внутренняя папка

export var a = 1;
export function b () {}

module.exports = {a: a, b: b}; // аналог return из RequireJS

// События - on, once, emit, addListener, removeListener

var events = require("events");

var emitter = new events.EventEmitter();

emitter.on("say", function say (message) {});

emitter.once("say", function say (message) {});

emitter.addListener("say", function say (message) {});

emitter.removeListener("say", say);

emitter.emit("say", "Hello World");

// Работа с файлами - получение списка файлов, находящихся в папке - readdir

var fs = require("fs");

var files = readdirSync("./some/folder");
console.log(files);

readdir("./some/folder", function (error, files) {
    if (error) {throw error;}
    console.log(files);
});

// Работа с файлами - чтение содержимого файла - readFile

var fs = require("fs");

var fileContent = fs.readFileSync("./some/file.txt", "UTF-8"); // кодировку нужно указывать !!!
console.log(fileContent);

readFile("./some/file.txt", "UTF-8", function (error, fileContent) {
    if (error) {throw error;}
    console.log(fileContent);
});

// Работа с файлами - получение описания файла stat

var fs = require("fs");
var path = require("path");

fs.readdir("./libs", function (error, files) {
    if (error) {throw error;}
    files.forEach(function (fileName) {
        var file = path.join(__dirname, "libs", fileName); // абсолютный путь до файла
        var stats = fs.statSync(file);
        if (stats.isFile()) {
            fs.readFile(file, "UTF-8", function (error, fileContent) {
                if (error) {throw error;}
                console.log(fileContent);
            });
        } else if (stats.isDirectory()) {
            console.log("It is directory");
        }
    });
});

// Работа с файлами - создание файла и запись в файл - writeFile

var fs = require("fs");

var fileContent = "Hello World";

fs.writeFileSync("sample.txt", fileContent);
console.log("Done");

fs.writeFile("sample.txt", fileContent, function (error) {
    if (error) {throw error;}
    console.log("Done");
});

fs.appendFile("sample.txt", "\nGoodbye");

// Работа с файлами - переименование и перемещение файлов в другую папку - rename

var fs = require("fs");

fs.renameSync("./lib/file-1.js", "./lib/file-2.js"); // переименование файла
console.log("Файл переименован");

fs.rename("./lib/file-1.js", "./file-1.js", function (error) { // перемещение файла в другую папку
    if (error) {throw error;}
    console.log("Файл пемемещен в другую папку");
});

// Работа с файлами - удаление файлов - unlink

var fs = require("fs");

try {
    fs.unlinkSync("./lib/file-1.js"); // удаление файла
    console.log("Done");
} catch (error) {
    console.log(error);
}

fs.unlink("./lib/file-1.js", function (error) { // удаление файла
    if (error) {throw error;}
    console.log("Done");
});

// Работа с файлами - создание директорий - mkdir, exists

var fs = require("fs");

if (fs.existsSync("lib")) {
    console.log("Directory lib already exists");
} else {
    fs.mkdir("libs", function (error) {
        if (error) {throw error;}
        console.log("Directory created");
    });  
}

// Работа с файлами - переименование и перемещение папок в другую папку - rename

var fs = require("fs");

fs.renameSync("./assets/logs", "./logs"); // перемещение папки в другую папку
console.log("Done");

// Работа с файлами - удаление папки - rmdir - НЕЛЬЗЯ УДАЛИТЬ ПАПКУ, ЕСЛИ В НЕЙ ЕЩЕ ЕСТЬ ФАЙЛЫ! СНАЧАЛА НАДО УДАЛИТЬ ВСЕ ФАЙЛЫ!

var fs = require("fs");

var files = fs.readdirSync("./libs");

if (files.length > 0) {
    files.forEach(function (fileName) {
        fs.unlinkSync("./libs" + fileName);
    });
}

fs.rmdir("./libs", function (error) {
    if (error) {throw error;}
    console.log("Done");
});

// Потоки - readable, writable, duplex = readable + writable

// Потоки - создание потока для чтения данных - createReadStream

var fs = require("fs");

var readStream = fs.createReadStream("./chat.log", "UTF-8"); // прочитать содержимое файла в потоке

var fileContent = "";

readStream.on("data", function (chunk) {
    fileContent += chunk;
    process.stdout.write(chunk);
});

readStream.on("end", function () {
    console.log("Done");
});

// Потоки - создание потока для записи данных - createWriteStream

var fs = require("fs");

var writeSteam = fs.createWriteStream("./chat.log");

for (var i = 0; i < 1000; i++) {
    writeStream.write(Math.random());
}

// HTTP - клиентский запрос - request

var http = require("http");
var fs = require("fs");

var options = {
    hostname: "google.com",
    post: 80
    path: "/search/data",
    method: "GET"
};

var request = http.request(options, function (response) {
    response.setEncoding("UTF-8");
    console.log(response.statusCode);
    console.log(response.headers);
    var responseBody = "";
    response.on("data", function (chunk) {
        responseBody += chunk;
    });
    response.on("end", function () {
        fs.writeFile("some.html", responseBody, function (error) {
            if (error) {throw error;}
            console.log("File downloaded");
        });
    });
});

request.on("error", function () {
    console.log("Error in request");
});

request.end(); // Послать запрос на сервер

// HTTP - создание сервера - createServer

var http = require("http");

var server = http.createServer(function (request, response) {
    response.writeHead(200, {"Content-Type": "text/html"});
    response.write("<!DOCTYPE html>");
    response.end(); // Завершить отправку ответа
});

server.listen("127.0.0.1:80"); // Создать сервер

// HTTP - обслуживание файлов - writeHead, write, end, url, method

var http = require("http");
var fs = require("fs");
var path = require("path");

var server = http.createServer(function (request, responce) {
    console.log(respose.method);
    if (requres.url === "/") {
        fs.readFile("./public/index.html", "UTF-8", function (error, fileContent) {
            if (error) {throw error;}
            response.writeHead(200, {"Content-Type": "text/html"});
            response.end(fileContent);
        });
    } else if (request.url.match(/.css$/)) {
        var cssPath = path.join(__dirname, "public", request.url);
        var readFileStream = fs.createReadStream(cssPath, "UTF-8"); // текстовые данные
        response.writeHead(200, {"Content-Type": "text/css"});
        readFileStream.on("data", function (chunk) {
            response.write(chunk);
        });
        readFileStream.on("end", function () {
            response.end();
        });
        // или можно так
        // readFileStream.pipe(response); // автоматически ставит в конце response.end()
    } else if (request.url.match(/.jpg$/)) {
        var imagePath = path.join(__dirname, "public", request.url);
        var readFileStream = fs.createReadStream(imagePath); // бинарные данные
        response.writeHead(200, {"Content-Type": "image/jpeg"});
        readFileStream.pipe(response);
    } else {
        response.writeHead(404, {"Content-Type": "text/plain"});
        response.end("404 File Not Found");
    }
    console.log(request);
   
});

server.listen("127.0.0.1:80");

// HTTP - обслуживание JSON - writeHead, write, end, url, method

var http = require("http");
var data = require("./json-file");

var server = http.createServer(function (request, response) {
    if (request.url === "/") {
        response.writeHead(200, {"Content-Type": "text/json"});
        response.end(JSON.stringify(data));
    } else if (request.url === "/instock") {
        listInStock(response);
    } else if (requrest.url === "/onorder") {
        listOnBackOrder(response);
    } else {
        response.writeHead(404, {"Content-Type": "text/plain");
        response.end("404 File Not Found");
    }
});

server.listen("127.0.0.1:80");

function listInStock (response) {
    var inStock = data.filter(function (item) {
        return item.available === "In stock";
    });
    response.writeHead(200, {"Content-Type": "text/json"});
    reponse.end(JSON.stringify(inStock));
}

function listOnBackOrder (response) {
    var onOrder = data.filter(function (item) {
        return item.available === "On back order";
    });
    response.writeHead(200, {"Content-Type": "text/json"});
    reponse.end(JSON.stringify(onOrder));
}

// HTTP - обслуживание GET, POST - writeHead, write, end, url, method

var http = require("http");
var fs = require("fs");

var server = http.createServer(function (request, response) {
    if (request.method === "GET") {
        response.writeHead(200, {"Content-Type": "text/html"});
        var fileReadStream = fs.createReadStream("./public/form.html", "UTF-8");
        fileReadStream.pipe(response);
    } else if (request.method === "POST") {
        var body = "";
        request.on("data", function (chunk) {
            body += chunk;
        });
        request.on("end", function () {
            response.writeHead(200, {"Content-Type": "text/html"});
            reponse.end(body);
        });
    }

});

server.listen("127.0.0.1:80");

// Express - сервер и прослойки middleware - app, use, get, post, delete, static, bodyParser

var express = require("express");

var app = express();

app.use(express.static("./public"));

app.use(epress.bodyParser({uploadDir: "./upload"}));

app.use(function (request, response, next) {
    console.log(request.method);
    console.log(request.url);
    next();
});

app.get("/", function (request, response) {
    response.json({one: 1, two: 2});
});

app.post("/form", function (request, response) {
    response.end("<!DOCTYPE html>" + request.body);
});

app.delete("/delete/:id", function (request, response) {
    response.end(request.params.id);
});

app.listen("127.0.0.1:80");

module.exports = app;

// WebSockets - стронняя библиотека WS для работы с WebSockets - WebSocketServer, send

var WebSocketServer = require("ws");

var wss = new WebSocketServer({port: 80});

wss.on("connection", function (webSocket) {
    webSocket.on("message", function (message) {
        if (message === "exit") {
            webSocket.close();
        } else {
            wss.clients.forEach(function (client) {
                client.send(message);
            });
        }
    });
    webSocket.send("Welcome to chat");
});

// Socket.IO - стронняя библиотека Socket.IO для работы с WebSockets - emit

var express = require("express");
var http = require("http");
var io = require("socket.io");

var app = express();

var server = http.createServer(app).listen("127.0.0.1:80");

io(server);

app.use(express.static("./public"));

io.on("connection", function (socket) {
    socket.on("chat", function (message) {
        socket.broadcast.emit("message", message);
    });
    socket.emit("message", "Welcome to chat");
});

=======================================
| Assertion Testing - ассерты для тестирования
=======================================

const assert = require('assert');

assert(false, 'it is false'); // throws: AssertionError: it is false

assert.ok(false, 'it is false'); // throws: AssertionError: it is false

assert.equal({a: {b: 1}}, {a: {b: 1}}); // throws: AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

assert.strictEqual(1, '1'); // throws: AssertionError: 1 === '1'

assert.deepEqual({a: {b: 1}}, {a: {b: 2}}; // throws: AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepStrictEqual({a: 1}, {a: '1'}); // throws: AssertionError: { a: 1 } deepStrictEqual { a: '1' }

assert.fail(1, 2, undefined, '>'); // throws: AssertionError: 1 > 2

assert.fail(1, 2, 'whoops', '>'); // throws: AssertionError: whoops

assert.notEqual(1, 1); // throws: AssertionError: 1 != 1

assert.notStrictEqual(1, 1); // throws: AssertionError: 1 != 1

assert.notDeepEqual({a: {b: 1}}, {a: {b: 1}}); // throws: AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepStrictEqual({a: '1'}, {a: '1'}); // throws: AssertionError: { a: '1' } notDeepStrictEqual { a: '1' }

=======================================
| Buffer - буферы - массивы для двоичных данных
=======================================

const buf = Buffer.alloc(10); // <Buffer 00 00 00 00 00 00 00 00 00 00>

const buf = Buffer.alloc(10, 1); // <Buffer 01 01 01 01 01 01 01 01 01 01>

const buf = Buffer.from([1, 2, 3]); // <Buffer 01 02 03>

const buf = Buffer.from('test', 'utf8'); // <Buffer 74 65 73 74>

const buf = Buffer.from('hello world', 'ascii');

Варианты метода from:
- Buffer.from(array);
- Buffer.from(buffer);
- Buffer.from(arrayBuffer[, byteOffset [, length]]);
- Buffer.from(str[, encoding]);

const buf = Buffer.from([1, 2, 3]);
for (var b of buf) {
  console.log(b);
}
// Prints:
//   1
//   2
//   3

console.log(buf.toString('hex')); // prints: 68656c6c6f20776f726c64
console.log(buf.toString('base64')); // prints: aGVsbG8gd29ybGQ=

Варианты кодировок:
- 'ascii'
- 'utf8'
- 'utf16le'
- 'ucs2'
- 'base64'
- 'binary'
- 'hex'

const arr = new Uint16Array(20);
const buf = Buffer.from(arr.buffer, 0, 16);
console.log(buf.length); // Prints: 16

const buf = Buffer.from([1, 2, 3]); // <Buffer 01 02 03>
buf[1] = 5; // <Buffer 01 05 03>

console.log(buf.compare(buf)); // Prints: 0

console.log(buf1.equals(buf2)); // Prints: true

buf1.copy(buf2, 8, 16, 20);

const buf = Buffer.allocUnsafe(10);
buf.fill('h');
console.log(buf.toString()); // Prints: hhhhhhhhhh

const buf = Buffer.from('this is a buffer');

buf.indexOf('this'); // returns 0
buf.indexOf('is'); // returns 2

buf.lastIndexOf('this'); // returns 0
buf.lastIndexOf('buffer'); // returns 17

buf.includes('this'); // returns true

const buf = Buffer.from('buffer');
for (var key of buf.keys()) {
  console.log(key);
}
// prints:
//   0
//   1
//   2
//   3
//   4
//   5

Buffer.isBuffer(obj) // true или false

const buf = Buffer.alloc(1234);
console.log(buf.length); // Prints: 1234

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

const buf = Buffer.alloc(3, 1); // <Buffer 01 01 01>
buf.toJSON(); // {type: 'Buffer', data: [1, 1, 1]}

const buf = Buffer.from('buffer');
for (var value of buf.values()) {
  console.log(value);
}
// prints:
//   98
//   117
//   102
//   102
//   101
//   114

const buf = Buffer.allocUnsafe(256);
const len = buf.write('\u00bd + \u00bc = \u00be', 0);
console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`); // Prints: 12 bytes: 1/2 + 1/4 = 3/4


const buf = Buffer.alloc(3, 1); // <Buffer 01 01 01>
buf.inspect(); // <Buffer 01 01 01>

buffer.INSPECT_MAX_BYTES; // Default: 50

=======================================
| Child Processes - работа с окном командной строки и запуск дополнительных дочерних процессов Node.js
=======================================

child_process.exec() - асинхронно запускает окно командной строки и выполняет внутри него команду, передавая stdout и stderr в callback

function когда выполнение команды завершится.

child_process.execFile() - такой же как child_process.exec() за исключением того, что команда выполняется напрямую без запуска окна

командной строки.

child_process.execSync() - синхронная версия child_process.exec(), блокирующая Node.js event loop.

child_process.execFileSync() - синхронная версия child_process.execFile(), блокирующая Node.js event loop.

child_process.fork() - запускает новый отдельный процесс Node.js и открывает канал для передачи сообщений между родительским процессом

Node.js и дочерним процессом Node.js.

child_process.spawn() - асинхронно запускает дочерний процесс Node.js, передавая stdout и stderr в callback function когда выполнение

команды завершится.

child_process.spawnSync() - синхронная версия child_process.spawn(), блокирующая Node.js event loop до завершения выполнения дочернего

процесса.

Достыпные Events:
- on('data, function () {})
- on('close', function () {})
- on('disconnect', function () {})
- on('error', function () {})
- on('exit', function () {})
- on('message', function () {})

Методы:
- child.send(message[, sendHandle[, options]][, callback])

- child.connected
- child.disconnect()

- child.kill([signal])
- child.pid

- child.stderr
- child.stdin
- child.stdio
- child.stdout

Примеры:

const spawn = require('child_process').spawn;
const listProcess = spawn('ls', ['-lh', '/usr']);

listProcess.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

listProcess.stderr.on('data', (data) => {
  console.log(`stderr: ${data}`);
});

listProcess.on('close', (code) => {
  console.log(`child process exited with code ${code}`);
});

// Excute gulp task
var task = process.argv.slice(2).join(' ')
    , command = 'node ./node_modules/gulp/bin/gulp.js ' + task
    , childProcess = require('child_process').exec(command);
childProcess.stdout.on('data', function (data) {console.log(data);});
childProcess.stderr.on('data', function (data) {console.log(data);});
childProcess.on('data', function (code) {if (code === 0) {console.log('Done');} else {console.log('Exit code: ' + code);}});

// или

const exec = require('child_process').exec;
exec('cat *.js bad_file | wc -l', function (error, stdout, stderr) {
  if (error) {
    console.error(`exec error: ${error}`);
    return;
  }
  console.log(`stdout: ${stdout}`);
  console.log(`stderr: ${stderr}`);
});

// execFile

const execFile = require('child_process').execFile;
const child = execFile('node', ['--version'], function (error, stdout, stderr) {
  if (error) {
    throw error;
  }
  console.log(stdout);
});

=======================================
| Console - console.log() - вывод сообщений на консоль
=======================================

console.log('hello world'); // Prints: hello world, to stdout

console.log('hello %s', 'world'); // Prints: hello world, to stdout

console.info([data][, ...]) - тоже самое, что и console.log([data][, ...])

console.dir(obj[, options]) // печатает свойства объекта

console.trace('Show me'); // Prints: (stack trace will vary based on where trace is called)

const code = 5;

console.error('error #%d', code); // Prints: error #5, to stderr

console.error('error', code); // Prints: error 5, to stderr

console.warn([data][, ...]) - тоже самое, что и console.error([data][, ...])

console.assert(true, 'does nothing'); // OK

console.assert(false, 'Whoops %s', 'didn\'t work'); // AssertionError: Whoops didn't work

console.time('100-elements');

for (var i = 0; i < 100; i++) {}

console.timeEnd('100-elements'); // prints 100-elements: 225.438ms

=======================================
| Debugger - запуск отладчика debugger; в браузере для отладки скрипта Node.js
=======================================

Описание команд:

Команды перехода по коду:

cont, c - продолжить выполнения кода
next, n - перейти к следующему шагу
step, s - войти внутрь функции
out, o - выйти из функции
pause - поставить выполнение кода на паузу, как при нажатии на кнопку паузы в Chrome Developer Tools

Команды для расстановки точек остановок в коде:

setBreakpoint(), sb() - установить breakpoint на текущую линию кода
setBreakpoint(line), sb(line) - установить breakpoint конкретную линию кода
setBreakpoint('fn()'), sb(...) - установить breakpoint первую строчку внутри тела функции
setBreakpoint('script.js', 1), sb(...) - установить breakpoint первую строчку файлы script.js
clearBreakpoint('script.js', 1), cb(...) - удалить breakpoint в файле script.js с линии 1

// myscript.js

x = 5;
setTimeout(() => {
  debugger;
  console.log('world');
}, 1000);
console.log('hello');

// запуск отладки скрипта

$ node debug myscript.js

< debugger listening on port 5858
connecting... ok

break in /home/indutny/Code/git/indutny/myscript.js:1
  1 x = 5;
  2 setTimeout(() => {
  3   debugger;

debug> cont

< hello
break in /home/indutny/Code/git/indutny/myscript.js:3
  1 x = 5;
  2 setTimeout(() => {
  3   debugger;
  4   console.log('world');
  5 }, 1000);

debug> next

break in /home/indutny/Code/git/indutny/myscript.js:4
  2 setTimeout(() => {
  3   debugger;
  4   console.log('world');
  5 }, 1000);
  6 console.log('hello');

debug> repl

Press Ctrl + C to leave debug repl

> x
5
> 2+2
4

debug> next

< world
break in /home/indutny/Code/git/indutny/myscript.js:5
  3   debugger;
  4   console.log('world');
  5 }, 1000);
  6 console.log('hello');
  7

debug> quit

=======================================
| Events - события addListener(), removeListener(), emit()
=======================================

emitter.addListener(eventName, listener) - тоже самое, что и emitter.on(eventName, listener) - добавить событие

emitter.prependListener() - добавить событие в самое начало списка имеющихся событий

emitter.once(eventName, listener) - добавить событие, которое будет удалено сразу после его вызова

emitter.prependOnceListener() -  добавить событие в самое начало списка имеющихся событий, которое будет удалено сразу после его вызова

emitter.emit(eventName[, arg1][, arg2][, ...]) - синхронно вызвать функции привязанные к события в порядке их привязки с передачей в них

аргументов

emitter.removeListener(eventName) - удалить событие

emitter.removeAllListeners([eventName]) - удалить все события

emitter.eventNames() - вернуть массив существующих имен событий

emitter.listenerCount(eventName) - подсчитать число существующих событий

emitter.getMaxListeners() - получить предельно допустимое число возможных событий (по умолчанию 10)

emitter.setMaxListeners(n) - установить предельно допустимое число возможных событий

emitter.listeners(eventName) - получить массив с копией функций привязанных к событию

// Пример добавления событий

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on('event', function callback (a, b) {
  console.log(a, b, this);
    // Prints:
    //   a b MyEmitter {
    //     domain: null,
    //     _events: { event: [Function] },
    //     _eventsCount: 1,
    //     _maxListeners: undefined }
});

myEmitter.emit('event', 'a', 'b');

myEmitter.removeEvent('event', callback);

// метод on

const myEmitter = new MyEmitter();

var m = 0;

myEmitter.on('event', () => {
  console.log(++m);
});

myEmitter.emit('event'); // Prints: 1
myEmitter.emit('event'); // Prints: 2

// метод once

const myEmitter = new MyEmitter();

var m = 0;

myEmitter.once('event', () => {
  console.log(++m);
});

myEmitter.emit('event'); // Prints: 1
myEmitter.emit('event'); // Ignored

// Error event

const myEmitter = new MyEmitter();

myEmitter.emit('error', new Error('whoops!')); // Throws and crashes Node.js

=======================================
| Stream - end, read, write, pause, resume, pipe, unpipe
=======================================

const stream = require('stream');

Types of Streams:
- Readable - fs.createReadStream()
- Writable - fs.createWriteStream()
- Duplex - net.Socket
- Transform

Readable

readable.read([size])

readable.pause()
readable.resume()
readable.isPaused()

readable.pipe(destination[, options])
readable.unpipe([destination])

readable.setEncoding(encoding)

readable.wrap(stream)

readable.unshift(chunk)

Readable  Events
- 'close'
- 'data'
- 'end'
- 'error'
- 'readable'

Writable

writable.write(chunk[, encoding][, callback])
writable.end([chunk][, encoding][, callback])

writable.cork()
writable.uncork()

writable.setDefaultEncoding(encoding)

Writable Events
- 'close'
- 'drain'
- 'error'
- 'finish'
- 'pipe'
- 'unpipe'

=======================================
| File System - open, close, readFile, writeFile, appendFile unlink, stats, access, watch
=======================================

// Создать поток для чтения из файла
fs.createReadStream(path[, options])

// Создать поток для записи в файл
fs.createWriteStream(path[, options])

// Открыть файл
fs.open(path, flags[, mode], callback)

// Закрыть файл
fs.close(fd, callback)

// Прочитать файл
fs.read(fd, buffer, offset, length, position, callback)

// Асинхронно прочитать весь файл целиком
fs.readFile('/etc/passwd', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Прочитать содержимое директории
fs.readdir(path[, options], callback)

// Добавление текста в конец файла
fs.appendFile('message.txt', 'data to append', (err) => {
  if (err) throw err;
  console.log('The "data to append" was appended to file!');
});

// Усечь файл
fs.ftruncate(fd, len, callback)

// Записать данные в файл или создать новый файл
fs.write(fd, buffer, offset, length[, position], callback)
fs.write(fd, data[, position[, encoding]], callback)

// Записать данные в файл и заменить его на новый, если он уже существует
fs.writeFile(file, data[, options], callback)

// Переименовать файл
fs.rename(oldPath, newPath, callback)

// Проверить существует ли файл - deprecated
fs.exists('/etc/passwd', (exists) => {
  console.log(exists ? 'it\'s there' : 'no passwd!');
});

// Сведения о файлах
fs.stat()
fs.lstat()
fs.fstat()

stats.isFile()
stats.isDirectory()

stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() (only valid with fs.lstat())
stats.isFIFO()
stats.isSocket()

// Изменение атрибутов файла
fs.chmod(path, mode, callback)

// Изменение владельца файла
fs.chown(path, uid, gid, callback)

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

fs.access('/etc/passwd', fs.constants.R_OK | fs.constants.W_OK, (err) => {
  console.log(err ? 'no access!' : 'can read/write');
});

// Отслеживание изменений файлов
fs.watch('./tmp', {encoding: 'buffer'}, (eventType, filename) => {
  if (filename)
    console.log(filename);
    // Prints: <Buffer ...>
});

// Отслеживать изменения конкретного файла
fs.watchFile('message.text', (curr, prev) => {
  console.log(`the current mtime is: ${curr.mtime}`);
  console.log(`the previous mtime was: ${prev.mtime}`);
});

// Скопировать файл
fs.link(srcpath, dstpath, callback)

// Асинхронная версия удаления файла
const fs = require('fs');

fs.unlink('/tmp/hello', (err) => {
  if (err) throw err;
  console.log('successfully deleted /tmp/hello');
});

// Синхронная версия удаления файла
const fs = require('fs');

fs.unlinkSync('/tmp/hello');
console.log('successfully deleted /tmp/hello');

// Создать директорию
fs.mkdir(path[, mode], callback)

// Удалить директорию
fs.rmdir(path, callback)

=======================================
| Path
=======================================

const path = require('path');

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

path.win32..
path.posix..

path.delimiter
; for Windows
: for POSIX

path.sep
\ on Windows
/ on POSIX

// on POSIX:
'foo/bar/baz'.split(path.sep) // returns ['foo', 'bar', 'baz']

// on Windows:
'foo\\bar\\baz'.split(path.sep) // returns ['foo', 'bar', 'baz']

// on POSIX:
console.log(process.env.PATH) // '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin'
process.env.PATH.split(path.delimiter) // returns ['/usr/bin', '/bin', '/usr/sbin', '/sbin', '/usr/local/bin']

// on Windows:
console.log(process.env.PATH) // 'C:\Windows\system32;C:\Windows;C:\Program Files\node\'
process.env.PATH.split(path.delimiter) // returns ['C:\\Windows\\system32', 'C:\\Windows', 'C:\\Program Files\\node\\']

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

path.extname('index.html') // returns '.html'
path.extname('index.coffee.md') // returns '.md'
path.extname('index.') // returns '.'
path.extname('index') // returns ''
path.extname('.index') // returns ''

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

path.isAbsolute('/foo/bar') // true
path.isAbsolute('/baz/..')  // true
path.isAbsolute('qux/')     // false
path.isAbsolute('.')        // false
path.isAbsolute('//server')  // true
path.isAbsolute('C:/foo/..') // true
path.isAbsolute('bar\\baz')  // false
path.isAbsolute('.')         // false

ath.join('/foo', 'bar', 'baz/asdf', 'quux', '..') // returns '/foo/bar/baz/asdf'
path.join('foo', {}, 'bar') // throws TypeError: Arguments to path.join must be strings

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

// on POSIX:
path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb') // returns '../../impl/bbb'

// on Windows:
path.relative('C:\\orandea\\test\\aaa', 'C:\\orandea\\impl\\bbb') // returns '..\\..\\impl\\bbb'

path.resolve('/foo/bar', './baz') // returns '/foo/bar/baz'

path.resolve('/foo/bar', '/tmp/file/') // returns '/tmp/file'

path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif') // if the current working directory is /home/myself/node, this returns

'/home/myself/node/wwwroot/static_files/gif/image.gif'

// on POSIX:
┌───────────────────┬────────────┐
│                 dir              │         base       │
├──────┬                    ├─────┬──────┤
│   root   │                     │  name │   ext   │
│     /        home/user/dir  /   file       .txt   │
└──────┴───────────┴──────┴─────┘

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

on Windows:

┌───────────── ──┬────────────┐
│                 dir        │         base        │
├──────┬              ├──────┬─────┤
│   root   │              │  name   │   ext  │
│    C:\      path\dir   \   file         .txt  │
└──────┴──── ───┴──────┴─────┘

path.parse('C:\\path\\dir\\file.txt')
// returns
// {
//    root : "C:\\",
//    dir : "C:\\path\\dir",
//    base : "file.txt",
//    ext : ".txt",
//    name : "file"
// }

=======================================
| Globals - __driname, __filename, global, Buffer, process, setTimeout, clearTimweout, console, module, exports, require
=======================================

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

=======================================
| Modules - require, module, export, exports, name, id, parent, loaded
=======================================

require(X) from module at path Y
1. If X is a core module,
   a. return the core module
   b. STOP
2. If X begins with './' or '/' or '../'
   a. LOAD_AS_FILE(Y + X)
   b. LOAD_AS_DIRECTORY(Y + X)
3. LOAD_NODE_MODULES(X, dirname(Y))
4. THROW "not found"

LOAD_AS_FILE(X)
1. If X is a file, load X as JavaScript text.  STOP
2. If X.js is a file, load X.js as JavaScript text.  STOP
3. If X.json is a file, parse X.json to a JavaScript Object.  STOP
4. If X.node is a file, load X.node as binary addon.  STOP

LOAD_AS_DIRECTORY(X)
1. If X/package.json is a file,
   a. Parse X/package.json, and look for "main" field.
   b. let M = X + (json main field)
   c. LOAD_AS_FILE(M)
2. If X/index.js is a file, load X/index.js as JavaScript text.  STOP
3. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP
4. If X/index.node is a file, load X/index.node as binary addon.  STOP

LOAD_NODE_MODULES(X, START)
1. let DIRS=NODE_MODULES_PATHS(START)
2. for each DIR in DIRS:
   a. LOAD_AS_FILE(DIR/X)
   b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)
1. let PARTS = path split(START)
2. let I = count of PARTS - 1
3. let DIRS = []
4. while I >= 0,
   a. if PARTS[I] = "node_modules" CONTINUE
   c. DIR = path join(PARTS[0 .. I] + "node_modules")
   b. DIRS = DIRS + DIR
   c. let I = I - 1
5. return DIRS

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
});

module.filename
module.id
module.loaded
module.parent
module.require(id)

require.main === module

const circle = require('./circle.js');
console.log( `The area of a circle of radius 4 is ${circle.area(4)}`);

// assigning to exports will not modify module, must use module.exports
module.exports = (width) => {
  return {
    area: () => width * width
  };
}

=======================================
| OS - EOL, platform, type, cpus, homedir, tmpdir
=======================================

const os = require('os');

os.EOL
\n on POSIX
\r\n on Windows

os.endianness()
'BE' for big endian
'LE' for little endian.

os.arch() - тоже самое, что и process.arch
// 'arm', 'arm64', 'ia32', 'mips', 'mipsel', 'ppc', 'ppc64', 's390', 's390x', 'x32', 'x64', 'x86'

os.platform() - тоже самое, что и process.platform
// 'aix', 'darwin', 'freebsd', 'linux', 'openbsd', 'sunos', 'win32'

os.type() // 'Linux' on Linux, 'Darwin' on OS X, 'Windows_NT' on Windows

os.release()

os.constants

os.cpus()

os.freemem() - число доступных байт системной памяти

os.totalmem() - общее число байт системной памяти

os.homedir() - домашняя директория в операционной системе

os.tmpdir() - директория для временных файлов в операционной системе

os.loadavg()

os.uptime()

os.networkInterfaces()
{
    address: '127.0.0.1',
    netmask: '255.0.0.0',
    family: 'IPv4',
    mac: '00:00:00:00:00:00',
    internal: true
}

OS Constants:
- Signal Constants
- Error Constants
- POSIX Error Constants
- Windows Specific Error Constants
- libuv Constants

=======================================
| Process - argv, nextTick, exit, abort, stdin, stdout, stderr, chdir, cwd, env, hrtime
=======================================

process - это глобальный объект, экземляр Event Emitter, предоставляющий информацию и контролирующий текущий процесс работы Node.js

process.stdin

process.stdin.setEncoding('utf8');

process.stdin.on('readable', () => {
  var chunk = process.stdin.read();
  if (chunk !== null) {
    process.stdout.write(`data: ${chunk}`);
  }
});

process.stdin.on('end', () => {
  process.stdout.write('end');
});

process.stdout

console.log = (msg) => {
  process.stdout.write(`${msg}\n`);
};

process.stderr

process.nextTick(callback[, arg][, ...])

console.log('start');
process.nextTick(() => {
  console.log('nextTick callback');
});
console.log('scheduled');
// Output:
// start
// scheduled
// nextTick callback

process.exit(1)

if (someConditionNotMet()) {
  printUsageToStdout();
  process.exit(1);
}

process.exitCode

process.kill(pid[, signal])

process.kill(process.pid, 'SIGHUP');

process.getegid()

if (process.getegid) {
  console.log(`Current gid: ${process.getegid()}`);
}

process.geteuid()

process.getgid()

process.pid

process.title

process.abort()

process.argv

$ node process-2.js one two=three four

process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
});

$ node --harmony script.js --version
['/usr/local/bin/node', 'script.js', '--version']

process.execArgv

$ node --harmony script.js --version
['--harmony']

process.execPath // /usr/local/bin/node

process.stdin.resume();

process.chdir(directory)

process.cwd()
console.log(`Current directory: ${process.cwd()}`);

process.chdir('/tmp');
console.log(`Starting directory: ${process.cwd()}`);
try {
  process.chdir('/tmp');
  console.log(`New directory: ${process.cwd()}`);
}
catch (err) {
  console.log(`chdir: ${err}`);
}

process.hrtime([time])

var time = process.hrtime(); // [ 1800216, 25 ]

process.uptime()

process.versions
{
  http_parser: '2.3.0',
  node: '1.1.1',
  v8: '4.1.0.14',
  uv: '1.3.0',
  zlib: '1.2.8',
  ares: '1.10.0-DEV',
  modules: '43',
  icu: '55.1',
  openssl: '1.0.1k'
}

process.config

process.connected

process.disconnect()

process.arch

process.platform

process.cpuUsage([previousValue])

const startUsage = process.cpuUsage(); // { user: 38579, system: 6986 }

process.release

process.env
{
  TERM: 'xterm-256color',
  SHELL: '/usr/local/bin/bash',
  USER: 'maciej',
  PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
  PWD: '/Users/maciej',
  EDITOR: 'vim',
  SHLVL: '1',
  HOME: '/Users/maciej',
  LOGNAME: 'maciej',
  _: '/usr/local/bin/node'
}
process.env.foo = 'bar';
console.log(process.env.foo);

process.env.test = null;
console.log(process.env.test); // => 'null'

process.env.test = undefined;
console.log(process.env.test); // => 'undefined'

process.env.TEST = 1;
delete process.env.TEST;
console.log(process.env.TEST); // => undefined

process.mainModule

process.memoryUsage()

process.send(message[, sendHandle[, options]][, callback])

process.on('exit', (code) => {
  console.log(`About to exit with code: ${code}`);
});

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

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

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

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

const unhandledRejections = new Map();
process.on('unhandledRejection', (reason, p) => {
  unhandledRejections.set(p, reason);
});

process.on('rejectionHandled', (p) => {
  unhandledRejections.delete(p);
});

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

process.on('uncaughtException', (err) => {
  fs.writeSync(1, `Caught exception: ${err}`);
});

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

process.on('warning', (warning) => {
  console.warn(warning.name);    // Print the warning name
  console.warn(warning.message); // Print the warning message
  console.warn(warning.stack);   // Print the stack trace
});


process.emitWarning('Something happened!'); // Prints: (node 12345) Warning: Something happened!
process.emitWarning('This API is deprecated', 'DeprecationWarning');

Signal Events

process.on('SIGINT', () => {
  console.log('Received SIGINT.  Press Control-D to exit.');
});

=======================================
| HTTP - request, createServer, request, response, writeHead, write, end, setHeader, getHeader, removeHeader
=======================================

http.request(options[, callback])

http.createClient([port][, host])

http.createServer([requestListener])

http.globalAgent

http.get(options[, callback])

http.METHODS

http.STATUS_CODES

http.Agent
new Agent([options])

agent.createConnection(options[, callback])

agent.destroy()

agent.freeSockets

agent.getName(options)

agent.maxFreeSockets

agent.maxSockets

agent.requests

agent.sockets

http.ClientRequest

on('abort', function(){})
on('aborted', function(){})
on('checkExpectation', function(){})
on('connect', function(){})
on('continue', function(){})
on('response', function(){})
on('socket', function(){})
on('upgrade', function(){})

request.write(chunk[, encoding][, callback])

request.end([data][, encoding][, callback])

request.abort()

request.flushHeaders()

request.setNoDelay([noDelay])

request.setSocketKeepAlive([enable][, initialDelay])

request.setTimeout(timeout[, callback])

http.Server

on('checkContinue', function(){})
on('clientError', function(){})
on('close', function(){})
on('connect', function(){})
on('connection', function(){})
on('request', function(){})
on('upgrade', function(){})

server.listen(handle[, callback])
server.listen(path[, callback])
server.listen(port[, hostname][, backlog][, callback])

server.listening

server.close([callback])

server.maxHeadersCount

server.setTimeout(msecs, callback)

server.timeout

http.ServerResponse

on('close', function(){})
on('finish', function(){})

response.writeHead(statusCode[, statusMessage][, headers])
response.writeHead(200, {
  'Content-Length': Buffer.byteLength(body),
  'Content-Type': 'text/plain' });

response.write(chunk[, encoding][, callback])

response.end([data][, encoding][, callback])

response.setHeader(name, value)
response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);

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

response.removeHeader(name)
response.removeHeader('Content-Encoding');

response.headersSent

response.setTimeout(msecs, callback)

response.statusCode
response.statusCode = 404;

response.statusMessage
response.statusMessage = 'Not found';

response.addTrailers(headers)

response.finished

response.sendDate

response.writeContinue()

http.IncomingMessage

on('aborted', function(){})
on('close', function(){})

message.headers

message.rawHeaders

message.setTimeout(msecs, callback)

message.statusCode

message.httpVersion

message.destroy([error])

message.method

message.rawTrailers

message.statusMessage

message.socket

message.trailers

message.url

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

// Create an HTTP tunneling proxy
var proxy = http.createServer( (req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('okay');
});
proxy.on('connect', (req, cltSocket, head) => {
  // connect to an origin server
  var srvUrl = url.parse(`http://${req.url}`);
  var srvSocket = net.connect(srvUrl.port, srvUrl.hostname, () => {
    cltSocket.write('HTTP/1.1 200 Connection Established\r\n' +
                    'Proxy-agent: Node.js-Proxy\r\n' +
                    '\r\n');
    srvSocket.write(head);
    srvSocket.pipe(cltSocket);
    cltSocket.pipe(srvSocket);
  });
});

// now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {

  // make a request to a tunneling proxy
  var options = {
    port: 1337,
    hostname: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80'
  };

  var req = http.request(options);
  req.end();

  req.on('connect', (res, socket, head) => {
    console.log('got connected!');

    // make a request over an HTTP tunnel
    socket.write('GET / HTTP/1.1\r\n' +
                 'Host: www.google.com:80\r\n' +
                 'Connection: close\r\n' +
                 '\r\n');
    socket.on('data', (chunk) => {
      console.log(chunk.toString());
    });
    socket.on('end', () => {
      proxy.close();
    });
  });
});

// ------------------------------------

const http = require('http');

// Create an HTTP server
var srv = http.createServer( (req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('okay');
});
srv.on('upgrade', (req, socket, head) => {
  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
               'Upgrade: WebSocket\r\n' +
               'Connection: Upgrade\r\n' +
               '\r\n');

  socket.pipe(socket); // echo back
});

// now that server is running
srv.listen(1337, '127.0.0.1', () => {

  // make a request
  var options = {
    port: 1337,
    hostname: '127.0.0.1',
    headers: {
      'Connection': 'Upgrade',
      'Upgrade': 'websocket'
    }
  };

  var req = http.request(options);
  req.end();

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!');
    socket.end();
    process.exit(0);
  });
});

// ----------------------------------------

const http = require('http');

const server = http.createServer((req, res) => {
  res.end();
});
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
});
server.listen(8000);

// ---------------------------------------

const server = http.createServer((req,res) => {
  res.setHeader('Content-Type', 'text/html');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('ok');
});

// -------------------------------------------------------

var postData = querystring.stringify({
  'msg' : 'Hello World!'
});

var options = {
  hostname: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': Buffer.byteLength(postData)
  }
};

var req = http.request(options, (res) => {
  console.log(`STATUS: ${res.statusCode}`);
  console.log(`HEADERS: ${JSON.stringify(res.headers)}`);
  res.setEncoding('utf8');
  res.on('data', (chunk) => {
    console.log(`BODY: ${chunk}`);
  });
  res.on('end', () => {
    console.log('No more data in response.');
  });
});

req.on('error', (e) => {
  console.log(`problem with request: ${e.message}`);
});

// write data to request body
req.write(postData);
req.end();

=======================================
| HTTPS -
=======================================

https.request(options, callback)

https.createServer(options[, requestListener])

https.Agent

https.Server

server.setTimeout(msecs, callback)

server.timeout

server.close([callback])

server.listen(handle[, callback])
server.listen(path[, callback])
server.listen(port[, host][, backlog][, callback])

https.get(options, callback)

https.globalAgent

// ---------------------------------------------

// curl -k https://localhost:8000/
const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('hello world\n');
}).listen(8000);

// ---------------------------------------------

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

const options = {
  pfx: fs.readFileSync('server.pfx')
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('hello world\n');
}).listen(8000);

// ---------------------------------------------

const https = require('https');

https.get('https://encrypted.google.com/', (res) => {
  console.log('statusCode: ', res.statusCode);
  console.log('headers: ', res.headers);

  res.on('data', (d) => {
    process.stdout.write(d);
  });

}).on('error', (e) => {
  console.error(e);
});

// ---------------------------------------------

const https = require('https');

var options = {
  hostname: 'encrypted.google.com',
  port: 443,
  path: '/',
  method: 'GET'
};

var req = https.request(options, (res) => {
  console.log('statusCode: ', res.statusCode);
  console.log('headers: ', res.headers);

  res.on('data', (d) => {
    process.stdout.write(d);
  });
});
req.end();

req.on('error', (e) => {
  console.error(e);
});

// ---------------------------------------------

var options = {
  hostname: 'encrypted.google.com',
  port: 443,
  path: '/',
  method: 'GET',
  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
};
options.agent = new https.Agent(options);

var req = https.request(options, (res) => {
  ...
});

=======================================
| Timers - setTimeout, setInterval, setImmediate, ref, unref
=======================================

var timeout = setTimeout(function(){}, 5000[, ...arg])
clearTimeout(timeout)

var interval = setInterval(function(){}, 5000[, ...arg])
clearInterval(interval )

var immediate = setImmediate(function(){}[, ...arg])
clearImmediate(immediate)

timeout.ref()

timeout.unref()

=======================================
| URL - парсинг урлов
=======================================

http://user:pass@host.com:8080/p/a/t/h?query=string#hash

┌───────────────────────────────────────────────────────────┐
│                                                        href                                               │
├───── ─┬┬─────── ┬─────────────┬───────────────────┬──────┤
│ protocol ││   auth      │           host       │               path                │ hash   │
│             ││               ├─────────────┼───── ───┬──────────┤          │
│             ││               │ hostname │ port │ pathname │     search      │           │
│             ││               │               │        │               ├┬──────── ─┤          │
│             ││               │               │        │               │ │    query       │          │
│ http:      // user:pass @ host.com : 8080     /p/a/t/h   ?  query=string   #hash │
│             ││               │               │        │               │ │                   │         │
└───────┴┴─── ────┴────────┴────┴────── ─┴┴──────────┴─────┘

const url = require('url');

urlObject.href // 'http://user:pass@host.com:8080/p/a/t/h?query=string#hash'
urlObject.protocol // 'http:'
urlObject.slashes // true
urlObject.host // 'host.com:8080'
urlObject.auth // 'user:pass
urlObject.hostname // 'host.com'
urlObject.port // '8080'
urlObject.pathname // '/p/a/t/h'
urlObject.search // ?query=string'
urlObject.path // '/p/a/t/h?query=string'
urlObject.query // 'query=string' или {'query': 'string'}
urlObject.hash '#hash'

url.format(urlObject) // возвращает отформатированную строку в адресом
url.parse(urlString[, parseQueryString[, slashesDenoteHost]]) // берет строку с адресом и превращает её в объект URL object
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'

Пробелы и знаки < > " ` \r \n \t { } | \ ^ ' автоматически будут заэскейплены.

=======================================
| Query String - парсинг строки с параметрами из URL
=======================================

const querystring = require('querystring');

querystring.escape(str) // эскейпит строку символами с процентом

querystring.unescape(str) // анэскейпит (деколдирует) строку, содержащую символы с процентами

querystring.parse(str[, sep[, eq[, options]]]) // превращает строку с параметрами в объект

querystring.parse('foo=bar&abc=xyz&abc=123', '&', '=', {decodeURIComponent: querystring.unescape, maxKeys: 1000}) // {foo: 'bar', abc: ['xyz',

'123']}

querystring.stringify(obj[, sep[, eq[, options]]]) // преваращает объект с параметрами в строку

querystring.stringify({foo: 'bar', abc: ['xyz', '123']}, '&', '=', {encodeURIComponent: querystring.escape}) // 'foo=bar&abc=xyz&abc=123'
querystring.stringify({foo: 'bar', baz: ['qux', 'quux'], corge: ''}) // 'foo=bar&baz=qux&baz=quux&corge='
querystring.stringify({foo: 'bar', baz: 'qux'}, ';', ':') // 'foo:bar;baz:qux'

=======================================
| Utilities - утилиты format, debuglog, deprecate, inspect
=======================================

// debuglog()

const util = require('util');

const debuglog = util.debuglog('foo');

debuglog('hello from foo [%d]', 123); // Если программа запущена с ключом NODE_DEBUG=foo, то в консоли будет выведено FOO 3245: hello

from foo [123] иначе функция не выведен ничего

// deprecate()

const util = require('util');

exports.puts = util.deprecate(function() {
  for (var i = 0, len = arguments.length; i < len; ++i) {
    process.stdout.write(arguments[i] + '\n');
  }
}, 'util.puts: Use console.log instead'); // Выведет в консоли сообщение util.puts: Use console.log instead

// format()

Типы форматов:

%s - string
%d - number (integer и float).
%j - JSON
%% - символ '%'

util.format('%s:%s', 'foo'); // Returns 'foo:%s'

util.format('%s:%s', 'foo', 'bar', 'baz'); // 'foo:bar baz'

util.format(1, 2, 3); // '1 2 3'

// inspect()

console.log(util.inspect(util, { showHidden: true, depth: null })); // выведет структуру всех свойст объекта

// Custom inspect()

const util = require('util');

const obj = { name: 'nate' };

obj.inspect = function(depth) {
  return `{${this.name}}`;
};

util.inspect(obj); // "{nate}"

=======================================
| StringDecoder - декодирование объекта Buffer в строку
=======================================

new StringDecoder([encoding])
stringDecoder.end([buffer])
stringDecoder.write(buffer)

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));