Deno против Node.js: Будущее JavaScript рантайма

// Импорт в стиле CommonJS
const fs = require('fs');
const { join } = require('path');
 
// Экспорт в стиле CommonJS
module.exports = { myFunction };

// Импорт в стиле ESM в Deno
import { readFile } from "https://deno.land/std/fs/mod.ts";
import { join } from "https://deno.land/std/path/mod.ts";
 
// Экспорт в стиле ESM
export { myFunction };

// Использование нативного fetch в Deno
async function fetchUserData(userId) {
  const response = await fetch(`https://api.example.com/users/${userId}`);
  if (!response.ok) {
    throw new Error(`Ошибка HTTP: ${response.status}`);
  }
  return await response.json();
}
 
try {
  const userData = await fetchUserData("123");
  console.log(userData);
} catch (error) {
  console.error("Не удалось получить данные пользователя:", error);
}

// Deno - естественное использование Promise
const text = await Deno.readTextFile("./data.txt");
console.log(text);
 
// Node.js в старом стиле с коллбэками
fs.readFile("./data.txt", "utf8", (err, data) => {
  if (err) throw err;
  console.log(data);
});
 
// Node.js с промисами (fs/promises)
import { readFile } from 'fs/promises';
const text = await readFile("./data.txt", "utf8");
console.log(text);

const express = require('express');
const mongoose = require('mongoose');
require('dotenv').config();

import { Application, Router } from "https://deno.land/x/oak@v12.5.0/mod.ts";
import { MongoClient } from "https://deno.land/x/mongo@v0.32.0/mod.ts";
import { config } from "https://deno.land/x/dotenv@v3.2.2/mod.ts";

// deps.ts - централизованное управление зависимостями
export { Application, Router } from "https://deno.land/x/oak@v12.5.0/mod.ts";
export { MongoClient } from "https://deno.land/x/mongo@v0.32.0/mod.ts";
export { config } from "https://deno.land/x/dotenv@v3.2.2/mod.ts";
 
// В основном коде
import { Application, Router, MongoClient, config } from "./deps.ts";

// Node.js (http модуль)
const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World');
});
server.listen(3000);

// Deno (стандартная библиотека)
import { serve } from "https://deno.land/std/http/server.ts";
 
serve(req => new Response("Hello World"), { port: 3000 });

// Node.js
const fs = require('fs').promises;
const path = require('path');
 
async function countLinesInDirectory(directoryPath) {
  const files = await fs.readdir(directoryPath);
  let totalLines = 0;
  
  for (const file of files) {
    const filePath = path.join(directoryPath, file);
    const stats = await fs.stat(filePath);
    
    if (stats.isFile() && filePath.endsWith('.js')) {
      const content = await fs.readFile(filePath, 'utf8');
      totalLines += content.split('\n').length;
    } else if (stats.isDirectory()) {
      totalLines += await countLinesInDirectory(filePath);
    }
  }
  
  return totalLines;
}
 
countLinesInDirectory('./src')
  .then(lines => console.log(`Total lines: ${lines}`))
  .catch(console.error);

// Deno
async function countLinesInDirectory(directoryPath) {
  let totalLines = 0;
  
  for await (const entry of Deno.readDir(directoryPath)) {
    const filePath = `${directoryPath}/${entry.name}`;
    
    if (entry.isFile && filePath.endsWith('.js')) {
      const content = await Deno.readTextFile(filePath);
      totalLines += content.split('\n').length;
    } else if (entry.isDirectory) {
      totalLines += await countLinesInDirectory(filePath);
    }
  }
  
  return totalLines;
}
 
try {
  const lines = await countLinesInDirectory('./src');
  console.log(`Total lines: ${lines}`);
} catch (error) {
  console.error(error);
}

// Deno сервер WebSocket с множеством соединений
import { serve } from "https://deno.land/std/http/server.ts";
import { 
  acceptWebSocket, 
  WebSocket 
} from "https://deno.land/std/ws/mod.ts";
 
const clients = new Set<WebSocket>();
 
serve(async (req) => {
  if (req.headers.get("upgrade") === "websocket") {
    const { socket, response } = Deno.upgradeWebSocket(req);
    
    socket.onopen = () => {
      clients.add(socket);
      console.log(`Клиент подключен. Всего: ${clients.size}`);
    };
    
    socket.onclose = () => {
      clients.delete(socket);
      console.log(`Клиент отключен. Осталось: ${clients.size}`);
    };
    
    socket.onmessage = (e) => {
      // Отправить сообщение всем клиентам
      for (const client of clients) {
        if (client.readyState === WebSocket.OPEN) {
          client.send(e.data);
        }
      }
    };
    
    return response;
  }
  
  return new Response("Это WebSocket сервер");
}, { port: 8080 });

// Node.js с кластеризацией
const cluster = require('cluster');
const http = require('http');
const crypto = require('crypto');
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) => {
    console.log(`Рабочий процесс ${worker.process.pid} завершен`);
    cluster.fork(); // Перезапускаем рабочий процесс
  });
} else {
  // Рабочие процессы обрабатывают запросы
  http.createServer((req, res) => {
    // Имитация CPU-нагрузки
    const hash = crypto.pbkdf2Sync('password', 'salt', 10000, 512, 'sha512');
    res.writeHead(200);
    res.end(`Хеш: ${hash.toString('hex').substring(0, 16)}...`);
  }).listen(8000);
 
  console.log(`Рабочий процесс ${process.pid} запущен`);
}

// Deno с Worker API
// main.ts
import { serve } from "https://deno.land/std/http/server.ts";
 
const numCPUs = navigator.hardwareConcurrency;
const workers = [];
 
// Создаем воркеры
for (let i = 0; i < numCPUs; i++) {
  const worker = new Worker(new URL("./worker.ts", import.meta.url).href, {
    type: "module",
  });
  workers.push(worker);
}
 
let currentWorker = 0;
 
serve(async (req) => {
  // Round-robin распределение запросов между воркерами
  const worker = workers[currentWorker];
  currentWorker = (currentWorker + 1) % workers.length;
  
  // Отправляем запрос воркеру и ожидаем ответ
  const channel = new MessageChannel();
  worker.postMessage({ port: channel.port1 }, [channel.port1]);
  
  return new Promise((resolve) => {
    channel.port2.onmessage = ({ data }) => {
      resolve(new Response(data));
    };
  });
}, { port: 8000 });
 
// worker.ts
self.onmessage = async (e) => {
  const { port } = e.data;
  
  // Имитация CPU-нагрузки
  const encoder = new TextEncoder();
  const data = encoder.encode("password");
  const salt = encoder.encode("salt");
  const key = await crypto.subtle.deriveKey(
    {
      name: "PBKDF2",
      salt,
      iterations: 10000,
      hash: "SHA-512",
    },
    await crypto.subtle.importKey(
      "raw", data, { name: "PBKDF2" }, false, ["deriveKey"]
    ),
    { name: "AES-CBC", length: 256 },
    true,
    ["encrypt"]
  );
  
  const exported = await crypto.subtle.exportKey("raw", key);
  const hash = Array.from(new Uint8Array(exported))
    .map(b => b.toString(16).padStart(2, "0"))
    .join("");
  
  port.postMessage(`Хеш: ${hash.substring(0, 16)}...`);
};

// Типичный package.json в экосистеме Node.js
{
  "name": "my-node-app",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.18.2",
    "mongoose": "^7.0.0",
    "react": "^18.2.0",
    "webpack": "^5.75.0"
  },
  "devDependencies": {
    "jest": "^29.4.0",
    "eslint": "^8.33.0",
    "typescript": "^4.9.5"
  }
}

// Эквивалентные импорты в Deno
import { Application } from "https://deno.land/x/oak@v12.5.0/mod.ts"; // аналог Express
import { assertEquals } from "https://deno.land/std/testing/asserts.ts"; // часть встроенной тестовой системы
import React from "https://esm.sh/react@18.2.0"; // импорт через CDN-прокси

// Использование npm пакета в Deno
import express from "npm:express@4.18.2";
import { mongoose } from "npm:mongoose@7.0.0";
 
const app = express();
app.get("/", (req, res) => {
  res.send("Привет от Express в Deno!");
});
app.listen(3000);

// server.js (Node.js + Express)
const express = require('express');
const jwt = require('jsonwebtoken');
const bodyParser = require('body-parser');
 
const app = express();
const SECRET_KEY = 'ваш_секретный_ключ';
 
app.use(bodyParser.json());
 
// Эмуляция базы данных
const users = [
  { id: 1, username: 'admin', password: 'admin123', role: 'admin' },
  { id: 2, username: 'user', password: 'user123', role: 'user' }
];
 
// Эндпоинт авторизации
app.post('/login', (req, res) => {
  const { username, password } = req.body;
  const user = users.find(u => u.username === username && u.password === password);
  
  if (!user) {
    return res.status(401).json({ message: 'Неверное имя пользователя или пароль' });
  }
  
  const token = jwt.sign(
    { userId: user.id, role: user.role }, 
    SECRET_KEY, 
    { expiresIn: '1h' }
  );
  
  res.json({ token });
});
 
// Middleware для проверки токена
function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  
  if (!token) return res.status(401).json({ message: 'Требуется авторизация' });
  
  jwt.verify(token, SECRET_KEY, (err, user) => {
    if (err) return res.status(403).json({ message: 'Недействительный токен' });
    req.user = user;
    next();
  });
}
 
// Защищённый маршрут
app.get('/profile', authenticateToken, (req, res) => {
  const user = users.find(u => u.id === req.user.userId);
  res.json({ 
    username: user.username, 
    role: user.role 
  });
});
 
app.listen(3000, () => console.log('Сервер запущен на порту 3000'));

const fs = require('fs');
const csv = require('csv-parser');
const { Transform } = require('stream');
 
// Stream трансформер для обработки данных
const processRow = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    // Бизнес-логика: увеличиваем числовое значение на 10%
    if (chunk.value && !isNaN(chunk.value)) {
      chunk.value = (parseFloat(chunk.value) * 1.1).toFixed(2);
    }
    
    // Фильтрация: пропускаем только строки с важностью > 3
    if (chunk.importance && parseInt(chunk.importance) > 3) {
      this.push(chunk);
    }
    
    callback();
  }
});
 
// Читаем CSV, обрабатываем и записываем результат
fs.createReadStream('data.csv')
  .pipe(csv())
  .pipe(processRow)
  .pipe(fs.createWriteStream('processed_data.csv'));

const WebSocket = require('ws');
const http = require('http');
const fs = require('fs');
 
// Создаем HTTP сервер
const server = http.createServer((req, res) => {
  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    fs.createReadStream('index.html').pipe(res);
  }
});
 
// Создаем WebSocket сервер
const wss = new WebSocket.Server({ server });
 
// Хранилище активных соединений
const clients = new Set();
 
wss.on('connection', (ws) => {
  // Добавляем нового клиента
  clients.add(ws);
  
  // Отправляем приветственное сообщение
  ws.send(JSON.stringify({
    type: 'system',
    message: 'Добро пожаловать в чат!'
  }));
  
  // Оповещаем всех о новом пользователе
  broadcast({
    type: 'system',
    message: 'Новый пользователь присоеденился к чату'
  }, ws);
  
  // Обработка входящих сообщений
  ws.on('message', (message) => {
    try {
      const data = JSON.parse(message);
      
      // Защита от XSS
      data.message = data.message
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;');
      
      // Рассылаем сообщение всем
      broadcast({
        type: 'message',
        user: data.user,
        message: data.message,
        timestamp: new Date().toISOString()
      });
    } catch (e) {
      ws.send(JSON.stringify({
        type: 'error',
        message: 'Неверный формат сообщения'
      }));
    }
  });
  
  // Обработка отключений
  ws.on('close', () => {
    clients.delete(ws);
    broadcast({
      type: 'system',
      message: 'Пользователь покинул чат'
    });
  });
});
 
// Функция для рассылки сообщений
function broadcast(message, exclude = null) {
  const messageStr = JSON.stringify(message);
  
  for (const client of clients) {
    if (client !== exclude && client.readyState === WebSocket.OPEN) {
      client.send(messageStr);
    }
  }
}
 
server.listen(8080, () => {
  console.log('Сервер запущен на порту 8080');
});

// service_a.js (Node.js с amqplib)
const amqp = require('amqplib');
 
async function start() {
  const connection = await amqp.connect('amqp://localhost');
  const channel = await connection.createChannel();
  const queue = 'tasks_queue';
  
  await channel.assertQueue(queue, { durable: true });
  
  // Отправка задания другому микросервису
  channel.sendToQueue(queue, Buffer.from(JSON.stringify({
    task: 'process_data',
    payload: { userId: 1, action: 'update_profile' }
  })), { persistent: true });
  
  console.log("Задание отправлено");
  
  setTimeout(() => {
    connection.close();
    process.exit(0);
  }, 500);
}
 
start();

// Профилирование в Node.js
const { performance, PerformanceObserver } = require('perf_hooks');
 
// Создаем наблюдателя за метриками
const obs = new PerformanceObserver((items) => {
  items.getEntries().forEach(entry => {
    console.log(`${entry.name}: ${entry.duration}ms`);
  });
});
obs.observe({ entryTypes: ['measure'] });
 
// Отмечаем начало операции
performance.mark('start');
 
// Выполняем операцию
for (let i = 0; i < 1000000; i++) {
  // Интенсивные вычисления
}
 
// Отмечаем конец операции
performance.mark('end');
performance.measure('Операция', 'start', 'end');

// Логирование в Node.js с Winston
const winston = require('winston');
 
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});
 
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}
 
logger.info('Сервер запущен');
logger.error('Произошла ошибка', { error: 'Детали ошибки' });

// app.js (Node.js + Express)
const express = require('express');
const mongoose = require('mongoose');
require('dotenv').config();
 
const app = express();
app.use(express.json());
 
// Подключение к MongoDB
mongoose.connect(process.env.MONGO_URI);
 
// Модель пользователя
const User = mongoose.model('User', {
  name: String,
  email: String,
  age: Number
});
 
// Маршруты
app.get('/users', async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});
 
app.post('/users', async (req, res) => {
  try {
    const user = new User(req.body);
    await user.save();
    res.status(201).json(user);
  } catch (error) {
    res.status(400).json({ error: error.message });
  }
});
 
const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Сервер запущен на порту ${port}`);
});