Node.js изнутри: Рантайм, архитектура и исходный код

// Блокирующий ввод-вывод (синхронный)
const data = fs.readFileSync('/path/to/file');
console.log(data);
// Следующая строка выполнится только после чтения файла
 
// Неблокирующий ввод-вывод (асинхронный)
fs.readFile('/path/to/file', (err, data) => {
  console.log(data);
});
// Следующая строка выполнится немедленно, не ожидая чтения файла

// Это заблокирует event loop на несколько секунд!
function longComputation() {
  let sum = 0;
  for(let i = 0; i < 1e10; i++) {
    sum += i;
  }
  return sum;
}
console.log(longComputation()); // Все остальные запросы будут ждать

let data;
fs.readFile('/path/to/file', (err, fileData) => {
  data = fileData;
});
console.log(data); // Undefined! Файл еще не прочитан

// В JavaScript
const buf = Buffer.alloc(1024);
 
// В C++ этот буфер представлен как:
// char* data = (char*) malloc(1024);
// Данные не копируются между JS и C++!

// main.js
const { Worker } = require('worker_threads');
 
const worker = new Worker('./worker.js');
worker.on('message', (result) => {
  console.log('Результат:', result);
});
worker.postMessage({ data: someComplexData });

Promise.resolve().then(() => console.log('Это микрозадача'));
setTimeout(() => console.log('Это макрозадача'), 0);
// Вывод: сначала 'Это микрозадача', потом 'Это макрозадача'

async function processLines() {
  const stream = fs.createReadStream('file.txt');
  const rl = readline.createInterface({ input: stream });
  
  for await (const line of rl) {
    // Обработка строки
  }
}

console.log('1 - Синхронный код');
 
setTimeout(() => {
  console.log('2 - Макрозадача (setTimeout)');
}, 0);
 
Promise.resolve()
  .then(() => {
    console.log('3 - Микрозадача (Promise)');
    process.nextTick(() => {
      console.log('4 - Микрозадача (nextTick внутри Promise)');
    });
  });
 
process.nextTick(() => {
  console.log('5 - Микрозадача (nextTick)');
});
 
console.log('6 - Синхронный код');

1 - Синхронный код
6 - Синхронный код
5 - Микрозадача (nextTick)
3 - Микрозадача (Promise)
4 - Микрозадача (nextTick внутри Promise)
2 - Макрозадача (setTimeout)

Promise.resolve().then(() => console.log('Промис'));
process.nextTick(() => console.log('nextTick'));
// Вывод:
// nextTick
// Промис

function recurNextTick() {
  process.nextTick(() => {
    console.log('Бесконечный nextTick!');
    recurNextTick();  // Рекурсивно добавляем еще задачи
  });
}
recurNextTick();
// Event loop никогда не дойдет до фазы Poll для обработки I/O!

async function riskyOperation() {
  // Что-то пошло не так
  throw new Error('Ой!');
}
 
// Плохо: ошибка не будет поймана
setTimeout(() => {
  riskyOperation();  // Ошибка выбросится в следующей итерации event loop
}, 0);
 
// Хорошо: промис позволяет поймать ошибку
setTimeout(() => {
  riskyOperation().catch(err => console.error('Поймали:', err.message));
}, 0);

function updateDatabase(data) {
  // Обновляем БД
  db.save(data);
  
  // Это выполнится только после текущего синхронного кода
  process.nextTick(() => {
    emitEvents();  // Извещаем подписчиков об изменениях
  });
}

// Внутри I/O цикла
fs.readFile('file.txt', () => {
  setTimeout(() => console.log('setTimeout'), 0);
  setImmediate(() => console.log('setImmediate'));
});
// setImmediate выполнится перед setTimeout!
 
// Но вне I/O цикла порядок не гарантирован:
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));
// Результат непредсказуем

let value = 0;
Promise.resolve().then(() => { value = 1; });
console.log(value);  // 0, а не 1, как могли бы ожидать некоторые

function fetchData() {
  fs.readFile('/несуществующий/путь', (err, data) => {
    if (err) {
      // Стек вызовов здесь начинается с этого коллбэка,
      // а не с места вызова fetchData()
      console.error(err);
      // Стектрейс покажет только: fs.readFile -> коллбэк
      // Но не покажет, кто вызвал fetchData()!
    }
  });
}
 
function startApp() {
  fetchData();  // Это место не будет видно в стектрейсе ошибки
}
 
startApp();

function fetchData() {
  return fs.promises.readFile('/несуществующий/путь')
    .catch(err => {
      // Здесь мы можем обработать ошибку
      // или пробросить её дальше
      throw err;  // Пробрасываем ошибку вверх по цепочке промисов
    });
}
 
async function startApp() {
  try {
    await fetchData();
  } catch (err) {
    // Теперь мы можем поймать ошибку здесь!
    console.error('Ошибка в startApp:', err);
  }
}
 
startApp();

const asyncHooks = require('async_hooks');
const fs = require('fs');
 
// Хранилище для контекстов
const store = new Map();
 
// Создаем hook
const hook = asyncHooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    // Копируем контекст от родительской операции
    if (store.has(triggerAsyncId)) {
      store.set(asyncId, store.get(triggerAsyncId));
    }
  },
  destroy(asyncId) {
    // Удаляем контекст при завершении
    store.delete(asyncId);
  }
});
hook.enable();
 
// Теперь можем сохранять контекст
function withContext(fn, context) {
  const asyncId = asyncHooks.executionAsyncId();
  store.set(asyncId, context);
  return fn();
}
 
// Использование
withContext(() => {
  // Контекст: { route: '/api/users' }
  fs.readFile('/path', (err, data) => {
    // Контекст всё ещё доступен здесь!
    const myContext = store.get(asyncHooks.executionAsyncId());
    console.log('Route:', myContext.route);  // '/api/users'
  });
}, { route: '/api/users' });

// Для синхронных ошибок и исключений
process.on('uncaughtException', (err, origin) => {
  console.error('Необработаное исключение:', err);
  console.error('Источник:', origin);
  // Рекомендуется завершить процесс после логирования
  process.exit(1);
});
 
// Для ошибок в непойманных промисах
process.on('unhandledRejection', (reason, promise) => {
  console.error('Непойманое отклонение промиса:', reason);
  // В будущих версиях Node.js это может завершать процесс!
});

function MyError() {
  Error.captureStackTrace(this, MyError);
  // Исключит эту функцию из стека
}
 
// Ручное создание стектрейса
const stack = {};
Error.captureStackTrace(stack);
console.log(stack.stack);  // Выведет текущий стек

const start = Date.now();
setTimeout(() => {
  console.log(`Прошло ${Date.now() - start} мс`);
}, 100);
 
// Блокируем event loop на 500 мс
for (let i = 0; i < 1e9; i++) {}

fs.readFile('file.txt', () => {
  setTimeout(() => console.log('timeout'), 0);
  setImmediate(() => console.log('immediate'));
});
// Вывод всегда будет:
// immediate
// timeout

setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
// Порядок вывода может быть любым!

setTimeout(() => {
  console.log('внешний setTimeout');
  setImmediate(() => console.log('setImmediate внутри setTimeout'));
  setTimeout(() => console.log('вложенный setTimeout'), 0);
}, 0);

// Исходный код
function add(a, b) {
  return a + b;
}
 
// Преобразуется в AST (упрощенно):
// {
//   type: "FunctionDeclaration",
//   id: { type: "Identifier", name: "add" },
//   params: [
//     { type: "Identifier", name: "a" },
//     { type: "Identifier", name: "b" }
//   ],
//   body: {
//     type: "BlockStatement",
//     body: [{
//       type: "ReturnStatement",
//       argument: {
//         type: "BinaryExpression",
//         operator: "+",
//         left: { type: "Identifier", name: "a" },
//         right: { type: "Identifier", name: "b" }
//       }
//     }]
//   }
// }

function Point(x, y) {
  this.x = x;
  this.y = y;
}
 
// V8 создаст один hidden class для обоих объектов
const p1 = new Point(1, 2);
const p2 = new Point(3, 4);
 
// Но если добавить новое свойство, V8 создаст новый hidden class
p1.z = 5; // Теперь p1 и p2 имеют разные hidden classes

// Эта функция станет "горячей" при многократном вызове
function sumArray(arr) {
  let sum = 0;
  for (let i = 0; i < arr.length; i++) {
    sum += arr[i];
  }
  return sum;
}
 
// Многократный вызов делает функцию кандидатом на оптимизацию
for (let i = 0; i < 10000; i++) {
  sumArray([1, 2, 3, 4, 5]);
}

function add(a, b) {
  return a + b;
}
 
// V8 оптимизирует add() как функцию для сложения чисел
for (let i = 0; i < 10000; i++) {
  add(i, i + 1);
}
 
// Внезапно используем для строк - произойдет деоптимизация!
add("Hello, ", "world");

// Плохо для JIT: полиморфный код
function badForJIT(value) {
  if (typeof value === 'number') return value * 2;
  if (typeof value === 'string') return value.repeat(2);
  return null;
}
 
// Лучше для JIT: монофорфный код
function doubleNumber(num) {
  return num * 2;
}
function doubleString(str) {
  return str.repeat(2);
}

// Этот объект попадет в молодое поколение
let tempObj = { data: new Array(100).fill('temporary') };
tempObj = null; // Объект станет доступным для сборки мусора

// Принудительная сборка мусора (только с флагом --expose-gc)
global.gc(); // Не используйте в продакшн-коде!
 
// Вывести статистику использования памяти
console.log(process.memoryUsage());
// Результат: { rss: 30236672, heapTotal: 6537216, heapUsed: 3764904, ... }

let leakedData;
 
function badCache() {
  const largeData = new Array(1000000).fill('x');
  leakedData = function() { return largeData; };
}
 
badCache(); // largeData теперь не может быть собран GC, даже если не используется

function setupHandler(emitter) {
  const processData = (data) => {
    // Обработка данных
  };
  
  emitter.on('data', processData);
  // Забыли вернуть функцию для удаления обработчика!
}

function createCycle() {
  const objA = {};
  const objB = {};
  objA.ref = objB;
  objB.ref = objA;
  return objA; // objB остается в памяти, даже если не используется напрямую
}

// Стриминг вместо полной загрузки в память
fs.createReadStream('bigfile.txt')
  .pipe(new Transform({
    transform(chunk, encoding, callback) {
      // Обработка чанками
      this.push(processChunk(chunk));
      callback();
    }
  }))
  .pipe(fs.createWriteStream('output.txt'));

function Person(name, age) {
this.name = name;
this.age = age;
}
 
const person1 = new Person('Alice', 25);
const person2 = new Person('Bob', 30);

function getAgeMultipleTimes(person) {
// При первом вызове: поиск свойства "age" в объекте
// При последующих вызовах: прямой доступ по смещению в памяти
return person.age;
}
 
for (let i = 0; i < 1000; i++) {
getAgeMultipleTimes(person1);
}

const person3 = new Person('Charlie', 35);
person3.height = 180; // Создает новый скрытый класс C3!
 
// Вызов с объектом нового скрытого класса приведет к деоптимизации
getAgeMultipleTimes(person3);

// Мономорфный (быстрый) - все объекты одного типа
function monomoprhic(person) {
return person.age;
}
 
// Полиморфный (медленнее) - два разных типа объектов
function polymorphic(obj) {
if (obj instanceof Person) return obj.age;
if (obj instanceof User) return obj.age;
}
 
// Мегаморфный (самый медленный) - много разных типов
function megamorphic(anyObj) {
return anyObj.id; // Обращение к сотням разных объектов
}

// Может быть медленнее из-за создания уникальных скрытых классов
const user1 = { name: 'Alice', score: 10 };
const user2 = { score: 20, name: 'Bob' }; // Другой порядок свойств!
 
// Быстрее благодаря консистентным скрытым классам
class User {
constructor(name, score) {
  this.name = name;
  this.score = score;
}
}
const user3 = new User('Alice', 10);
const user4 = new User('Bob', 20);

// Пример того, как libuv используется в Node.js для работы с файлами
fs.readFile('/path/to/file', (err, data) => {
  if (err) throw err;
  console.log(data);
});
// В это время основной поток продолжает работу

// Прямой доступ к файловым дескрипторам в Node.js
const fs = require('fs');
 
// Открываем файл и получаем дескриптор
fs.open('example.txt', 'r', (err, fd) => {
  if (err) throw err;
  
  // Используем дескриптор для чтения
  const buffer = Buffer.alloc(1024);
  fs.read(fd, buffer, 0, buffer.length, 0, (err, bytesRead) => {
    if (err) throw err;
    console.log(buffer.slice(0, bytesRead).toString());
    
    // Важно закрывать дескрипторы!
    fs.close(fd, (err) => {
      if (err) throw err;
    });
  });
});

// Анти-паттерн: использование закрытого дескриптора
let globalFd;
 
fs.open('config.json', 'r', (err, fd) => {
  globalFd = fd; // Сохраняем дескриптор
  fs.close(fd, () => {}); // Закрываем его
});
 
// Позже - ошибка: использование закрытого дескриптора
setTimeout(() => {
  fs.read(globalFd, Buffer.alloc(10), 0, 10, 0, (err) => {
    // Здесь будет ошибка!
  });
}, 1000);

// Node.js может эффективно обрабатывать тысячи подключений
for (let i = 0; i < 10000; i++) {
  const client = net.connect(8000, 'localhost');
  client.on('data', data => {
    // Обработка ответа
  });
  client.write('Привет от клиента ' + i);
}

const dgram = require('dgram');
const server = dgram.createSocket('udp4');
 
server.on('message', (msg, rinfo) => {
  console.log(`Получено сообщение от ${rinfo.address}:${rinfo.port}: ${msg}`);
});
 
server.bind(8000);

// Анти-паттерн: необработанное закрытие соединения
const socket = net.connect(80, 'example.com');
socket.write('GET / HTTP/1.1\r\n\r\n');
// Что если соединение закроется до получения ответа?

const server = net.createServer();
server.on('connection', socket => {
  // Отключаем алгоритм Нейгла для уменьшения задержек
  socket.setNoDelay(true);
  // Устанавливаем размер буфера
  socket.setRecvBufferSize(65536);
});

// Node.js HTTP-сервер
const http = require('http');
const server = http.createServer((req, res) => {
  res.end('Hello World');
});
server.listen(8000);

// Эта операция выполняется в пуле потоков
fs.readFile('/path/to/big/file', (err, data) => {
  // Этот коллбэк выполнится в главном потоке,
  // когда рабочий поток завершит чтение
});

// Это заблокирует весь сервер!
function calculatePiDigits(digits) {
  // Тяжелые вычисления...
  return result;
}
app.get('/pi', (req, res) => {
  const result = calculatePiDigits(1000000);
  res.send(result);
});

const { Worker, isMainThread, parentPort } = require('worker_threads');
 
if (isMainThread) {
  // Код в основном потоке
  const worker = new Worker(__filename);
  worker.on('message', result => {
    console.log('Результат:', result);
  });
  worker.postMessage(1000000);
} else {
  // Код в рабочем потоке
  parentPort.on('message', digits => {
    const result = calculatePiDigits(digits);
    parentPort.postMessage(result);
  });
}

// В основном потоке
const buffer = new SharedArrayBuffer(1024);
const view = new Uint8Array(buffer);
view[0] = 123;
worker.postMessage({ buffer });
 
// В рабочем потоке
parentPort.on('message', data => {
  const view = new Uint8Array(data.buffer);
  console.log(view[0]); // 123
  view[0] = 42; // Это значение увидит основной поток!
});

Atomics.add(sharedInt32Array, 0, 1); // Атомарно увеличивает значение
Atomics.wait(sharedInt32Array, 0, 0); // Блокирует до изменения значения
Atomics.notify(sharedInt32Array, 0, 1); // Разблокирует ожидающие потоки

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
 
if (cluster.isMaster) {
  console.log(`Мастер-процесс ${process.pid} запущен`);
 
  // Создаем рабочие процессы
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
 
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Рабочий процесс ${worker.process.pid} завершился`);
    // Можно запустить новый процес вместо умершего
    cluster.fork();
  });
} else {
  // Рабочие процессы могут совместно использовать TCP-соединение
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Привет от процесса ${process.pid}\n`);
  }).listen(8000);
 
  console.log(`Рабочий процесс ${process.pid} запущен`);
}

// Явное указание алгоритма балансировки
cluster.schedulingPolicy = cluster.SCHED_RR; // Round-Robin
// или
cluster.schedulingPolicy = cluster.SCHED_NONE; // Эвристический

// Передача сообщений между процессами
if (cluster.isMaster) {
  // В мастер-процессе
  cluster.on('message', (worker, message) => {
    console.log(`Получено от рабочего ${worker.id}:`, message);
    // Можно передать сообщение другим рабочим
    for (const id in cluster.workers) {
      cluster.workers[id].send({ cmd: 'update', data: message.data });
    }
  });
} else {
  // В рабочем процессе
  process.on('message', (msg) => {
    if (msg.cmd === 'update') {
      // Обновляем локальное состояние
      localCache = msg.data;
    }
  });
  
  // Отправляем сообщение мастеру
  process.send({ data: 'some updated data' });
}

if (cluster.isMaster) {
  // Обработчик сигнала SIGUSR2 для горячего перезапуска
  process.on('SIGUSR2', () => {
    console.log('Получен сигнал для обновления рабочих процессов');
    
    // Сохраняем старых рабочих
    const oldWorkers = Object.values(cluster.workers);
    
    // Запускаем новых рабочих
    for (let i = 0; i < oldWorkers.length; i++) {
      cluster.fork();
    }
    
    // После запуска новых, постепенно завершаем старых
    oldWorkers.forEach(worker => {
      worker.disconnect();
      setTimeout(() => {
        if (worker.exitedAfterDisconnect !== true) {
          worker.kill();
        }
      }, 5000);
    });
  });
}

const { spawn } = require('child_process');
const ls = spawn('ls', ['-la']);
 
ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});
 
ls.stderr.on('data', (data) => {
  console.error(`stderr: ${data}`);
});
 
ls.on('close', (code) => {
  console.log(`процесс завершился с кодом ${code}`);
});

const { exec } = require('child_process');
exec('find . -type f | wc -l', (error, stdout, stderr) => {
  if (error) {
    console.error(`ошибка: ${error.message}`);
    return;
  }
  if (stderr) {
    console.error(`stderr: ${stderr}`);
    return;
  }
  console.log(`количество файлов: ${stdout}`);
});

const { execFile } = require('child_process');
execFile('node', ['--version'], (error, stdout, stderr) => {
  console.log(`версия Node.js: ${stdout}`);
});

const { fork } = require('child_process');
const child = fork('worker.js');
 
child.on('message', (message) => {
  console.log('Получено от дочернего процесса:', message);
});
 
child.send({ hello: 'world' });

// parent.js
const { fork } = require('child_process');
const child = fork('./child.js');
 
// Обработка сообщений от дочернего процесса
child.on('message', (message) => {
  console.log('Родитель получил:', message);
});
 
// Отправка сообщения дочернему процессу
child.send({ from: 'parent', data: [1, 2, 3] });
 
// child.js
process.on('message', (message) => {
  console.log('Дочерний получил:', message);
  
  // Отправка ответа родителю
  process.send({ from: 'child', result: 'обработано' });
});

// main.js
const { fork } = require('child_process');
 
function fib(n) {
  if (n < 2) return n;
  return fib(n-1) + fib(n-2);
}
 
// Блокирующий вызов в основном потоке
console.time('без дочернего процесса');
console.log(`Результат: ${fib(40)}`);
console.timeEnd('без дочернего процесса');
 
// Неблокирующий вызов через дочерний процесс
console.time('с дочерним процессом');
const child = fork('./fib-worker.js');
child.on('message', (message) => {
  console.log(`Результат: ${message.result}`);
  console.timeEnd('с дочерним процессом');
});
child.send({ number: 40 });
console.log('Основной поток продолжает работу...');
 
// fib-worker.js
process.on('message', (message) => {
  const result = fib(message.number);
  process.send({ result });
});
 
function fib(n) {
  if (n < 2) return n;
  return fib(n-1) + fib(n-2);
}

// Уничтожение процесса
child.kill('SIGTERM');
 
// Проверка, работает ли еще процесс
console.log(child.killed); // false до обработки сигнала

const { fork } = require('child_process');
const os = require('os');
 
class ProcessPool {
  constructor(file, poolMax) {
    this.file = file;
    this.poolMax = poolMax || os.cpus().length;
    this.pool = [];
    this.active = [];
    this.waiting = [];
  }
 
  acquire() {
    return new Promise((resolve, reject) => {
      let worker;
      if (this.pool.length > 0) {
        worker = this.pool.pop();
        this.active.push(worker);
        return resolve(worker);
      }
      
      if (this.active.length >= this.poolMax) {
        return this.waiting.push({ resolve, reject });
      }
      
      worker = fork(this.file);
      this.active.push(worker);
      resolve(worker);
    });
  }
 
  release(worker) {
    const index = this.active.indexOf(worker);
    if (index < 0) return;
    this.active.splice(index, 1);
    this.pool.push(worker);
    
    if (this.waiting.length > 0) {
      const { resolve } = this.waiting.shift();
      const worker = this.pool.pop();
      this.active.push(worker);
      resolve(worker);
    }
  }
}

// CommonJS модуль
const path = require('path');
const myModule = require('./myModule');
 
module.exports = function doSomething() {
  return myModule.process(path.join(__dirname, 'data'));
};

// Внутренняя структура require.cache
console.log(Object.keys(require.cache));
// [ '/absolute/path/to/your/file.js', '...и другие загруженные модули...' ]

(function(exports, require, module, __filename, __dirname) {
  // Код вашего модуля здесь
});

// ES модуль
import path from 'path';
import { process } from './myModule.js';
 
export function doSomething() {
  return process(path.join(import.meta.url, 'data'));
}

// a.js
console.log('Загрузка модуля a.js');
const b = require('./b');
console.log('b.counter в a.js:', b.counter);
exports.counter = 42;
console.log('Модуль a.js загружен');
 
// b.js
console.log('Загрузка модуля b.js');
const a = require('./a');
console.log('a.counter в b.js:', a.counter);
exports.counter = 37;
console.log('Модуль b.js загружен');

Загрузка модуля a.js
Загрузка модуля b.js
a.counter в b.js: undefined
Модуль b.js загружен
b.counter в a.js: 37
Модуль a.js загружен

// improved-a.js
exports.setup = function() { /* ... */ };
const b = require('./improved-b');
b.doSomething();
 
// improved-b.js
const a = require('./improved-a');
exports.doSomething = function() {
  a.setup(); // Работает, setup определен до require('./improved-b')
};
 
// Но если поменять порядок в a.js:
const b = require('./improved-b');
b.doSomething();
exports.setup = function() { /* ... */ }; // Определен ПОСЛЕ require
// Получим ошибку при выполнении b.doSomething(),
// потому что a.setup еще не определен

// a.mjs
import * as b from './b.mjs';
console.log('b.counter в a.mjs:', b.counter);
export const counter = 42;
 
// b.mjs
import * as a from './a.mjs';
console.log('a.counter в b.mjs:', a.counter);
export const counter = 37;

// Встроенный модуль загружается мгновенно, без проверки файловой системы
const fs = require('fs');

// Допустим, структура проекта такая:
// /project
//   /node_modules
//     /lodash
//   /src
//     /features
//       /auth
//         index.js
 
// В index.js мы пишем:
const _ = require('lodash');
// Node.js сначала ищет в /project/src/features/auth/node_modules/lodash
// Затем в /project/src/features/node_modules/lodash
// Затем в /project/src/node_modules/lodash
// И наконец находит в /project/node_modules/lodash

// Предположим, есть файлы: 
// - ./utils.js
// - ./config/index.js
 
const utils = require('./utils');       // Загрузит ./utils.js
const config = require('./config');     // Загрузит ./config/index.js

// CommonJS - работает
const utils = require('./utils');
 
// ES модули - ошибка, нужно указать расширение
import utils from './utils';      // Ошибка!
 
// ES модули - правильно
import utils from './utils.js';   // Работает

// Фрагмент из lib/http.js
function createServer(options, requestListener) {
if (typeof options === 'function') {
  requestListener = options;
  options = {};
}
return new Server(options, requestListener);
}
 
// А вот как это связано с C++ частью
const binding = internalBinding('http');

// В JavaScript-коде Node.js часто можно встретить нечто подобное:
const binding = process.binding('tcp_wrap');
// или более современный вариант
const binding = internalBinding('tcp_wrap');

const nativeAddon = require('./build/Release/hello');
console.log(nativeAddon.hello()); // "Привет из C++!"

// Использование WebAssembly вместо нативного аддона
const fs = require('fs');
const wasmBuffer = fs.readFileSync('./module.wasm');
WebAssembly.instantiate(wasmBuffer).then(({instance}) => {
  console.log(instance.exports.hello());
});