Как работает Node.js изнутри

// Пример неблокирующего кода в Node.js
const fs = require('fs');
 
// Асинхронное чтение файла, не блокирующее основной поток
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});
 
// Этот код выполнится сразу, не дожидаясь чтения файла
console.log('Продолжаем выполнение программы...');

// V8 оптимизирует такой код на лету
function sum(a, b) {
  return a + b;
}
 
// При многократном вызове с числами V8 может оптимизировать
// эту функцию специально для работы с числами
for (let i = 0; i < 100000; i++) {
  sum(i, i+1);
}

const fs = require('fs');
 
// Эта операция делегируется libuv, которая использует потоки из пула
// для выполнения чтения файла без блокирования основного потока
fs.readFile('/path/to/file', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// math.js
module.exports = {
  add: function(a, b) {
    return a + b;
  },
  subtract: function(a, b) {
    return a - b;
  }
};
 
// app.js
const math = require('./math');
console.log(math.add(5, 3)); // 8

// math.js
export function add(a, b) {
  return a + b;
}
 
export function subtract(a, b) {
  return a - b;
}
 
// app.js
import { add, subtract } from './math';
console.log(add(5, 3)); // 8

const memoryUsage = process.memoryUsage();
console.log(memoryUsage);
// Выведет что-то вроде:
// { rss: 26247168, heapTotal: 5767168, heapUsed: 3573032, external: 8772 }

// Импорт модуля
const http = require('http');
 
// Экспорт функциональности
module.exports = function(req, res) {
  res.end('Hello World');
};

// Импорт с деструктуризацией
import { createServer } from 'http';
 
// Импорт по умолчанию
import express from 'express';
 
// Экспорт
export function handler(req, res) {
  res.end('Hello from ES modules');
}

// Этот код создаёт много временных объектов, которые быстро становятся мусором
function processLargeArray(arr) {
  return arr.map(x => x * 2)
            .filter(x => x > 10)
            .reduce((acc, x) => acc + x, 0);
}

// Создание буфера
const buf = Buffer.from('Hello World', 'utf8');
console.log(buf.toString('hex')); // 48656c6c6f20576f726c64
 
// Работа с бинарными данными
const binaryData = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
console.log(binaryData.toString()); // "buffer"

const fs = require('fs');
 
fs.readFile('image.png', (err, buffer) => {
  if (err) throw err;
  
  // buffer содержит бинарные данные изображения
  console.log(`Размер файла: ${buffer.length} байт`);
  
  // Можно манипулировать битами напрямую
  const magicNumber = buffer.slice(0, 4).toString('hex');
  console.log(`Магические байты: ${magicNumber}`);
});

// Создание типизированного массива из буфера
const buf = Buffer.from([1, 2, 3, 4]);
const uint32array = new Uint32Array(buf.buffer, buf.byteOffset, buf.length / Uint32Array.BYTES_PER_ELEMENT);
 
// Можно использовать типизированные массивы напрямую
const float64Array = new Float64Array(10);
for (let i = 0; i < float64Array.length; i++) {
  float64Array[i] = Math.random();
}

const fs = require('fs');
const crypto = require('crypto');
 
// Вычисление хеша большого файла без загрузки его целиком в память
const hash = crypto.createHash('sha256');
const input = fs.createReadStream('largefile.bin');
 
input.on('data', chunk => {
  hash.update(chunk);
});
 
input.on('end', () => {
  console.log(hash.digest('hex'));
});

// Пример, демонстрирующий порядок выполнения фаз
console.log('Начало программы');
 
setTimeout(() => {
  console.log('Таймер');
}, 0);
 
setImmediate(() => {
  console.log('Immediate');
});
 
process.nextTick(() => {
  console.log('NextTick');
});
 
console.log('Конец программы');
 
// Вывод:
// Начало программы
// Конец программы
// NextTick
// Таймер (или Immediate - может варьироваться)
// Immediate (или Таймер - может варьироваться)

const fs = require('fs');
 
fs.readFile('some-file.txt', () => {
  setTimeout(() => {
    console.log('Таймер внутри I/O колбэка');
  }, 0);
  
  setImmediate(() => {
    console.log('Immediate внутри I/O колбэка');
  });
});
 
// Вывод всегда будет:
// Immediate внутри I/O колбэка
// Таймер внутри I/O колбэка

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

console.log('1. Синхронный код');
 
setTimeout(() => {
  console.log('2. Таймер 1');
  
  process.nextTick(() => {
    console.log('3. nextTick внутри таймера');
  });
  
  Promise.resolve().then(() => {
    console.log('4. Промис внутри таймера');
  });
}, 0);
 
process.nextTick(() => {
  console.log('5. nextTick 1');
  
  setTimeout(() => {
    console.log('6. Вложенный таймер в nextTick');
  }, 0);
});
 
Promise.resolve().then(() => {
  console.log('7. Промис 1');
  
  process.nextTick(() => {
    console.log('8. nextTick внутри промиса');
  });
});
 
setTimeout(() => {
  console.log('9. Таймер 2');
}, 0);
 
setImmediate(() => {
  console.log('10. Immediate');
});
 
console.log('11. Ещё синхронный код');

1. Синхронный код
11. Ещё синхронный код
5. nextTick 1
7. Промис 1
8. nextTick внутри промиса
2. Таймер 1
3. nextTick внутри таймера
4. Промис внутри таймера
9. Таймер 2
10. Immediate
6. Вложенный таймер в nextTick

// Создание множества таймеров может вызвать проблемы
for (let i = 0; i < 10000; i++) {
  setTimeout(() => {
    // Тяжелая операция
    const result = Array(10000).fill(1).map(x => x * 2).reduce((a, b) => a + b);
  }, 1000);
}

const tasks = Array(10000).fill(null).map((_, i) => i);
let completed = 0;
 
setTimeout(() => {
  // Обрабатываем задачи пакетами
  const processBatch = () => {
    const batch = tasks.slice(completed, completed + 500);
    if (batch.length === 0) return;
    
    batch.forEach(taskId => {
      // Выполнение задачи
      const result = Array(10000).fill(1).map(x => x * 2).reduce((a, b) => a + b);
    });
    
    completed += batch.length;
    
    // Отдаём управление событийному циклу, используя setImmediate
    setImmediate(processBatch);
  };
  
  processBatch();
}, 1000);

try {
  const result = riskyOperation();
  // Обработка результата
} catch (error) {
  console.error('Ошибка перехвачена:', error);
}

try {
  setTimeout(() => {
    throw new Error('Асинхронная ошибка');
  }, 100);
} catch (error) {
  // Этот блок никогда не выполнится
  console.error('Ошибка перехвачена?', error);
}

fs.readFile('file.txt', (err, data) => {
  if (err) {
    console.error('Ошибка чтения файла:', err);
    return;
  }
  // Обработка данных
});

fs.promises.readFile('file.txt')
  .then(data => {
    // Обработка данных
  })
  .catch(err => {
    console.error('Ошибка чтения файла:', err);
  });

async function readFileContent() {
  try {
    const data = await fs.promises.readFile('file.txt');
    // Обработка данных
  } catch (err) {
    console.error('Ошибка чтения файла:', err);
  }
}

process.on('unhandledRejection', (reason, promise) => {
  console.error('Необработанное отклонение промиса:', reason);
  // Можно завершить процесс или выполнить другие действия
  // process.exit(1);
});

process.on('uncaughtException', (err) => {
  console.error('Необработанное исключение:', err);
  // Важно: после необработанного исключения состояние процесса может быть нестабильным
  // Рекомендуется выполнить логирование и перезапустить процесс
  process.exit(1);
});

function processLargeArray(array, batchSize = 1000) {
  let index = 0;
 
  function processBatch() {
    const end = Math.min(index + batchSize, array.length);
    
    // Обработка текущего пакета
    for (let i = index; i < end; i++) {
      // Тяжелая операция над элементом
      array[i] = heavyComputationOnItem(array[i]);
    }
    
    index = end;
    
    // Если есть еще элементы, планируем следующий пакет
    if (index < array.length) {
      setImmediate(processBatch);
    } else {
      console.log('Обработка завершена');
    }
  }
  
  // Начинаем обработку
  processBatch();
}

function calculatePrimes(max) {
  const primes = [];
  let currentNumber = 2;
  
  function checkNextBatch() {
    const endTime = Date.now() + 50; // Максимум 50мс на пакет
    
    while (Date.now() < endTime && currentNumber <= max) {
      let isPrime = true;
      
      for (let i = 2; i <= Math.sqrt(currentNumber); i++) {
        if (currentNumber % i === 0) {
          isPrime = false;
          break;
        }
      }
      
      if (isPrime) primes.push(currentNumber);
      currentNumber++;
    }
    
    if (currentNumber <= max) {
      // Еще не закончили, планируем следующий пакет
      setTimeout(checkNextBatch, 0);
    } else {
      console.log(`Найдено ${primes.length} простых чисел`);
    }
  }
  
  checkNextBatch();
}

let lastCheck = Date.now();
 
setInterval(() => {
  const now = Date.now();
  const delay = now - lastCheck - 1000; // Ожидаемая задержка 1000мс
  
  if (delay > 100) { // Задержка более 100мс считается проблемной
    console.warn(`Событийный цикл был заблокирован на ${delay}мс`);
    // Можно отправить метрику в систему мониторинга
  }
  
  lastCheck = now;
}, 1000);

const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
 
if (isMainThread) {
  // Это основной поток
  const worker = new Worker(__filename, {
    workerData: { input: Array(1000000).fill(1) }
  });
  
  worker.on('message', result => {
    console.log('Результат от работника:', result);
  });
  
  worker.on('error', err => {
    console.error('Ошибка работника:', err);
  });
  
  worker.on('exit', code => {
    if (code !== 0)
      console.error(`Работник завершился с кодом ${code}`);
  });
} else {
  // Это работник
  const { input } = workerData;
  
  // Выполняем тяжелую операцию без блокировки основного потока
  const result = input.map(x => x * 2).reduce((a, b) => a + b, 0);
  
  // Отправляем результат основному потоку
  parentPort.postMessage(result);
}

const { Worker, isMainThread } = require('worker_threads');
 
if (isMainThread) {
  // Создаем SharedArrayBuffer, доступный между потоками
  const buffer = new SharedArrayBuffer(4);
  const view = new Int32Array(buffer);
  view[0] = 0;
  
  const worker = new Worker(__filename, { workerData: { buffer } });
  
  // Запускаем таймер для чтения обновлений
  setInterval(() => {
    console.log('Текущее значение:', Atomics.load(view, 0));
  }, 100);
} else {
  const { buffer } = workerData;
  const view = new Int32Array(buffer);
  
  // Инкрементируем значение каждые 500мс
  setInterval(() => {
    Atomics.add(view, 0, 1);
  }, 500);
}

// Профилирование CPU
const profiler = require('v8-profiler-next');
const fs = require('fs');
 
// Начинаем профилирование
profiler.startProfiling('CPU Profile');
 
// Через некоторое время останавливаем и сохраняем результат
setTimeout(() => {
  const profile = profiler.stopProfiling();
  profile.export()
    .pipe(fs.createWriteStream('./cpuprofile.cpuprofile'))
    .on('finish', () => profile.delete());
}, 30000);

const cache = new Map();
 
function badCaching(key, value) {
  // Отсутствует механизм очистки кеша
  cache.set(key, value);
  
  // Кеш будет расти бесконечно
  setInterval(() => {
    console.log(cache.get(key));
  }, 1000);
}

class LRUCache {
  constructor(maxSize = 1000) {
    this.cache = new Map();
    this.maxSize = maxSize;
  }
 
  set(key, value) {
    if (this.cache.size >= this.maxSize) {
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
    this.cache.set(key, value);
  }
 
  get(key) {
    const value = this.cache.get(key);
    if (value) {
      // Обновляем позицию элемента
      this.cache.delete(key);
      this.cache.set(key, value);
    }
    return value;
  }
}

const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const os = require('os');
 
function processDataParallel(data, processingFn) {
  return new Promise((resolve, reject) => {
    const numCPUs = os.cpus().length;
    const chunkSize = Math.ceil(data.length / numCPUs);
    const workers = [];
    let completedWorkers = 0;
    const results = [];
 
    for (let i = 0; i < numCPUs; i++) {
      const start = i * chunkSize;
      const end = Math.min(start + chunkSize, data.length);
      
      const worker = new Worker(`
        const { parentPort, workerData } = require('worker_threads');
        const { data, start, end, fnStr } = workerData;
        const processingFn = eval('(' + fnStr + ')');
        
        const result = data.slice(start, end).map(processingFn);
        parentPort.postMessage(result);
      `, {
        eval: true,
        workerData: {
          data,
          start,
          end,
          fnStr: processingFn.toString()
        }
      });
 
      worker.on('message', (result) => {
        results[i] = result;
        completedWorkers++;
        
        if (completedWorkers === numCPUs) {
          resolve([].concat(...results));
        }
      });
 
      worker.on('error', reject);
      workers.push(worker);
    }
  });
}

const { Pool } = require('pg');
 
const pool = new Pool({
  user: 'dbuser',
  host: 'database.server.com',
  database: 'mydb',
  password: 'secretpassword',
  port: 5432,
  // Оптимальные настройки пула
  max: 20, // максимум соединений
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});
 
// Переиспользование соединений
async function executeQueries(queries) {
  const client = await pool.connect();
  try {
    await client.query('BEGIN');
    const results = [];
    
    for (const query of queries) {
      const result = await client.query(query);
      results.push(result);
    }
    
    await client.query('COMMIT');
    return results;
  } catch (e) {
    await client.query('ROLLBACK');
    throw e;
  } finally {
    client.release();
  }
}

function memoizeWithTTL(fn, ttl = 60000) {
  const cache = new Map();
  
  return function (...args) {
    const key = JSON.stringify(args);
    const cached = cache.get(key);
    
    if (cached && Date.now() - cached.timestamp < ttl) {
      return cached.value;
    }
    
    const result = fn.apply(this, args);
    cache.set(key, {
      value: result,
      timestamp: Date.now()
    });
    
    return result;
  };
}
 
// Пример использования
const expensiveOperation = memoizeWithTTL((n) => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(n * n);
    }, 1000);
  });
}, 5000); // кеш на 5 секунд

const fs = require('fs');
const { Transform } = require('stream');
const csv = require('csv-parser');
 
const transformStream = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    // Преобразование данных
    const transformed = {
      name: chunk.name.toUpperCase(),
      age: parseInt(chunk.age) + 1,
      city: chunk.city
    };
    
    callback(null, JSON.stringify(transformed) + '\n');
  }
});
 
fs.createReadStream('input.csv')
  .pipe(csv())
  .pipe(transformStream)
  .pipe(fs.createWriteStream('output.json'))
  .on('finish', () => console.log('Преобразование завершено'));

const express = require('express');
const app = express();
 
class UserService {
constructor() {
  this.users = new Map();
}
 
async createUser(userData) {
  const userId = Math.random().toString(36).substr(2, 9);
  this.users.set(userId, userData);
  return { id: userId, ...userData };
}
 
async getUser(userId) {
  const user = this.users.get(userId);
  if (!user) throw new Error('User not found');
  return user;
}
}
 
const userService = new UserService();
 
app.use(express.json());
 
app.post('/users', async (req, res) => {
try {
  const user = await userService.createUser(req.body);
  res.status(201).json(user);
} catch (err) {
  res.status(400).json({ error: err.message });
}
});
 
app.get('/users/:id', async (req, res) => {
try {
  const user = await userService.getUser(req.params.id);
  res.json(user);
} catch (err) {
  res.status(404).json({ error: err.message });
}
});
 
app.listen(3000);

const { Transform } = require('stream');
const fs = require('fs');
 
class DataTransformer extends Transform {
constructor(options = {}) {
  super({ ...options, objectMode: true });
  this.batchSize = options.batchSize || 1000;
  this.batch = [];
}
 
_transform(chunk, encoding, callback) {
  this.batch.push(chunk);
  
  if (this.batch.length >= this.batchSize) {
    this.processBatch();
  }
  
  callback();
}
 
_flush(callback) {
  if (this.batch.length > 0) {
    this.processBatch();
  }
  callback();
}
 
processBatch() {
  // Обработка пакета данных
  const result = this.batch.map(item => ({
    ...item,
    processed: true,
    timestamp: Date.now()
  }));
  
  this.push(result);
  this.batch = [];
}
}
 
// Использование трансформера
fs.createReadStream('input.json')
.pipe(new DataTransformer({ batchSize: 100 }))
.pipe(fs.createWriteStream('output.json'));

const { Worker } = require('worker_threads');
const os = require('os');
 
class ComputationPool {
constructor(workerScript, numWorkers = os.cpus().length) {
  this.workers = new Array(numWorkers).fill(null).map(() => 
    new Worker(workerScript)
  );
  this.nextWorker = 0;
}
 
async compute(data) {
  const worker = this.workers[this.nextWorker];
  this.nextWorker = (this.nextWorker + 1) % this.workers.length;
  
  return new Promise((resolve, reject) => {
    worker.once('message', resolve);
    worker.once('error', reject);
    worker.postMessage(data);
  });
}
 
terminate() {
  return Promise.all(
    this.workers.map(worker => worker.terminate())
  );
}
}
 
// Использование пула для тяжёлых вычислений
const pool = new ComputationPool('./compute-worker.js');
const results = await Promise.all(
tasks.map(task => pool.compute(task))
);

class TransactionManager {
constructor(pool) {
  this.pool = pool;
}
 
async withTransaction(callback) {
  const client = await this.pool.connect();
  
  try {
    await client.query('BEGIN');
    const result = await callback(client);
    await client.query('COMMIT');
    return result;
  } catch (err) {
    await client.query('ROLLBACK');
    throw err;
  } finally {
    client.release();
  }
}
}
 
// Использование менеджера транзакций
const tm = new TransactionManager(pool);
await tm.withTransaction(async (client) => {
const { rows } = await client.query(
  'UPDATE accounts SET balance = balance - $1 WHERE id = $2 RETURNING *',
  [amount, fromId]
);
 
if (rows[0].balance < 0) {
  throw new Error('Insufficient funds');
}
 
await client.query(
  'UPDATE accounts SET balance = balance + $1 WHERE id = $2',
  [amount, toId]
);
});

// ecosystem.config.js для PM2
module.exports = {
apps: [{
  name: 'api-server',
  script: './server.js',
  instances: 'max',
  exec_mode: 'cluster',
  env: {
    NODE_ENV: 'production',
    PORT: 3000
  },
  env_production: {
    NODE_ENV: 'production',
    PORT: 80
  }
}]
};