Перевірка знань по темі "Node"

Node.js — це середовище виконання JavaScript поза браузером, побудоване на V8 (движок Chrome). Воно дозволяє запускати JS на сервері.

• Створене для масштабованих, високопродуктивних мережевих додатків.
• Використовує подієво-орієнтовану, неблокуючу модель I/O.
• Активно застосовується у веб-розробці, CLI-утилітах, мікросервісах.

// Перевірка версії Node.js
node -v

// Виконання JS-файлу
node app.js

Висновок: Node.js робить JavaScript універсальною мовою — і для клієнта, і для сервера.

Існує кілька способів установки:

• З офіційного сайту: nodejs.org
• Через пакетні менеджери:
  • nvm (Node Version Manager) — для Unix-подібних систем.
  • choco (Chocolatey) — для Windows.

# Приклад з nvm
nvm install 20
nvm use 20

Рекомендація: Використовуй nvm для зручного перемикання між версіями Node.js.

REPL (Read–Eval–Print–Loop) — інтерактивне середовище Node.js для швидкого тестування коду.

// Запуск REPL
node

// Усередині REPL
> 2 + 2
4
> const x = 10;
> x * 2
20

Використання: зручно для експериментів, перевірки функцій без створення окремого файлу.

• У браузері JS працює з DOM, подіями, localStorage.
• У Node.js доступ до файлової системи, мережі, процесів ОС.
• У браузері немає require/module.exports (до ES Modules).
• Node.js — орієнтований на сервер і бекенд.

// У Node.js
const fs = require('fs');
fs.writeFileSync('test.txt', 'Привіт Node.js!');

// У браузері так зробити не можна

Модулі — це окремі файли з кодом, які можна підключати й перевикористовувати.

• Вбудовані: fs, http, path.
• Користувацькі: власні JS-файли.
• Зовнішні: пакети з npm.

// example.js
module.exports = function(a, b) {
  return a + b;
}

// app.js
const add = require('./example');
console.log(add(2, 3)); // 5

Висновок: Модулі роблять код організованим і підтримуваним.

require() використовується для підключення модулів, module.exports — для експорту функцій чи об'єктів із модуля.

// math.js
module.exports.sum = (a, b) => a + b;

// app.js
const math = require('./math');
console.log(math.sum(3, 4)); // 7

Висновок: Це основа організації коду в Node.js.

Node.js має власні глобальні об'єкти:

• global — глобальний об'єкт
• __dirname — шлях до директорії поточного файлу
• __filename — повний шлях до файлу
• process — інформація про процес Node.js
• console — вивід у консоль

console.log(__dirname);
console.log(__filename);
console.log(process.platform);

package.json — файл, який описує проект Node.js, його залежності, скрипти та метадані.

{
  "name": "my-app",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

Висновок: package.json керує всіма аспектами проекту Node.js.

// У терміналі
node app.js

// Можна передавати аргументи
node app.js arg1 arg2

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

• Вбудовані модулі: fs, http, path
• Користувацькі модулі: ваші файли JS
• Зовнішні модулі: встановлені через npm

npm — менеджер пакетів для Node.js, що дозволяє встановлювати бібліотеки, управляти залежностями та скриптами.

// Ініціалізація npm
npm init

// Встановлення пакета
npm install express

• Через nvm: nvm install latest
• Через офіційний сайт Node.js
• Через пакетний менеджер ОС

node -v
npm -v

Node.js підтримує ES Modules за розширенням .mjs або при "type": "module" у package.json.

// sum.mjs
export const sum = (a, b) => a + b;

// app.mjs
import { sum } from './sum.mjs';
console.log(sum(3,4));

Callback — це функція, яка передається як аргумент іншій функції для виконання після завершення операції.

const fs = require('fs');
fs.readFile('file.txt', 'utf8', (err, data) => {
  if(err) throw err;
  console.log(data);
});

Event Loop — механізм Node.js для обробки неблокуючих асинхронних операцій.

• Node.js ставить I/O операції в чергу.
• Event Loop перевіряє, коли операція завершена, і викликає відповідний callback.

Node.js кешує модулі після першого підключення.

// Модуль буде завантажений лише один раз
const mod1 = require('./mod');
const mod2 = require('./mod'); // поверне кешований об'єкт

__dirname — абсолютний шлях до поточної директорії.

__filename — абсолютний шлях до поточного файлу.

console.log(__dirname);
console.log(__filename);

Process.env містить змінні оточення Node.js.

console.log(process.env.PORT || 3000);

Зручно для налаштування конфігурацій та секретів.

Callback hell — це занадто глибоко вкладені callback-функції, які погіршують читаність коду.

fs.readFile('file1', (err, data1) => {
  fs.readFile('file2', (err, data2) => {
    fs.readFile('file3', (err, data3) => {
      console.log(data1, data2, data3);
    });
  });
});

Висновок: Використовуй Promises або async/await для чистішого коду.

Модуль fs дозволяє читати файли синхронно або асинхронно.

// Асинхронно
const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Синхронно
const content = fs.readFileSync('example.txt', 'utf8');
console.log(content);

const fs = require('fs');

// Асинхронно
fs.writeFile('output.txt', 'Привіт Node.js!', (err) => {
  if (err) throw err;
  console.log('Файл збережено!');
});

// Синхронно
fs.writeFileSync('output.txt', 'Привіт Node.js!');

# Встановити пакет локально
npm install express

# Встановити пакет глобально
npm install -g nodemon

# Видалити пакет
npm uninstall express

# Перегляд локальних пакетів
npm list

# Перегляд глобальних пакетів
npm list -g

devDependencies — пакети, потрібні лише для розробки (тестування, збірки), але не для продакшн.

npm install --save-dev jest

mkdir my-app
cd my-app
npm init
# або швидка ініціалізація
npm init -y

Це створить файл package.json з базовими налаштуваннями проекту.

// Вбудований модуль
const fs = require('fs');

// Користувацький модуль
const helper = require('./helper.js');

// Модуль з npm
const express = require('express');

Файл package-lock.json фіксує точні версії залежностей, щоб проект працював однаково на всіх машинах.

npm list package-name

Повертає встановлену версію пакета або повідомляє, що пакет не встановлено.

# Оновити всі пакети локально
npm update

# Оновити конкретний пакет
npm install express@latest

Node.js >= 10 підтримує проміс-базований API для fs.

const fs = require('fs').promises;

async function readFile() {
  const data = await fs.readFile('file.txt', 'utf8');
  console.log(data);
}

readFile();

const fs = require('fs');

fs.access('file.txt', fs.constants.F_OK, (err) => {
  console.log(err ? 'Файл не існує' : 'Файл існує');
});

const fs = require('fs');

// Створити директорію
fs.mkdirSync('my-folder');

// Видалити директорію
fs.rmdirSync('my-folder');

const fs = require('fs');

// Копіювання
fs.copyFileSync('source.txt', 'destination.txt');

// Переміщення
fs.renameSync('old.txt', 'new.txt');

__dirname — абсолютний шлях до поточної директорії файлу.

process.cwd() — робоча директорія, з якої запущено Node.js.

console.log(__dirname);
console.log(process.cwd());

npm cache clean --force

npm search express

npm install -g nodemon

Глобальні пакети доступні з будь-якої директорії системи.

npm audit
npm audit fix

Допомагає знайти вразливості та оновити пакети безпечні версії.

У package.json можна додавати власні скрипти:

{
  "scripts": {
    "start": "node app.js",
    "test": "jest"
  }
}

Запуск у терміналі: npm run start або npm run test

Асинхронність означає, що операції не блокують виконання коду, поки чекають на завершення I/O.

• Node.js використовує неблокуючу модель вводу/виводу.
• Це дозволяє обробляти багато запитів одночасно.

const fs = require('fs');

// Асинхронне читання файлу
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

console.log('Цей рядок виконується раніше, ніж завершиться readFile');

Callback — це функція, передана як аргумент іншій функції, яка виконується після завершення операції.

function greet(name, callback) {
  console.log(`Hello, ${name}`);
  callback();
}

greet('Alice', () => console.log('Callback виконано!'));

Callback hell — це занадто глибоко вкладені callback-функції, що погіршують читаність коду.

fs.readFile('file1.txt', (err, data1) => {
  fs.readFile('file2.txt', (err, data2) => {
    fs.readFile('file3.txt', (err, data3) => {
      console.log(data1, data2, data3);
    });
  });
});

Використовуй Promises або async/await для чистішого коду.

Promise — об’єкт, який представляє результат асинхронної операції.

• Може бути у стані pending, fulfilled або rejected.

const fs = require('fs').promises;

fs.readFile('file.txt', 'utf8')
  .then(data => console.log(data))
  .catch(err => console.error(err));

const myPromise = new Promise((resolve, reject) => {
  const success = true;
  if (success) resolve('Успіх!');
  else reject('Помилка!');
});

myPromise
  .then(msg => console.log(msg))
  .catch(err => console.error(err));

Async/await дозволяє писати асинхронний код, як синхронний, з використанням Promises.

const fs = require('fs').promises;

async function readFile() {
  try {
    const data = await fs.readFile('file.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

readFile();

someAsyncFunction()
  .then(result => {
    console.log(result);
  })
  .catch(err => {
    console.error('Помилка:', err);
  });

Promise.all дозволяє виконати кілька Promises паралельно і отримати результат лише коли всі завершаться успішно.

const p1 = Promise.resolve(1);
const p2 = Promise.resolve(2);

Promise.all([p1, p2])
  .then(results => console.log(results)); // [1,2]

Promise.race повертає результат того Promise, який завершився першим.

const p1 = new Promise(res => setTimeout(() => res('A'), 500));
const p2 = new Promise(res => setTimeout(() => res('B'), 300));

Promise.race([p1, p2])
  .then(result => console.log(result)); // B

async function example() {
  try {
    const data = await fs.readFile('file.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error('Помилка:', err);
  }
}

example();

Можна ітерувати асинхронні об’єкти за допомогою for await...of.

async function process(items) {
  for await (const item of items) {
    console.log(item);
  }
}

// setTimeout
setTimeout(() => console.log('Через 1 сек'), 1000);

// setImmediate
setImmediate(() => console.log('Виконується після I/O'));

// setInterval
setInterval(() => console.log('Кожні 2 секунди'), 2000);

Виконує функцію одразу після поточного етапу Event Loop, перед чергами I/O.

process.nextTick(() => console.log('Виконано на наступному кроці Event Loop'));

const fs = require('fs');

fs.readFile('file.txt', 'utf8', function(err, data) {
  if (err) throw err;
  console.log(data);
});

const fs = require('fs');
const { promisify } = require('util');

const readFileAsync = promisify(fs.readFile);

readFileAsync('file.txt', 'utf8')
  .then(data => console.log(data))
  .catch(err => console.error(err));

Promise.resolve(1)
  .then(x => x + 1)
  .then(x => x * 2)
  .then(result => console.log(result)); // 4

Повертає масив всіх результатів Promises, незалежно від успіху чи помилки.

const p1 = Promise.resolve(1);
const p2 = Promise.reject('error');

Promise.allSettled([p1, p2])
  .then(results => console.log(results));

Повертає результат першого успішного Promise, ігноруючи помилки.

const p1 = Promise.reject('err');
const p2 = Promise.resolve(2);

Promise.any([p1, p2])
  .then(result => console.log(result)); // 2

async function run() {
  try {
    const data = await fs.readFile('file.txt', 'utf8');
    console.log(data);
  } catch(err) {
    console.error('Помилка:', err);
  }
}

run();

Це найчистіший та безпечний спосіб обробки асинхронного коду в Node.js.

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello, Node.js!');
});

server.listen(3000, () => {
  console.log('Сервер працює на http://localhost:3000');
});

Express.js — популярний фреймворк для Node.js, який спрощує створення серверів і маршрутизації.

const express = require('express');
const app = express();

app.get('/', (req, res) => res.send('Hello Express!'));

app.listen(3000, () => console.log('Сервер на порту 3000'));

app.get('/about', (req, res) => {
  res.send('Про сайт');
});

app.post('/login', (req, res) => {
  res.send('Логін');
});

Middleware — це функції, які обробляють запити та відповіді перед маршрутом або після нього.

app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next(); // передає керування далі
});

Для обробки JSON та форм у запитах.

const express = require('express');
const app = express();

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.post('/submit', (req, res) => {
  console.log(req.body);
  res.send('Дані отримано');
});

app.use(express.static('public'));
// Тепер файли з папки public доступні напряму
// Наприклад: /public/index.html → http://localhost:3000/index.html

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Щось пішло не так!');
});

app.get('/user/:id', (req, res) => {
  res.send(`Користувач з ID: ${req.params.id}`);
});

app.get('/search', (req, res) => {
  const query = req.query.q;
  res.send(`Ви шукали: ${query}`);
});

app.post('/login', (req, res) => {
  const { username, password } = req.body;
  res.send(`Логін: ${username}`);
});

Router дозволяє розбити маршрути на модулі для кращої організації.

const router = express.Router();

router.get('/products', (req, res) => res.send('Список продуктів'));
app.use('/api', router);
// Маршрут доступний за /api/products

const cors = require('cors');
app.use(cors()); // Дозволяє CORS для всіх маршрутів

app.use((req, res, next) => {
  res.status(404).send('Сторінку не знайдено');
});

app.use(express.json());
app.post('/data', (req, res) => {
  console.log(req.body);
  res.send('Отримано JSON');
});

app.get('/user', (req, res) => {
  res.json({ name: 'Alice', age: 25 });
});

Middleware виконується у порядку підключення. Перший app.use → другий → маршрут → обробник помилок.

function logger(req, res, next) {
  console.log(`${req.method} ${req.url}`);
  next();
}

app.use(logger);

next() передає керування наступному middleware або маршруту.

app.use((req, res, next) => {
  console.log('Перший middleware');
  next();
});

app.use((req, res) => {
  res.send('Другий middleware');
});

router.get('/user/:id', (req, res) => {
  res.send(`Користувач ID: ${req.params.id}`);
});

Створюй модулі для кожного набору маршрутів:

// routes/users.js
const express = require('express');
const router = express.Router();
router.get('/', (req, res) => res.send('Користувачі'));
module.exports = router;

// app.js
const usersRouter = require('./routes/users');
app.use('/users', usersRouter);

Buffer — об’єкт для роботи з двійковими даними у Node.js.

const buf = Buffer.from('Hello');
console.log(buf); // <Buffer 48 65 6c 6f>
console.log(buf.toString()); // Hello

const fs = require('fs');
const readStream = fs.createReadStream('file.txt', 'utf8');

readStream.on('data', chunk => console.log('Отримано chunk:', chunk));
readStream.on('end', () => console.log('Читання завершено'));

const fs = require('fs');
const writeStream = fs.createWriteStream('output.txt');

writeStream.write('Привіт Node.js!\n');
writeStream.end('Завершено запис');

const fs = require('fs');
const readStream = fs.createReadStream('file.txt');
const writeStream = fs.createWriteStream('copy.txt');

readStream.pipe(writeStream);

EventEmitter — клас для створення івентів та їх обробки.

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('message', data => console.log('Повідомлення:', data));
emitter.emit('message', 'Привіт світе!');

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, I'm ${this.name}`);
  }
}

const alice = new Person('Alice', 25);
alice.greet();

class Employee extends Person {
  constructor(name, age, position) {
    super(name, age);
    this.position = position;
  }
  work() {
    console.log(`${this.name} працює на посаді ${this.position}`);
  }
}

const bob = new Employee('Bob', 30, 'Developer');
bob.greet();
bob.work();

const EventEmitter = require('events');

class MyClass extends EventEmitter {
  doSomething() {
    this.emit('done', 'Завершено!');
  }
}

const obj = new MyClass();
obj.on('done', msg => console.log(msg));
obj.doSomething();

Використовуй process.memoryUsage() та профайлери Node.js:

console.log(process.memoryUsage());

Streams дозволяють обробляти файли без завантаження всього у пам’ять.

const fs = require('fs');
const readStream = fs.createReadStream('bigfile.txt');
readStream.on('data', chunk => console.log('chunk length:', chunk.length));

const crypto = require('crypto');
const hash = crypto.createHash('sha256').update('password').digest('hex');
console.log(hash);

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

const options = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};

https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('Hello HTTPS!');
}).listen(443);

Використовуй пакети типу helmet та валідаторів вводу:

const helmet = require('helmet');
app.use(helmet());

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100
});

app.use(limiter);

Можна використовувати пам’ять, Redis або інші кеші:

const cache = new Map();
cache.set('key', 'value');
console.log(cache.get('key'));

node --inspect app.js
# Відкрити Chrome DevTools → профілювання CPU та пам’яті

const { exec } = require('child_process');
exec('ls -la', (err, stdout, stderr) => {
  if (err) console.error(err);
  console.log(stdout);
});

process.on('uncaughtException', err => {
  console.error('Помилка:', err);
});

process.on('unhandledRejection', reason => {
  console.error('Unhandled Rejection:', reason);
});

• Використовуй кластеризацію (cluster) для багатоядерних CPU.
• Оптимізуй асинхронний код і мінімізуй блокуючі операції.
• Використовуй кешування та CDN для статичних файлів.
• Використовуй профайлери та моніторинг для виявлення вузьких місць.