> Какие способы оптимизации time to first byte существуют (JavaScript)

Короткий ответ

TTFB (time to first byte) оптимизируется на стороне сервера и сети. Основные способы: кэширование ответов (CDN, HTTP-кеш), оптимизация бэкенда (уменьшение времени обработки запроса, пул соединений к БД), использование keep-alive, предварительное прогревание сервера, минимизация цепочек middleware, асинхронная обработка, сжатие, выбор географически близкого хостинга и HTTP/2 или HTTP/3.

Подробное объяснение

TTFB - время от отправки запроса до получения первого байта ответа. Включает:

• DNS resolution
• TCP/TLS handshake
• server processing time
• network latency

Основные направления оптимизации:

1. Сетевой уровень:

   • CDN для статики и кэширования динамических ответов
   • HTTP/2 multiplexing уменьшает количество соединений
   • HTTP/3 (QUIC) снижает latency за счёт 0-RTT
   • Keep-alive и connection pooling
   • Выбор сервера ближе к пользователям (edge computing)

2. Серверный уровень (Node.js):

   • Кэширование в памяти (Redis, in-memory cache)
   • Оптимизация middleware: минимизировать цепочки, вынести тяжёлые операции в очередь
   • Асинхронная обработка без блокировки event loop
   • Пул соединений к БД и внешним API
   • Предварительное прогревание (warm-up) кэшей и соединений
   • Использование cluster mode для параллельной обработки
   • Оптимизация парсинга тела запроса (streaming вместо буферизации)

3. Архитектурные решения:

   • Server-Side Rendering с streaming (React Suspense, Next.js)
   • Edge Functions для географически распределённой обработки
   • Асинхронная генерация контента (send early hints, 103 Early Hints)
   • Минимизация блокирующих операций в критическом пути запроса

На практике

Для Node.js приложений:

• Используйте app.use(compression()) для сжатия ответов
• Настройте HTTP-кеширование через заголовки Cache-Control, ETag
• В Express минимизируйте middleware: выносите аутентификацию и логирование в отдельные потоки
• Для SSR используйте renderToPipeableStream вместо renderToString
• Применяйте Redis для кэширования результатов тяжёлых запросов
• Включите cluster или PM2 для использования всех ядер CPU
• Используйте http.Server с keepAliveTimeout для переиспользования соединений

Пример настройки keep-alive:

JAVASCRIPT
const server = http.createServer(app);
server.keepAliveTimeout = 5000; // 5 секунд
server.headersTimeout = 6000;

Пример кода

JAVASCRIPT
// Оптимизация Express-приложения
const express = require('express');
const compression = require('compression');
const redis = require('redis');
const client = redis.createClient();

const app = express();

// Сжатие ответов
app.use(compression());

// Кэширование в Redis
app.get('/api/data', async (req, res) => {
  const cacheKey = 'data';
  const cached = await client.get(cacheKey);
  if (cached) {
    res.set('X-Cache', 'HIT');
    return res.json(JSON.parse(cached));
  }
  
  const data = await fetchData(); // тяжёлая операция
  await client.setEx(cacheKey, 60, JSON.stringify(data));
  res.set('X-Cache', 'MISS');
  res.json(data);
});

// Streaming SSR
app.get('/page', (req, res) => {
  const stream = renderToPipeableStream(<App />, {
    onShellReady() {
      res.setHeader('Content-Type', 'text/html');
      stream.pipe(res);
    }
  });
});

Как отвечать на собеседовании

Начните с определения TTFB и его составляющих. Затем перечислите основные категории оптимизаций: сетевые, серверные, архитектурные. Для каждой приведите конкретный пример из Node.js. Упомяните trade-off: кэширование увеличивает сложность инвалидации, streaming требует особой обработки ошибок. Покажите понимание, что TTFB - не единственная метрика, и важно балансировать с FCP и LCP. Завершите практическим советом: измерять TTFB через Performance API и мониторить в production.

Что проверяет интервьюер

• Понимание полного цикла запроса от клиента до сервера
• Знание особенностей Node.js: event loop, блокирующие операции, cluster
• Умение выбирать между кэшированием, streaming и предварительной генерацией
• Практический опыт с инструментами: CDN, Redis, HTTP/2
• Способность оценивать trade-off: скорость vs сложность vs стоимость

Типичные ошибки

• Фокус только на клиентских оптимизациях (preconnect, prefetch) без серверных
• Игнорирование сетевых задержек (DNS, TLS) и предложение только кэширования
• Предложение сжатия без учёта, что оно увеличивает CPU time на сервере
• Забывают про keep-alive и connection pooling в Node.js
• Путают TTFB с FCP или LCP
• Предлагают синхронные блокирующие операции в критическом пути запроса