new Agent([options])

• options <Object> Набор параметров агента. Может содержать следующие поля:
  • keepAlive <boolean> Сохранять сокеты открытыми, даже если нет невыполненных запросов, чтобы использовать их для будущих запросов без повторного установления TCP-соединения. Не следует путать со значением keep-alive заголовка Connection. При использовании агента заголовок Connection: keep-alive отправляется всегда, кроме случаев, когда явно указан заголовок Connection или параметры keepAlive и maxSockets соответственно установлены в false и Infinity; в этом случае будет использоваться Connection: close. По умолчанию: false.
  • keepAliveMsecs <number> При использовании параметра keepAlive задаёт начальную задержку для пакетов TCP Keep-Alive. Игнорируется, если параметр keepAlive равен false или undefined. По умолчанию: 1000.
  • agentKeepAliveTimeoutBuffer <number> Количество миллисекунд, вычитаемое из подсказки keep-alive: timeout=..., предоставленной сервером, при определении времени истечения срока действия сокета. Этот запас помогает агенту закрыть сокет немного раньше сервера и снижает вероятность отправки запроса через сокет, который сервер собирается закрыть. По умолчанию: 1000.
  • maxSockets <number> Максимальное количество сокетов на хост. Если один и тот же хост открывает несколько одновременных соединений, для каждого запроса будет использоваться новый сокет, пока не будет достигнуто значение maxSockets. Если хост попытается открыть больше соединений, чем maxSockets, дополнительные запросы попадут в очередь ожидания и перейдут в активное состояние соединения после завершения существующего соединения. Это гарантирует, что от одного хоста одновременно будет открыто не более maxSockets активных соединений. По умолчанию: Infinity.
  • maxTotalSockets <number> Максимальное общее количество сокетов для всех хостов. Для каждого запроса будет использоваться новый сокет, пока не будет достигнут этот предел. По умолчанию: Infinity.
  • maxFreeSockets <number> Максимальное количество сокетов на хост, остающихся открытыми в свободном состоянии. Применяется только если keepAlive установлено в true. По умолчанию: 256.
  • scheduling <string> Стратегия планирования, применяемая при выборе следующего свободного сокета. Возможные значения: 'fifo' или 'lifo'. Главное различие между этими стратегиями планирования состоит в том, что 'lifo' выбирает сокет, использовавшийся последним, а 'fifo' — сокет, который дольше всего не использовался. При небольшом количестве запросов в секунду планирование 'lifo' снижает риск выбора сокета, который сервер мог закрыть из-за бездействия. При большом количестве запросов в секунду планирование 'fifo' позволяет увеличить количество открытых сокетов, а планирование 'lifo' — свести его к минимуму. По умолчанию: 'lifo'.
  • timeout <number> Тайм-аут сокета в миллисекундах. Устанавливает тайм-аут при создании сокета.
  • proxyEnv <Object> | <undefined> Переменные среды для настройки прокси. Подробнее см. в разделе Встроенная поддержка прокси. По умолчанию: undefined
    • HTTP_PROXY <string> | <undefined> URL прокси-сервера, который должны использовать HTTP-запросы. Если значение не определено, для HTTP-запросов прокси не используется.
    • HTTPS_PROXY <string> | <undefined> URL прокси-сервера, который должны использовать HTTPS-запросы. Если значение не определено, для HTTPS-запросов прокси не используется.
    • NO_PROXY <string> | <undefined> Шаблоны, задающие конечные точки, запросы к которым не следует направлять через прокси.
    • http_proxy <string> | <undefined> То же, что и HTTP_PROXY. Если заданы оба параметра, приоритет имеет http_proxy.
    • https_proxy <string> | <undefined> То же, что и HTTPS_PROXY. Если заданы оба параметра, приоритет имеет https_proxy.
    • no_proxy <string> | <undefined> То же, что и NO_PROXY. Если заданы оба параметра, приоритет имеет no_proxy.
  • defaultPort <number> Порт по умолчанию, используемый, если порт не указан в запросе. По умолчанию: 80.
  • protocol <string> Протокол, используемый агентом. По умолчанию: 'http:'.

Также поддерживаются options в socket.connect().

Чтобы настроить любой из них, необходимо создать собственный экземпляр http.Agent.

import { Agent, request } from 'node:http';
const keepAliveAgent = new Agent({ keepAlive: true });
options.agent = keepAliveAgent;
request(options, onResponseCallback);

const http = require('node:http');
const keepAliveAgent = new http.Agent({ keepAlive: true });
options.agent = keepAliveAgent;
http.request(options, onResponseCallback);

agent.createConnection(options[, callback])

• options <Object> Параметры, содержащие сведения о соединении. Формат параметров см. в разделе net.createConnection(). Для пользовательских агентов этот объект передаётся пользовательской функции createConnection.
• callback <Function> (Необязательная, в основном для пользовательских агентов) Функция, вызываемая пользовательской реализацией createConnection при создании сокета, особенно для асинхронных операций.
  • err <Error> | <null> Объект ошибки, если создание сокета завершилось неудачно.
  • socket <stream.Duplex> Созданный сокет.
• Возвращает: <stream.Duplex> Созданный сокет. Он возвращается реализацией по умолчанию или пользовательской синхронной реализацией createConnection. Если пользовательская функция createConnection использует callback для асинхронной операции, это возвращаемое значение может быть не основным способом получения сокета.

Создаёт сокет/поток для использования HTTP-запросами.

По умолчанию эта функция ведёт себя так же, как net.createConnection(), и синхронно возвращает созданный сокет. Необязательный параметр callback в сигнатуре не используется этой реализацией по умолчанию.

Однако пользовательские агенты могут переопределить этот метод, чтобы обеспечить большую гибкость, например создавать сокеты асинхронно. При переопределении createConnection:

1. Синхронное создание сокета: переопределённый метод может непосредственно возвращать сокет/поток.
2. Асинхронное создание сокета: переопределённый метод может принимать callback и передавать ему созданный сокет/поток (например, callback(null, newSocket)). Если при создании сокета произошла ошибка, её следует передать в качестве первого аргумента в callback (например, callback(err)).

Агент вызовет переданную функцию createConnection с options и этим внутренним callback. У callback, предоставляемого агентом, сигнатура (err, stream).

agent.keepSocketAlive(socket)

• socket <stream.Duplex>

Вызывается, когда socket отсоединяется от запроса и может быть сохранён Agent. Поведение по умолчанию:

socket.setKeepAlive(true, this.keepAliveMsecs);
socket.unref();
return true; copy

Этот метод можно переопределить в конкретном подклассе Agent. Если метод возвращает ложное значение, сокет будет уничтожен, а не сохранён для использования со следующим запросом.

Аргумент socket может быть экземпляром <net.Socket>, подклассом <stream.Duplex>.

agent.reuseSocket(socket, request)

• socket <stream.Duplex>
• request <http.ClientRequest>

Вызывается, когда socket присоединяется к request после сохранения благодаря параметрам keep-alive. Поведение по умолчанию:

socket.ref(); copy

Этот метод можно переопределить в конкретном подклассе Agent.

Аргумент socket может быть экземпляром <net.Socket>, подклассом <stream.Duplex>.

agent.destroy()

Уничтожает все сокеты, используемые в данный момент агентом.

Обычно в этом нет необходимости. Однако при использовании агента с включённым keepAlive рекомендуется явно завершить работу агента, когда он больше не нужен. В противном случае сокеты могут оставаться открытыми довольно долго, пока сервер не закроет их.

agent.freeSockets

• Тип: <Object>

Объект, содержащий массивы сокетов, ожидающих использования агентом при включённом keepAlive. Не изменяйте его.

Сокеты в списке freeSockets автоматически уничтожаются и удаляются из массива при событии 'timeout'.

agent.getName([options])

• options <Object> Набор параметров с данными для формирования имени
  • host <string> Доменное имя или IP-адрес сервера, которому будет отправлен запрос
  • port <number> Порт удалённого сервера
  • localAddress <string> Локальный интерфейс, к которому привязываются сетевые соединения при отправке запроса
  • family <integer> Должно быть равно 4 или 6, если это значение не равно undefined.
• Возвращает: <string>

Возвращает уникальное имя для набора параметров запроса, чтобы определить, можно ли повторно использовать соединение. Для HTTP-агента возвращается host:port:localAddress или host:port:localAddress:family. Для HTTPS-агента имя включает CA, сертификат, шифры и другие параметры, специфичные для HTTPS/TLS, которые определяют возможность повторного использования сокета.

agent.maxFreeSockets

• Тип: <number>

По умолчанию установлено значение 256. Для агентов с включённым keepAlive задаёт максимальное количество сокетов, которые останутся открытыми в свободном состоянии.

agent.maxSockets

• Тип: <number>

По умолчанию установлено значение Infinity. Определяет количество одновременных сокетов, которые агент может открыть для одного источника. Источник — это значение, возвращаемое методом agent.getName().

agent.maxTotalSockets

• Тип: <number>

По умолчанию установлено значение Infinity. Определяет количество одновременных сокетов, которые агент может открыть. В отличие от maxSockets, этот параметр применяется ко всем источникам.

agent.requests

• Тип: <Object>

Объект, содержащий очереди запросов, которым ещё не назначены сокеты. Не изменяйте его.

agent.sockets

• Тип: <Object>

Объект, содержащий массивы сокетов, используемых в данный момент агентом. Не изменяйте его.

Событие: 'abort'

Генерируется, когда клиент прервал запрос. Это событие генерируется только при первом вызове abort().

Событие: 'close'

Указывает, что запрос завершён либо базовое соединение было преждевременно разорвано (до завершения ответа).

Событие: 'connect'

• response <http.IncomingMessage>
• socket <stream.Duplex>
• head <Buffer>

Генерируется каждый раз, когда сервер отвечает на запрос методом CONNECT. Если это событие не прослушивается, соединения клиентов, получивших ответ методом CONNECT, будут закрыты.

В качестве аргумента этого события гарантированно передаётся экземпляр класса <net.Socket> — подкласса <stream.Duplex>, если только пользователь не указал тип сокета, отличный от <net.Socket>.

Пример клиента и сервера, демонстрирующий прослушивание события 'connect':

import { createServer, request } from 'node:http';
import { connect } from 'node:net';
import { URL } from 'node:url';

// Create an HTTP tunneling proxy
const proxy = createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
proxy.on('connect', (req, clientSocket, head) => {
  // Connect to an origin server
  const { port, hostname } = new URL(`http://${req.url}`);
  const serverSocket = connect(port || 80, hostname, () => {
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n' +
                    'Proxy-agent: Node.js-Proxy\r\n' +
                    '\r\n');
    serverSocket.write(head);
    serverSocket.pipe(clientSocket);
    clientSocket.pipe(serverSocket);
  });
});

// Now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {

  // Make a request to a tunneling proxy
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80',
  };

  const req = request(options);
  req.end();

  req.on('connect', (res, socket, head) => {
    console.log('got connected!');

    // Make a request over an HTTP tunnel
    socket.write('GET / HTTP/1.1\r\n' +
                 'Host: www.google.com:80\r\n' +
                 'Connection: close\r\n' +
                 '\r\n');
    socket.on('data', (chunk) => {
      console.log(chunk.toString());
    });
    socket.on('end', () => {
      proxy.close();
    });
  });
});

const http = require('node:http');
const net = require('node:net');
const { URL } = require('node:url');

// Create an HTTP tunneling proxy
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
proxy.on('connect', (req, clientSocket, head) => {
  // Connect to an origin server
  const { port, hostname } = new URL(`http://${req.url}`);
  const serverSocket = net.connect(port || 80, hostname, () => {
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n' +
                    'Proxy-agent: Node.js-Proxy\r\n' +
                    '\r\n');
    serverSocket.write(head);
    serverSocket.pipe(clientSocket);
    clientSocket.pipe(serverSocket);
  });
});

// Now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {

  // Make a request to a tunneling proxy
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80',
  };

  const req = http.request(options);
  req.end();

  req.on('connect', (res, socket, head) => {
    console.log('got connected!');

    // Make a request over an HTTP tunnel
    socket.write('GET / HTTP/1.1\r\n' +
                 'Host: www.google.com:80\r\n' +
                 'Connection: close\r\n' +
                 '\r\n');
    socket.on('data', (chunk) => {
      console.log(chunk.toString());
    });
    socket.on('end', () => {
      proxy.close();
    });
  });
});

Событие: 'continue'

Генерируется, когда сервер отправляет HTTP-ответ «100 Continue», обычно потому, что запрос содержал «Expect: 100-continue». Это указание клиенту отправить тело запроса.

Событие: 'finish'

Генерируется после отправки запроса. Точнее, это событие генерируется, когда последний фрагмент заголовков и тела запроса передан операционной системе для отправки по сети. Это не означает, что сервер уже что-либо получил.

Событие: 'information'

• info <Object>
  • httpVersion <string>
  • httpVersionMajor <integer>
  • httpVersionMinor <integer>
  • statusCode <integer>
  • statusMessage <string>
  • headers <Object>
  • rawHeaders <string[]>

Генерируется, когда сервер отправляет промежуточный ответ 1xx (за исключением 101 Upgrade). Слушатели этого события получают объект с версией HTTP, кодом состояния, сообщением о состоянии, объектом заголовков «ключ-значение» и массивом исходных имён заголовков, за которыми следуют соответствующие значения.

import { request } from 'node:http';

const options = {
  host: '127.0.0.1',
  port: 8080,
  path: '/length_request',
};

// Make a request
const req = request(options);
req.end();

req.on('information', (info) => {
  console.log(`Got information prior to main response: ${info.statusCode}`);
});

const http = require('node:http');

const options = {
  host: '127.0.0.1',
  port: 8080,
  path: '/length_request',
};

// Make a request
const req = http.request(options);
req.end();

req.on('information', (info) => {
  console.log(`Got information prior to main response: ${info.statusCode}`);
});

События со статусом 101 Upgrade не генерируются, поскольку они разрывают традиционную цепочку HTTP-запроса и ответа, например при использовании веб-сокетов, обновлении TLS на существующем соединении или HTTP 2.0. Чтобы получать уведомления 101 Upgrade, прослушивайте событие 'upgrade'.

Событие: 'response'

• response <http.IncomingMessage>

Генерируется при получении ответа на этот запрос. Это событие генерируется только один раз.

Событие: 'socket'

• socket <stream.Duplex>

В качестве аргумента этого события гарантированно передаётся экземпляр класса <net.Socket> — подкласса <stream.Duplex>, если только пользователь не указал тип сокета, отличный от <net.Socket>.

Событие: 'timeout'

Генерируется при тайм-ауте базового сокета из-за отсутствия активности. Это лишь уведомление о том, что сокет простаивает. Запрос необходимо уничтожить вручную.

См. также: request.setTimeout().

Событие: 'upgrade'

• response <http.IncomingMessage>
• socket <stream.Duplex>
• head <Buffer>

Генерируется каждый раз, когда сервер отвечает на запрос обновлением протокола. Если это событие не прослушивается, а код состояния ответа равен 101 Switching Protocols, соединения клиентов, получивших заголовок обновления, будут закрыты.

В качестве аргумента этого события гарантированно передаётся экземпляр класса <net.Socket> — подкласса <stream.Duplex>, если только пользователь не указал тип сокета, отличный от <net.Socket>.

Пример клиента и сервера, демонстрирующий прослушивание события 'upgrade'.

import http from 'node:http';
import process from 'node:process';

// Create an HTTP server
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
server.on('upgrade', (req, socket, head) => {
  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
               'Upgrade: WebSocket\r\n' +
               'Connection: Upgrade\r\n' +
               '\r\n');

  socket.pipe(socket); // echo back
});

// Now that server is running
server.listen(1337, '127.0.0.1', () => {

  // make a request
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      'Connection': 'Upgrade',
      'Upgrade': 'websocket',
    },
  };

  const req = http.request(options);
  req.end();

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!');
    socket.end();
    process.exit(0);
  });
});

const http = require('node:http');

// Create an HTTP server
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
server.on('upgrade', (req, socket, head) => {
  socket.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
               'Upgrade: WebSocket\r\n' +
               'Connection: Upgrade\r\n' +
               '\r\n');

  socket.pipe(socket); // echo back
});

// Now that server is running
server.listen(1337, '127.0.0.1', () => {

  // make a request
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      'Connection': 'Upgrade',
      'Upgrade': 'websocket',
    },
  };

  const req = http.request(options);
  req.end();

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!');
    socket.end();
    process.exit(0);
  });
});

request.abort()

Помечает запрос как прерываемый. Вызов этого метода приведёт к отбрасыванию оставшихся данных ответа и уничтожению сокета.

request.aborted

• Тип: <boolean>

Свойство request.aborted будет иметь значение true, если запрос был прерван.

request.connection

• Тип: <stream.Duplex>

См. request.socket.

request.cork()

См. writable.cork().

request.end([data[, encoding]][, callback])

• data <string> | <Buffer> | <Uint8Array>
• encoding <string>
• callback <Function>
• Возвращает: <this>

Завершает отправку запроса. Если остались неотправленные части тела, они будут переданы в поток. Если запрос использует передачу данных по частям, будет отправлен завершающий '0\r\n\r\n'.

Если указано data, это эквивалентно вызову request.write(data, encoding), за которым следует request.end(callback).

Если указано callback, оно будет вызвано после завершения потока запроса.

request.destroy([error])

• error <Error> Необязательная ошибка, передаваемая вместе с событием 'error'.
• Возвращает: <this>

Уничтожает запрос. При необходимости генерирует событие 'error' и генерирует событие 'close'. Вызов этого метода приведёт к отбрасыванию оставшихся данных ответа и уничтожению сокета.

Подробнее см. writable.destroy().

request.finished

• Тип: <boolean>

Свойство request.finished будет иметь значение true, если был вызван метод request.end(). request.end() будет автоматически вызван, если запрос инициирован через http.get().

request.flushHeaders()

Отправляет заголовки запроса.

Для повышения эффективности Node.js обычно буферизует заголовки запроса до вызова request.end() или записи первого фрагмента данных запроса. Затем программа пытается упаковать заголовки и данные запроса в один TCP-пакет.

Обычно это желательно (экономит один цикл обмена данными TCP), но не в тех случаях, когда первая порция данных будет отправлена нескоро. request.flushHeaders() отключает эту оптимизацию и инициирует отправку запроса.

request.getHeader(name)

• name <string>
• Возвращает: <any>

Возвращает значение заголовка запроса. Имя заголовка нечувствительно к регистру. Тип возвращаемого значения зависит от аргументов, переданных в request.setHeader().

request.setHeader('content-type', 'text/html');
request.setHeader('Content-Length', Buffer.byteLength(body));
request.setHeader('Cookie', ['type=ninja', 'language=javascript']);
const contentType = request.getHeader('Content-Type');
// 'contentType' is 'text/html'
const contentLength = request.getHeader('Content-Length');
// 'contentLength' is of type number
const cookie = request.getHeader('Cookie');
// 'cookie' is of type string[] copy

request.getHeaderNames()

• Возвращает: <string[]>

Возвращает массив с уникальными именами текущих исходящих заголовков. Все имена заголовков записаны в нижнем регистре.

request.setHeader('Foo', 'bar');
request.setHeader('Cookie', ['foo=bar', 'bar=baz']);

const headerNames = request.getHeaderNames();
// headerNames === ['foo', 'cookie'] copy

request.getHeaders()

• Возвращает: <Object>

Возвращает поверхностную копию текущих исходящих заголовков. Поскольку используется поверхностная копия, значения-массивы можно изменять без дополнительных вызовов различных методов модуля http, связанных с заголовками. Ключами возвращаемого объекта являются имена заголовков, а значениями — соответствующие значения заголовков. Все имена заголовков записаны в нижнем регистре.

Объект, возвращаемый методом request.getHeaders(), не наследует прототип от JavaScript Object. Это означает, что стандартные методы Object, такие как obj.toString(), obj.hasOwnProperty() и другие, не определены и не будут работать.

request.setHeader('Foo', 'bar');
request.setHeader('Cookie', ['foo=bar', 'bar=baz']);

const headers = request.getHeaders();
// headers === { foo: 'bar', 'cookie': ['foo=bar', 'bar=baz'] } copy

request.getRawHeaderNames()

• Возвращает: <string[]>

Возвращает массив с уникальными именами текущих исходящих необработанных заголовков. Имена заголовков возвращаются с сохранением исходного регистра.

request.setHeader('Foo', 'bar');
request.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);

const headerNames = request.getRawHeaderNames();
// headerNames === ['Foo', 'Set-Cookie'] copy

request.hasHeader(name)

• name <string>
• Возвращает: <boolean>

Возвращает true, если заголовок с именем name в данный момент задан в исходящих заголовках. Сопоставление имён заголовков нечувствительно к регистру.

const hasContentType = request.hasHeader('content-type'); copy

request.maxHeadersCount

• Тип: <number> По умолчанию: 2000

Ограничивает максимальное количество заголовков ответа. Если задано значение 0, ограничение не применяется.

request.path

• Тип: <string> Путь запроса.

request.method

• Тип: <string> Метод запроса.

request.host

• Тип: <string> Хост запроса.

request.protocol

• Тип: <string> Протокол запроса.

request.removeHeader(name)

• name <string>

Удаляет заголовок, который уже задан в объекте заголовков.

request.removeHeader('Content-Type'); copy

request.reusedSocket

• Тип: <boolean> Указывает, отправляется ли запрос через повторно использованный сокет.

При отправке запроса через агент с включённым keep-alive базовый сокет может быть повторно использован. Но если сервер закроет соединение в неподходящий момент, на стороне клиента может возникнуть ошибка «ECONNRESET».

import http from 'node:http';
const agent = new http.Agent({ keepAlive: true });

// Server has a 5 seconds keep-alive timeout by default
http
  .createServer((req, res) => {
    res.write('hello\n');
    res.end();
  })
  .listen(3000);

setInterval(() => {
  // Adapting a keep-alive agent
  http.get('http://localhost:3000', { agent }, (res) => {
    res.on('data', (data) => {
      // Do nothing
    });
  });
}, 5000); // Sending request on 5s interval so it's easy to hit idle timeout

const http = require('node:http');
const agent = new http.Agent({ keepAlive: true });

// Server has a 5 seconds keep-alive timeout by default
http
  .createServer((req, res) => {
    res.write('hello\n');
    res.end();
  })
  .listen(3000);

setInterval(() => {
  // Adapting a keep-alive agent
  http.get('http://localhost:3000', { agent }, (res) => {
    res.on('data', (data) => {
      // Do nothing
    });
  });
}, 5000); // Sending request on 5s interval so it's easy to hit idle timeout

Отметив, использовал ли запрос повторно сокет, можно автоматически повторять запрос при ошибке с учётом этого значения.

import http from 'node:http';
const agent = new http.Agent({ keepAlive: true });

function retriableRequest() {
  const req = http
    .get('http://localhost:3000', { agent }, (res) => {
      // ...
    })
    .on('error', (err) => {
      // Check if retry is needed
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest();
      }
    });
}

retriableRequest();

const http = require('node:http');
const agent = new http.Agent({ keepAlive: true });

function retriableRequest() {
  const req = http
    .get('http://localhost:3000', { agent }, (res) => {
      // ...
    })
    .on('error', (err) => {
      // Check if retry is needed
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest();
      }
    });
}

retriableRequest();

request.setHeader(name, value)

• name <string>
• value <any>

Задаёт одно значение заголовка в объекте заголовков. Если такой заголовок уже есть среди заголовков, ожидающих отправки, его значение будет заменено. Чтобы отправить несколько заголовков с одинаковым именем, используйте массив строк. Значения, не являющиеся строками, сохраняются без изменений. Поэтому request.getHeader() может возвращать значения, не являющиеся строками. Однако при передаче по сети такие значения будут преобразованы в строки.

request.setHeader('Content-Type', 'application/json'); copy

или

request.setHeader('Cookie', ['type=ninja', 'language=javascript']); copy

Если значение является строкой, будет выброшено исключение, если она содержит символы, не входящие в кодировку latin1.

Если необходимо передать в значении символы UTF-8, закодируйте значение в соответствии со стандартом RFC 8187.

const filename = 'Rock 🎵.txt';
request.setHeader('Content-Disposition', `attachment; filename*=utf-8''${encodeURIComponent(filename)}`); copy

request.setNoDelay([noDelay])

• noDelay <boolean>

После назначения сокета этому запросу и установления соединения будет вызван socket.setNoDelay().

request.setSocketKeepAlive([enable][, initialDelay])

• enable <boolean>
• initialDelay <number>

После назначения сокета этому запросу и установления соединения будет вызван socket.setKeepAlive().

request.setTimeout(timeout[, callback])

• timeout <number> Время в миллисекундах до истечения времени ожидания запроса.
• callback <Function> Необязательная функция, вызываемая при истечении времени ожидания. Эквивалентна привязке к событию 'timeout'.
• Возвращает: <http.ClientRequest>

После назначения сокета этому запросу и установления соединения будет вызван socket.setTimeout().

request.socket

• Тип: <stream.Duplex>

Ссылка на базовый сокет. Обычно пользователям не требуется обращаться к этому свойству. В частности, сокет не будет генерировать события 'readable' из-за того, как синтаксический анализатор протокола подключается к сокету.

import http from 'node:http';
const options = {
  host: 'www.google.com',
};
const req = http.get(options);
req.end();
req.once('response', (res) => {
  const ip = req.socket.localAddress;
  const port = req.socket.localPort;
  console.log(`Your IP address is ${ip} and your source port is ${port}.`);
  // Consume response object
});

const http = require('node:http');
const options = {
  host: 'www.google.com',
};
const req = http.get(options);
req.end();
req.once('response', (res) => {
  const ip = req.socket.localAddress;
  const port = req.socket.localPort;
  console.log(`Your IP address is ${ip} and your source port is ${port}.`);
  // Consume response object
});

Это свойство гарантированно содержит экземпляр класса <net.Socket> — подкласса <stream.Duplex>, если только пользователь не указал тип сокета, отличный от <net.Socket>.

request.uncork()

См. writable.uncork().

request.writableEnded

• Тип: <boolean>

Имеет значение true после вызова request.end(). Это свойство не указывает, были ли данные сброшены в поток; для этого используйте request.writableFinished.

request.writableFinished

• Тип: <boolean>

Имеет значение true, если все данные сброшены в базовую систему непосредственно перед генерацией события 'finish'.

request.write(chunk[, encoding][, callback])

• chunk <string> | <Buffer> | <Uint8Array>
• encoding <string>
• callback <Function>
• Возвращает: <boolean>

Отправляет часть тела запроса. Этот метод можно вызывать несколько раз. Если Content-Length не задан, данные автоматически кодируются с использованием передачи HTTP Chunked, чтобы сервер знал, когда данные заканчиваются. Добавляется заголовок Transfer-Encoding: chunked. Для завершения отправки запроса необходимо вызвать request.end().

Аргумент encoding необязателен и применяется только в том случае, если chunk имеет тип string. По умолчанию используется 'utf8'.

Аргумент callback необязателен. Он будет вызван после сброса этой части данных, но только если часть не пуста.

Возвращает true, если все данные успешно сброшены в буфер ядра. Возвращает false, если все данные или их часть поставлены в очередь в памяти пользователя. Событие 'drain' будет создано, когда буфер снова освободится.

Если функция write вызывается с пустой строкой или буфером, она ничего не делает и ожидает новые данные.

Событие: 'checkContinue'

• request <http.IncomingMessage>
• response <http.ServerResponse>

Вызывается при получении каждого запроса с HTTP-заголовком Expect: 100-continue. Если обработчик этого события не задан, сервер автоматически отправит соответствующий ответ 100 Continue.

Обработка этого события предполагает вызов response.writeContinue(), если клиенту следует продолжить отправку тела запроса, либо формирование соответствующего HTTP-ответа (например, 400 Bad Request), если клиенту не следует продолжать отправку тела запроса.

Если это событие вызвано и обработано, событие 'request' вызвано не будет.

Событие: 'checkExpectation'

• request <http.IncomingMessage>
• response <http.ServerResponse>

Вызывается при получении каждого запроса с HTTP-заголовком Expect, значение которого не равно 100-continue. Если обработчик этого события не задан, сервер автоматически отправит соответствующий ответ 417 Expectation Failed.

Если это событие вызвано и обработано, событие 'request' вызвано не будет.

Событие: 'clientError'

• exception <Error>
• socket <stream.Duplex>

Если клиентское соединение генерирует событие 'error', оно будет передано сюда. Обработчик этого события отвечает за закрытие или уничтожение базового сокета. Например, вместо резкого разрыва соединения можно закрыть сокет более корректно, отправив пользовательский HTTP-ответ. До завершения работы обработчика сокет должен быть закрыт или уничтожен.

Гарантируется, что событию будет передан экземпляр класса <net.Socket>, подкласса <stream.Duplex>, если только пользователь не укажет тип сокета, отличный от <net.Socket>.

По умолчанию предпринимается попытка закрыть сокет с ответом HTTP '400 Bad Request' или HTTP '431 Request Header Fields Too Large' в случае ошибки HPE_HEADER_OVERFLOW. Если сокет недоступен для записи или заголовки текущего связанного http.ServerResponse уже отправлены, сокет немедленно уничтожается.

socket — это объект net.Socket, в котором возникла ошибка.

import http from 'node:http';

const server = http.createServer((req, res) => {
  res.end();
});
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
});
server.listen(8000);

const http = require('node:http');

const server = http.createServer((req, res) => {
  res.end();
});
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
});
server.listen(8000);

При возникновении события 'clientError' объект request или response отсутствует, поэтому любой HTTP-ответ, включая заголовки и полезную нагрузку, необходимо записывать непосредственно в объект socket. Следует убедиться, что ответ представляет собой правильно отформатированное HTTP-сообщение.

err — это экземпляр Error с двумя дополнительными полями:

• bytesParsed: количество байтов пакета запроса, которые Node.js, возможно, успешно обработал;
• rawPacket: необработанный пакет текущего запроса.

В некоторых случаях клиент уже получил ответ и/или сокет уже уничтожен, например при ошибках ECONNRESET. Перед отправкой данных в сокет рекомендуется проверить, доступен ли он для записи.

server.on('clientError', (err, socket) => {
  if (err.code === 'ECONNRESET' || !socket.writable) {
    return;
  }

  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
}); copy

Событие: 'close'

Вызывается при закрытии сервера.

Событие: 'connect'

• request <http.IncomingMessage> Аргументы HTTP-запроса, как и в событии 'request'
• socket <stream.Duplex> Сетевой сокет между сервером и клиентом
• head <Buffer> Первый пакет туннельного потока (может быть пустым)

Вызывается каждый раз, когда клиент отправляет HTTP-запрос с методом CONNECT. Если обработчик этого события не задан, соединения клиентов, запрашивающих метод CONNECT, будут закрыты.

Гарантируется, что событию будет передан экземпляр класса <net.Socket>, подкласса <stream.Duplex>, если только пользователь не укажет тип сокета, отличный от <net.Socket>.

После вызова этого события у сокета запроса не будет обработчика события 'data', поэтому его необходимо назначить для обработки данных, отправленных серверу через этот сокет.

Событие: 'connection'

• socket <stream.Duplex>

Это событие вызывается при установлении нового потока TCP. Обычно socket — это объект типа net.Socket. Как правило, пользователям не требуется обращаться к этому событию. В частности, сокет не будет генерировать события 'readable' из-за того, как анализатор протокола подключается к сокету. Доступ к socket также можно получить через request.socket.

Пользователи также могут явно вызвать это событие, чтобы передать соединения HTTP-серверу. В этом случае можно передать любой поток Duplex.

Если здесь вызывается socket.setTimeout(), тайм-аут будет заменён на server.keepAliveTimeout после обработки сокетом запроса (если server.keepAliveTimeout не равен нулю).

Гарантируется, что событию будет передан экземпляр класса <net.Socket>, подкласса <stream.Duplex>, если только пользователь не укажет тип сокета, отличный от <net.Socket>.

Событие: 'dropRequest'

• request <http.IncomingMessage> Аргументы HTTP-запроса, как и в событии 'request'
• socket <stream.Duplex> Сетевой сокет между сервером и клиентом

Когда число запросов через сокет достигает порогового значения server.maxRequestsPerSocket, сервер отклоняет новые запросы и вместо этого вызывает событие 'dropRequest', после чего отправляет клиенту 503.

Событие: 'request'

• request <http.IncomingMessage>
• response <http.ServerResponse>

Вызывается при каждом запросе. Для одного соединения может быть несколько запросов (в случае соединений HTTP Keep-Alive).

Событие: 'upgrade'

• request <http.IncomingMessage> Аргументы HTTP-запроса, как и в событии 'request'
• socket <stream.Duplex> Сетевой сокет между сервером и клиентом
• head <Buffer> Первый пакет переключённого потока (может быть пустым)

Вызывается каждый раз, когда принимается запрос клиента на переключение протокола HTTP. По умолчанию все запросы на переключение протокола HTTP игнорируются (то есть вызываются только обычные события 'request', сохраняющие стандартный поток запросов и ответов HTTP), если только вы не добавите обработчик этого события. В этом случае все такие запросы принимаются (то есть вместо него вызывается событие 'upgrade', а дальнейшее взаимодействие должно выполняться напрямую через необработанный сокет). Более точно управлять этим поведением можно с помощью параметра сервера shouldUpgradeCallback.

Обработчик этого события необязателен, и клиенты не могут настаивать на смене протокола.

После вызова этого события у сокета запроса не будет обработчика события 'data', поэтому его необходимо назначить для обработки данных, отправленных серверу через этот сокет.

Если shouldUpgradeCallback принимает запрос на переключение протокола, но обработчик события не зарегистрирован, сокет уничтожается, что приводит к немедленному закрытию соединения с клиентом.

Гарантируется, что событию будет передан экземпляр класса <net.Socket>, подкласса <stream.Duplex>, если только пользователь не укажет тип сокета, отличный от <net.Socket>.

server.close([callback])

• callback <Function>

Прекращает приём новых соединений сервером и закрывает все соединения с этим сервером, через которые не отправляется запрос и не ожидается ответ. См. net.Server.close().

const http = require('node:http');

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({
    data: 'Hello World!',
  }));
});

server.listen(8000);
// Close the server after 10 seconds
setTimeout(() => {
  server.close(() => {
    console.log('server on port 8000 closed successfully');
  });
}, 10000); copy

server.closeAllConnections()

Закрывает все установленные HTTP(S)-соединения с этим сервером, включая активные соединения, через которые отправляется запрос или ожидается ответ. Метод не уничтожает сокеты, переключённые на другой протокол, например WebSocket или HTTP/2.

Это принудительный способ закрытия всех соединений, и использовать его следует с осторожностью. При использовании вместе с server.close рекомендуется вызывать этот метод после server.close, чтобы избежать состояний гонки, при которых новые соединения создаются между вызовами этого метода и server.close.

const http = require('node:http');

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({
    data: 'Hello World!',
  }));
});

server.listen(8000);
// Close the server after 10 seconds
setTimeout(() => {
  server.close(() => {
    console.log('server on port 8000 closed successfully');
  });
  // Closes all connections, ensuring the server closes successfully
  server.closeAllConnections();
}, 10000); copy

server.closeIdleConnections()

Закрывает все соединения с этим сервером, через которые не отправляется запрос и не ожидается ответ.

Начиная с Node.js 19.0.0, для закрытия неактивных соединений keep-alive больше не требуется вызывать этот метод вместе с server.close. Его вызов не причинит вреда, а также может быть полезен для обеспечения обратной совместимости библиотек и приложений, которым необходимо поддерживать версии ниже 19.0.0. При использовании вместе с server.close рекомендуется вызывать этот метод после server.close, чтобы избежать состояний гонки, при которых новые соединения создаются между вызовами этого метода и server.close.

const http = require('node:http');

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({
    data: 'Hello World!',
  }));
});

server.listen(8000);
// Close the server after 10 seconds
setTimeout(() => {
  server.close(() => {
    console.log('server on port 8000 closed successfully');
  });
  // Closes idle connections, such as keep-alive connections. Server will close
  // once remaining active connections are terminated
  server.closeIdleConnections();
}, 10000); copy

server.headersTimeout

• Тип: <number> По умолчанию: меньшее из значений server.requestTimeout и 60000.

Ограничивает время, в течение которого анализатор ожидает получения всех HTTP-заголовков.

Если время ожидания истекает, сервер отвечает со статусом 408, не передавая запрос обработчику запросов, а затем закрывает соединение.

Чтобы защититься от потенциальных атак типа «отказ в обслуживании», если сервер развёрнут без обратного прокси перед ним, необходимо задать ненулевое значение (например, 120 секунд).

server.listen()

Запускает HTTP-сервер для прослушивания соединений. Этот метод идентичен методу server.listen() класса net.Server.

server.listening

• Тип: <boolean> Указывает, прослушивает ли сервер соединения.

server.maxHeadersCount

• Тип: <number> По умолчанию: 2000

Ограничивает максимальное количество входящих заголовков. Если задано значение 0, ограничение не применяется.

server.requestTimeout

• Тип: <number> По умолчанию: 300000

Задаёт время ожидания в миллисекундах для получения полного запроса от клиента.

Если время ожидания истекает, сервер отвечает со статусом 408, не передавая запрос обработчику запросов, а затем закрывает соединение.

Чтобы защититься от потенциальных атак типа «отказ в обслуживании», если сервер развёрнут без обратного прокси перед ним, необходимо задать ненулевое значение (например, 120 секунд).

server.setTimeout([msecs][, callback])

• msecs <number> По умолчанию: 0 (без тайм-аута)
• callback <Function>
• Возвращает: <http.Server>

Задаёт значение тайм-аута для сокетов и при его истечении генерирует событие 'timeout' объекта Server, передавая сокет в качестве аргумента.

Если у объекта Server есть обработчик события 'timeout', он будет вызван с сокетом, для которого истёк тайм-аут, в качестве аргумента.

По умолчанию для сокетов Server тайм-аут не устанавливается. Однако, если для события 'timeout' объекта Server назначена функция обратного вызова, тайм-ауты необходимо обрабатывать явно.

server.maxRequestsPerSocket

• Тип: <number> Количество запросов на сокет. По умолчанию: 0 (без ограничений)

Максимальное количество запросов, которое может обработать сокет до закрытия keep-alive-соединения.

Значение 0 отключает ограничение.

При достижении ограничения значение заголовка Connection устанавливается в close, но соединение фактически не закрывается; на последующие запросы, отправленные после достижения ограничения, будет возвращаться ответ 503 Service Unavailable.

server.timeout

• Тип: <number> Тайм-аут в миллисекундах. По умолчанию: 0 (без тайм-аута)

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

Значение 0 отключает действие тайм-аута для входящих соединений.

Логика тайм-аута сокета настраивается при установлении соединения, поэтому изменение этого значения влияет только на новые соединения с сервером, но не на уже существующие.

server.keepAliveTimeout

• Тип: <number> Тайм-аут в миллисекундах. По умолчанию: 5000 (5 секунд).

Время бездействия в миллисекундах, в течение которого сервер должен ожидать дополнительные входящие данные после завершения отправки последнего ответа, прежде чем сокет будет уничтожен.

Это значение тайм-аута объединяется с параметром server.keepAliveTimeoutBuffer для определения фактического тайм-аута сокета, вычисляемого по формуле: socketTimeout = keepAliveTimeout + keepAliveTimeoutBuffer. Если сервер получает новые данные до срабатывания тайм-аута keep-alive, обычный тайм-аут бездействия, то есть server.timeout, будет сброшен.

Значение 0 отключает действие тайм-аута keep-alive для входящих соединений. Значение 0 заставляет HTTP-сервер работать аналогично версиям Node.js до 8.0.0, в которых не было тайм-аута keep-alive.

Логика тайм-аута сокета настраивается при установлении соединения, поэтому изменение этого значения влияет только на новые соединения с сервером, но не на уже существующие.

server.keepAliveTimeoutBuffer

• Тип: <number> Тайм-аут в миллисекундах. По умолчанию: 1000 (1 секунда).

Дополнительное время, добавляемое к параметру server.keepAliveTimeout для увеличения внутреннего тайм-аута сокета.

Этот запас времени помогает уменьшить количество ошибок сброса соединения (ECONNRESET), слегка увеличивая тайм-аут сокета относительно объявленного тайм-аута keep-alive.

Этот параметр применяется только к новым входящим соединениям.

server[Symbol.asyncDispose]()

Вызывает server.close() и возвращает промис, который выполняется после закрытия сервера.

Событие: 'close'

Указывает, что ответ завершён или его базовое соединение было преждевременно разорвано (до завершения ответа).

Событие: 'finish'

Возникает, когда ответ отправлен. Точнее, это событие возникает, когда последний сегмент заголовков и тела ответа передан операционной системе для отправки по сети. Это не означает, что клиент уже что-либо получил.

response.addTrailers(headers)

• headers <Object>

Этот метод добавляет к ответу завершающие HTTP-заголовки (заголовки в конце сообщения).

Завершающие заголовки будут отправлены только при использовании для ответа сегментированного кодирования; если оно не используется (например, если запрос был HTTP/1.0), они будут молча отброшены.

Для отправки завершающих заголовков HTTP требует передать заголовок Trailer со списком полей заголовков в его значении. Например:

response.writeHead(200, { 'Content-Type': 'text/plain',
                          'Trailer': 'Content-MD5' });
response.write(fileData);
response.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });
response.end(); copy

Попытка задать имя или значение поля заголовка, содержащие недопустимые символы, приведёт к выбросу TypeError.

response.connection

• Тип: <stream.Duplex>

См. response.socket.

response.cork()

См. writable.cork().

response.end([data[, encoding]][, callback])

• data <string> | <Buffer> | <Uint8Array>
• encoding <string>
• callback <Function>
• Возвращает: <this>

Этот метод сообщает серверу, что все заголовки и тело ответа отправлены; сервер должен считать это сообщение завершённым. Метод response.end() необходимо вызвать для каждого ответа.

Если указан data, его действие аналогично вызову response.write(data, encoding), за которым следует response.end(callback).

Если указан callback, он будет вызван после завершения потока ответа.

response.finished

• Тип: <boolean>

Свойство response.finished принимает значение true, если был вызван response.end().

response.flushHeaders()

Отправляет заголовки ответа. См. также: request.flushHeaders().

response.getHeader(name)

• name <string>
• Возвращает: <number> | <string> | <string[]> | <undefined>

Возвращает заголовок, который уже добавлен в очередь, но ещё не отправлен клиенту. Регистр имени не учитывается. Тип возвращаемого значения зависит от аргументов, переданных в response.setHeader().

response.setHeader('Content-Type', 'text/html');
response.setHeader('Content-Length', Buffer.byteLength(body));
response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']);
const contentType = response.getHeader('content-type');
// contentType is 'text/html'
const contentLength = response.getHeader('Content-Length');
// contentLength is of type number
const setCookie = response.getHeader('set-cookie');
// setCookie is of type string[] copy

response.getHeaderNames()

• Возвращает: <string[]>

Возвращает массив с уникальными именами текущих исходящих заголовков. Все имена заголовков записаны строчными буквами.

response.setHeader('Foo', 'bar');
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);

const headerNames = response.getHeaderNames();
// headerNames === ['foo', 'set-cookie'] copy

response.getHeaders()

• Возвращает: <Object>

Возвращает поверхностную копию текущих исходящих заголовков. Поскольку используется поверхностная копия, значения-массивы можно изменять без дополнительных вызовов различных методов модуля http, связанных с заголовками. Ключи возвращаемого объекта — имена заголовков, а значения — соответствующие значения заголовков. Все имена заголовков записаны строчными буквами.

Объект, возвращаемый методом response.getHeaders(), не наследует прототип от JavaScript Object. Это означает, что стандартные методы Object, например obj.toString(), obj.hasOwnProperty() и другие, не определены и не будут работать.

response.setHeader('Foo', 'bar');
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);

const headers = response.getHeaders();
// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] } copy

response.hasHeader(name)

• name <string>
• Возвращает: <boolean>

Возвращает true, если заголовок, указанный в name, в данный момент задан в исходящих заголовках. Регистр имени заголовка не учитывается.

const hasContentType = response.hasHeader('content-type'); copy

response.headersSent

• Тип: <boolean>

Логическое значение (только для чтения). True, если заголовки отправлены, в противном случае false.

response.removeHeader(name)

• name <string>

Удаляет заголовок, поставленный в очередь для неявной отправки.

response.removeHeader('Content-Encoding'); copy

response.req

• Тип: <http.IncomingMessage>

Ссылка на исходный объект HTTP request.

response.sendDate

• Тип: <boolean>

Если значение равно true, заголовок Date будет автоматически сформирован и включён в ответ, если его ещё нет в заголовках. По умолчанию — true.

Отключать эту настройку следует только для тестирования; протокол HTTP требует наличия заголовка Date в ответах.

response.setHeader(name, value)

• name <string>
• value <number> | <string> | <string[]>
• Возвращает: <http.ServerResponse>

Возвращает объект ответа.

Задаёт одно значение заголовка для неявных заголовков. Если такой заголовок уже есть среди заголовков, предназначенных для отправки, его значение будет заменено. Чтобы отправить несколько заголовков с одинаковым именем, используйте массив строк. Значения, не являющиеся строками, сохраняются без изменений. Поэтому response.getHeader() может возвращать значения, не являющиеся строками. Однако при передаче по сети такие значения будут преобразованы в строки. Вызывающему коду возвращается тот же объект ответа, что позволяет объединять вызовы в цепочку.

response.setHeader('Content-Type', 'text/html'); copy

или

response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']); copy

Попытка задать имя или значение поля заголовка, содержащие недопустимые символы, приведёт к выбросу TypeError.

Заголовки, заданные с помощью response.setHeader(), будут объединены с заголовками, переданными в response.writeHead(); приоритет будет у заголовков, переданных в response.writeHead().

// Returns content-type = text/plain
const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('ok');
}); copy

Если вызван метод response.writeHead(), а этот метод не вызывался, переданные значения заголовков будут сразу записаны в сетевой канал без внутреннего кэширования, и response.getHeader() для заголовка не вернёт ожидаемый результат. Если требуется постепенно добавлять заголовки с возможностью последующего получения и изменения, используйте response.setHeader() вместо response.writeHead().

response.setTimeout(msecs[, callback])

• msecs <number>
• callback <Function>
• Возвращает: <http.ServerResponse>

Задаёт для сокета значение тайм-аута msecs. Если передан callback, он добавляется к объекту ответа как обработчик события 'timeout'.

Если ни к запросу, ни к ответу, ни к серверу не добавлен обработчик события 'timeout', сокеты уничтожаются по истечении времени ожидания. Если обработчик назначен событиям 'timeout' запроса, ответа или сервера, тайм-ауты сокетов необходимо обрабатывать явно.

response.socket

• Тип: <stream.Duplex>

Ссылка на базовый сокет. Обычно пользователям не требуется обращаться к этому свойству. В частности, сокет не будет генерировать события 'readable' из-за того, как анализатор протокола подключается к сокету. После response.end() свойство принимает значение null.

import http from 'node:http';
const server = http.createServer((req, res) => {
  const ip = res.socket.remoteAddress;
  const port = res.socket.remotePort;
  res.end(`Your IP address is ${ip} and your source port is ${port}.`);
}).listen(3000);

const http = require('node:http');
const server = http.createServer((req, res) => {
  const ip = res.socket.remoteAddress;
  const port = res.socket.remotePort;
  res.end(`Your IP address is ${ip} and your source port is ${port}.`);
}).listen(3000);

Гарантируется, что это свойство является экземпляром класса <net.Socket>, подкласса <stream.Duplex>, если только пользователь не указал тип сокета, отличный от <net.Socket>.

response.statusCode

• Тип: <number> По умолчанию: 200

При использовании неявных заголовков (без явного вызова response.writeHead()) это свойство задаёт код состояния, который будет отправлен клиенту при передаче заголовков.

response.statusCode = 404; copy

После отправки заголовка ответа клиенту это свойство указывает отправленный код состояния.

response.statusMessage

• Тип: <string>

При использовании неявных заголовков (без явного вызова response.writeHead()) это свойство задаёт сообщение о состоянии, которое будет отправлено клиенту при передаче заголовков. Если оставить значение undefined, будет использовано стандартное сообщение для кода состояния.

response.statusMessage = 'Not found'; copy

После отправки заголовка ответа клиенту это свойство указывает отправленное сообщение о состоянии.

response.strictContentLength

• Тип: <boolean> По умолчанию: false

Если значение равно true, Node.js проверит, совпадают ли значение заголовка Content-Length и размер тела в байтах. Несоответствие значения заголовка Content-Length приведёт к выбросу Error с кодом code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'.

response.uncork()

См. writable.uncork().

response.writableEnded

• Тип: <boolean>

Равно true после вызова response.end(). Это свойство не указывает, были ли данные переданы; для этого используйте response.writableFinished.

response.writableFinished

• Тип: <boolean>

Равно true, если все данные переданы базовой системе, непосредственно перед генерацией события 'finish'.

response.write(chunk[, encoding][, callback])

• chunk <string> | <Buffer> | <Uint8Array>
• encoding <string> По умолчанию: 'utf8'
• callback <Function>
• Возвращает: <boolean>

Если этот метод вызван, а response.writeHead() не вызывался, будет включён режим неявных заголовков и отправлены неявные заголовки.

Отправляет фрагмент тела ответа. Этот метод можно вызывать несколько раз, передавая последовательные части тела.

Если в createServer для rejectNonStandardBodyWrites задано значение true, запись в тело запрещена, если метод запроса или статус ответа не допускают содержимого. При попытке записать данные в тело для запроса HEAD либо в ответе 204 или 304 будет синхронно выброшена ошибка Error с кодом ERR_HTTP_BODY_NOT_ALLOWED.

chunk может быть строкой или буфером. Если chunk — строка, второй параметр задаёт способ её кодирования в поток байтов. callback будет вызван, когда этот фрагмент данных будет передан.

Это необработанное тело HTTP, не связанное с кодировками многочастного тела более высокого уровня, которые могут использоваться.

При первом вызове response.write() клиенту будут отправлены буферизованные заголовки и первый фрагмент тела. При втором вызове response.write() Node.js предполагает, что данные будут передаваться потоком, и отправляет новые данные отдельно. То есть ответ буферизуется до первого фрагмента тела.

Возвращает true, если все данные успешно переданы в буфер ядра. Возвращает false, если все данные или их часть поставлены в очередь в памяти пользователя. Событие 'drain' будет сгенерировано, когда буфер снова освободится.

response.writeContinue()

Отправляет клиенту сообщение HTTP/1.1 100 Continue, указывающее, что следует отправить тело запроса. См. событие 'checkContinue' у Server.

response.writeEarlyHints(hints[, callback])

• hints <Object>
• callback <Function>

Отправляет клиенту сообщение HTTP/1.1 103 Early Hints с заголовком Link, указывающее, что пользовательский агент может предварительно загрузить связанные ресурсы или установить предварительное соединение с ними. hints — объект, содержащий значения заголовков, которые будут отправлены вместе с сообщением ранних подсказок. Необязательный аргумент callback будет вызван после записи сообщения ответа.

Пример

const earlyHintsLink = '</styles.css>; rel=preload; as=style';
response.writeEarlyHints({
  'link': earlyHintsLink,
});

const earlyHintsLinks = [
  '</styles.css>; rel=preload; as=style',
  '</scripts.js>; rel=preload; as=script',
];
response.writeEarlyHints({
  'link': earlyHintsLinks,
  'x-trace-id': 'id for diagnostics',
});

const earlyHintsCallback = () => console.log('early hints message sent');
response.writeEarlyHints({
  'link': earlyHintsLinks,
}, earlyHintsCallback); copy

response.writeHead(statusCode[, statusMessage][, headers])

• statusCode <number>
• statusMessage <string>
• headers <Object> | <Array>
• Возвращает: <http.ServerResponse>

Отправляет заголовок ответа на запрос. Код состояния — это трёхзначный код состояния HTTP, например 404. Последний аргумент, headers, содержит заголовки ответа. При необходимости вторым аргументом можно передать понятное человеку statusMessage.

headers может быть Array, в котором ключи и значения находятся в одном списке. Это не список кортежей. Таким образом, элементы с чётными индексами являются ключами, а элементы с нечётными индексами — соответствующими значениями. Массив имеет тот же формат, что и request.rawHeaders.

Возвращает ссылку на ServerResponse, чтобы вызовы можно было объединять в цепочку.

const body = 'hello world';
response
  .writeHead(200, {
    'Content-Length': Buffer.byteLength(body),
    'Content-Type': 'text/plain',
  })
  .end(body); copy

Этот метод следует вызывать только один раз для сообщения и до вызова response.end().

Если response.write() или response.end() вызваны до этого метода, неявные/изменяемые заголовки будут вычислены, и эта функция будет вызвана.

Заголовки, заданные с помощью response.setHeader(), будут объединены с заголовками, переданными в response.writeHead(); приоритет будет у заголовков, переданных в response.writeHead().

Если этот метод вызван, а response.setHeader() не вызывался, переданные значения заголовков будут сразу записаны в сетевой канал без внутреннего кэширования, и response.getHeader() для заголовка не вернёт ожидаемый результат. Если требуется постепенно добавлять заголовки с возможностью последующего получения и изменения, используйте response.setHeader().

// Returns content-type = text/plain
const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('ok');
}); copy

Content-Length измеряется в байтах, а не в символах. Используйте Buffer.byteLength(), чтобы определить длину тела в байтах. Node.js проверит, совпадают ли Content-Length и длина переданного тела.

Попытка задать имя или значение поля заголовка, содержащие недопустимые символы, приведёт к выбросу TypeError.

response.writeProcessing()

Отправляет клиенту сообщение HTTP/1.1 102 Processing, указывающее, что следует отправить тело запроса.

Событие: 'aborted'

Генерируется, когда запрос был прерван.

Событие: 'close'

Генерируется после завершения запроса.

message.aborted

• Тип: <boolean>

Значение свойства message.aborted будет равно true, если запрос был прерван.

message.complete

• Тип: <boolean>

Значение свойства message.complete будет равно true, если полное HTTP-сообщение было получено и успешно разобрано.

Это свойство особенно полезно для определения того, полностью ли клиент или сервер передал сообщение до разрыва соединения:

const req = http.request({
  host: '127.0.0.1',
  port: 8080,
  method: 'POST',
}, (res) => {
  res.resume();
  res.on('end', () => {
    if (!res.complete)
      console.error(
        'The connection was terminated while the message was still being sent');
  });
}); copy

message.connection

Псевдоним для message.socket.

message.destroy([error])

• error <Error>
• Возвращает: <this>

Вызывает destroy() для сокета, получившего IncomingMessage. Если указан error, в сокете генерируется событие 'error', а error передаётся в качестве аргумента всем обработчикам этого события.

message.headers

• Тип: <Object>

Объект заголовков запроса/ответа.

Пары «ключ-значение» для имён и значений заголовков. Имена заголовков приводятся к нижнему регистру.

// Prints something like:
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers); copy

Дубликаты в необработанных заголовках обрабатываются следующим образом в зависимости от имени заголовка:

• Дубликаты age, authorization, content-length, content-type, etag, expires, from, host, if-modified-since, if-unmodified-since, last-modified, location, max-forwards, proxy-authorization, referer, retry-after, server или user-agent отбрасываются. Чтобы разрешить объединение дублирующихся значений перечисленных выше заголовков, используйте параметр joinDuplicateHeaders в http.request() и http.createServer(). Дополнительные сведения см. в разделе 5.3 RFC 9110.
• set-cookie всегда является массивом. Дубликаты добавляются в массив.
• Для дублирующихся заголовков cookie значения объединяются с помощью ; .
• Для всех остальных заголовков значения объединяются с помощью , .

message.headersDistinct

• Тип: <Object>

Похоже на message.headers, но значения не объединяются и всегда представлены массивами строк, даже если заголовок получен только один раз.

// Prints something like:
//
// { 'user-agent': ['curl/7.22.0'],
//   host: ['127.0.0.1:8000'],
//   accept: ['*/*'] }
console.log(request.headersDistinct); copy

message.httpVersion

• Тип: <string>

Для запроса на сервере — версия HTTP, отправленная клиентом. Для ответа клиенту — версия HTTP подключённого сервера. Вероятно, это '1.1' или '1.0'.

Кроме того, message.httpVersionMajor — это первое целое число, а message.httpVersionMinor — второе.

message.method

• Тип: <string>

Действительно только для запроса, полученного от http.Server.

Метод запроса в виде строки. Только для чтения. Примеры: 'GET', 'DELETE'.

message.rawHeaders

• Тип: <string[]>

Список необработанных заголовков запроса/ответа в точности в том виде, в котором они были получены.

Ключи и значения находятся в одном списке. Это не список кортежей. Таким образом, элементы с чётными индексами содержат ключи, а элементы с нечётными индексами — соответствующие значения.

Имена заголовков не приводятся к нижнему регистру, а дубликаты не объединяются.

// Prints something like:
//
// [ 'user-agent',
//   'this is invalid because there can be only one',
//   'User-Agent',
//   'curl/7.22.0',
//   'Host',
//   '127.0.0.1:8000',
//   'ACCEPT',
//   '*/*' ]
console.log(request.rawHeaders); copy

message.rawTrailers

• Тип: <string[]>

Ключи и значения необработанных завершающих заголовков запроса/ответа в точности в том виде, в котором они были получены. Заполняется только при событии 'end'.

message.setTimeout(msecs[, callback])

• msecs <number>
• callback <Function>
• Возвращает: <http.IncomingMessage>

Вызывает message.socket.setTimeout(msecs, callback).

message.socket

• Тип: <stream.Duplex>

Объект net.Socket, связанный с соединением.

При использовании HTTPS вызовите request.socket.getPeerCertificate(), чтобы получить сведения об аутентификации клиента.

Это свойство гарантированно является экземпляром класса <net.Socket>, подкласса <stream.Duplex>, если только пользователь не указал тип сокета, отличный от <net.Socket>, или значение не было обнулено внутри системы.

message.statusCode

• Тип: <number>

Действительно только для ответа, полученного от http.ClientRequest.

Трёхзначный код состояния HTTP-ответа. Например, 404.

message.statusMessage

• Тип: <string>

Действительно только для ответа, полученного от http.ClientRequest.

Текст состояния HTTP-ответа (фраза причины). Например, OK или Internal Server Error.

message.trailers

• Тип: <Object>

Объект завершающих заголовков запроса/ответа. Заполняется только при событии 'end'.

message.trailersDistinct

• Тип: <Object>

Похоже на message.trailers, но значения не объединяются и всегда представлены массивами строк, даже если заголовок получен только один раз. Заполняется только при событии 'end'.

message.url

• Тип: <string>

Действительно только для запроса, полученного от http.Server.

Строка URL запроса. Она содержит только URL, указанный в фактическом HTTP-запросе. Рассмотрим следующий запрос:

GET /status?name=ryan HTTP/1.1
Accept: text/plain copy

Чтобы разобрать URL на составляющие:

new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`); copy

Если request.url имеет значение '/status?name=ryan', а process.env.HOST не определён:

$ node
> new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`);
URL {
  href: 'http://localhost/status?name=ryan',
  origin: 'http://localhost',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'localhost',
  hostname: 'localhost',
  port: '',
  pathname: '/status',
  search: '?name=ryan',
  searchParams: URLSearchParams { 'name' => 'ryan' },
  hash: ''
} copy

Убедитесь, что для process.env.HOST задано имя узла сервера, или рассмотрите возможность полной замены этой части. При использовании req.headers.host убедитесь, что применяется надлежащая проверка, поскольку клиенты могут указывать пользовательский заголовок Host.

Событие: 'drain'

Возникает, когда буфер сообщения снова освобождается.

Событие: 'finish'

Возникает при успешном завершении передачи.

Событие: 'prefinish'

Возникает после вызова outgoingMessage.end(). В момент возникновения события все данные обработаны, но не обязательно полностью переданы.

outgoingMessage.addTrailers(headers)

• headers <Object>

Добавляет к сообщению HTTP-трейлеры (заголовки в конце сообщения).

Трейлеры будут отправлены только в том случае, если сообщение передаётся с кодированием чанками. В противном случае трейлеры будут молча отброшены.

Для отправки трейлеров HTTP требует наличия заголовка Trailer со списком имён полей заголовков в его значении, например:

message.writeHead(200, { 'Content-Type': 'text/plain',
                         'Trailer': 'Content-MD5' });
message.write(fileData);
message.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });
message.end(); copy

Попытка задать имя или значение поля заголовка, содержащие недопустимые символы, приведёт к выбрасыванию TypeError.

outgoingMessage.appendHeader(name, value)

• name <string> Имя заголовка
• value <string> | <string[]> Значение заголовка
• Возвращает: <this>

Добавляет одно значение заголовка в объект заголовков.

Если значение представляет собой массив, это эквивалентно многократному вызову данного метода.

Если для заголовка ранее не было задано значений, это эквивалентно вызову outgoingMessage.setHeader(name, value).

В зависимости от значения options.uniqueHeaders на момент создания клиентского запроса или сервера заголовок будет отправлен несколько раз либо один раз со значениями, объединёнными с помощью ; .

outgoingMessage.connection

Псевдоним outgoingMessage.socket.

outgoingMessage.cork()

См. writable.cork().

outgoingMessage.destroy([error])

• error <Error> Необязательная ошибка, передаваемая вместе с событием error
• Возвращает: <this>

Уничтожает сообщение. Если с сообщением связан сокет и он подключён, этот сокет также будет уничтожен.

outgoingMessage.end(chunk[, encoding][, callback])

• chunk <string> | <Buffer> | <Uint8Array>
• encoding <string> Необязательный параметр, значение по умолчанию: utf8
• callback <Function> Необязательный параметр
• Возвращает: <this>

Завершает исходящее сообщение. Если какие-либо части тела ещё не отправлены, они будут переданы в нижележащую систему. Если сообщение передаётся чанками, будет отправлен завершающий чанк 0\r\n\r\n, а также трейлеры (если они есть).

Если указан chunk, это эквивалентно вызову outgoingMessage.write(chunk, encoding), за которым следует outgoingMessage.end(callback).

Если передан callback, он будет вызван по завершении сообщения (что эквивалентно подписке на событие 'finish').

outgoingMessage.flushHeaders()

Передаёт заголовки сообщения.

Для повышения эффективности Node.js обычно буферизует заголовки сообщения до вызова outgoingMessage.end() или записи первого фрагмента данных сообщения. Затем Node.js пытается упаковать заголовки и данные в один TCP-пакет.

Обычно это желательно (так экономится один цикл обмена данными TCP), но не в том случае, если первые данные будут отправлены лишь значительно позже. outgoingMessage.flushHeaders() отключает эту оптимизацию и запускает отправку сообщения.

outgoingMessage.getHeader(name)

• name <string> Имя заголовка
• Возвращает: <number> | <string> | <string[]> | <undefined>

Возвращает значение HTTP-заголовка с указанным именем. Если этот заголовок не задан, возвращаемым значением будет undefined.

outgoingMessage.getHeaderNames()

• Возвращает: <string[]>

Возвращает массив с уникальными именами текущих исходящих заголовков. Все имена записаны в нижнем регистре.

outgoingMessage.getHeaders()

• Возвращает: <Object>

Возвращает поверхностную копию текущих исходящих заголовков. Поскольку используется поверхностная копия, значения-массивы можно изменять без дополнительных вызовов различных методов HTTP-модуля, связанных с заголовками. Ключи возвращаемого объекта — это имена заголовков, а значения — соответствующие значения заголовков. Все имена заголовков записаны в нижнем регистре.

Объект, возвращаемый методом outgoingMessage.getHeaders(), не наследуется по цепочке прототипов от JavaScript-объекта Object. Это означает, что типичные методы Object, например obj.toString(), obj.hasOwnProperty() и другие, не определены и не будут работать.

outgoingMessage.setHeader('Foo', 'bar');
outgoingMessage.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);

const headers = outgoingMessage.getHeaders();
// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] } copy

outgoingMessage.hasHeader(name)

• name <string>
• Возвращает: <boolean>

Возвращает true, если заголовок с именем name в данный момент задан среди исходящих заголовков. Регистр букв в имени заголовка не учитывается.

const hasContentType = outgoingMessage.hasHeader('content-type'); copy

outgoingMessage.headersSent

• Тип: <boolean>

Только для чтения. Значение true, если заголовки отправлены, иначе — false.

outgoingMessage.pipe()

Переопределяет метод stream.pipe(), унаследованный от устаревшего класса Stream, который является родительским классом для http.OutgoingMessage.

Вызов этого метода приведёт к выбрасыванию Error, поскольку outgoingMessage — это поток только для записи.

outgoingMessage.removeHeader(name)

• name <string> Имя заголовка

Удаляет заголовок, поставленный в очередь для неявной отправки.

outgoingMessage.removeHeader('Content-Encoding'); copy

outgoingMessage.setHeader(name, value)

• name <string> Имя заголовка
• value <number> | <string> | <string[]> Значение заголовка
• Возвращает: <this>

Задаёт одно значение заголовка. Если заголовок уже присутствует среди заголовков, предназначенных для отправки, его значение будет заменено. Чтобы отправить несколько заголовков с одинаковым именем, используйте массив строк.

outgoingMessage.setHeaders(headers)

• headers <Headers> | <Map>
• Возвращает: <this>

Задаёт несколько значений заголовков для неявных заголовков. headers должен быть экземпляром Headers или Map; если заголовок уже присутствует среди заголовков, предназначенных для отправки, его значение будет заменено.

const headers = new Headers({ foo: 'bar' });
outgoingMessage.setHeaders(headers); copy

или

const headers = new Map([['foo', 'bar']]);
outgoingMessage.setHeaders(headers); copy

Если заголовки заданы с помощью outgoingMessage.setHeaders(), они будут объединены с любыми заголовками, переданными в response.writeHead(); при этом приоритет будет отдан заголовкам, переданным в response.writeHead().

// Returns content-type = text/plain
const server = http.createServer((req, res) => {
  const headers = new Headers({ 'Content-Type': 'text/html' });
  res.setHeaders(headers);
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('ok');
}); copy

outgoingMessage.setTimeout(msecs[, callback])

• msecs <number>
• callback <Function> Необязательная функция, вызываемая при наступлении тайм-аута. То же, что и подписка на событие timeout.
• Возвращает: <this>

Когда с сообщением будет связан сокет и он будет подключён, будет вызван socket.setTimeout(), которому в качестве первого параметра будет передан msecs.

outgoingMessage.socket

• Тип: <stream.Duplex>

Ссылка на нижележащий сокет. Обычно пользователям не требуется обращаться к этому свойству.

После вызова outgoingMessage.end() это свойство будет иметь значение null.

outgoingMessage.uncork()

См. writable.uncork()

outgoingMessage.writableCorked

• Тип: <number>

Количество вызовов outgoingMessage.cork().

outgoingMessage.writableEnded

• Тип: <boolean>

Имеет значение true, если был вызван outgoingMessage.end(). Это свойство не указывает, были ли данные переданы. Для этой цели используйте message.writableFinished.

outgoingMessage.writableFinished

• Тип: <boolean>

Имеет значение true, если все данные переданы в нижележащую систему.

outgoingMessage.writableHighWaterMark

• Тип: <number>

Значение highWaterMark нижележащего сокета, если он задан. В противном случае — уровень буфера по умолчанию, при котором writable.write() начинает возвращать false (16384).

outgoingMessage.writableLength

• Тип: <number>

Количество байтов в буфере.

outgoingMessage.writableObjectMode

• Тип: <boolean>

Всегда имеет значение false.

outgoingMessage.write(chunk[, encoding][, callback])

• chunk <string> | <Buffer> | <Uint8Array>
• encoding <string> Значение по умолчанию: utf8
• callback <Function>
• Возвращает: <boolean>

Отправляет фрагмент тела сообщения. Этот метод можно вызывать несколько раз.

Аргумент encoding имеет значение только в том случае, если chunk — строка. По умолчанию используется 'utf8'.

Аргумент callback является необязательным и будет вызван после передачи этого фрагмента данных.

Возвращает true, если все данные успешно переданы в буфер ядра. Возвращает false, если все данные или их часть поставлены в очередь в пользовательской памяти. Когда буфер снова освободится, возникнет событие 'drain'.

Формат URL прокси

В URL прокси могут использоваться протоколы HTTP или HTTPS:

• HTTP-прокси: http://proxy.example.com:8080
• HTTPS-прокси: https://proxy.example.com:8080
• Прокси с аутентификацией: http://username:password@proxy.example.com:8080

Формат NO_PROXY

Переменная среды NO_PROXY поддерживает несколько форматов:

• * — не использовать прокси для всех хостов
• example.com — точное совпадение имени хоста
• .example.com — совпадение по суффиксу домена (совпадает с sub.example.com)
• *.example.com — совпадение с доменом по шаблону
• 192.168.1.100 — точное совпадение IP-адреса
• 192.168.1.1-192.168.1.100 — диапазон IP-адресов
• example.com:8080 — имя хоста с определённым портом

Несколько записей следует разделять запятыми.

Пример

Чтобы запустить процесс Node.js с поддержкой прокси для всех запросов, отправляемых через глобальный агент по умолчанию, используйте переменную среды NODE_USE_ENV_PROXY:

NODE_USE_ENV_PROXY=1 HTTP_PROXY=http://proxy.example.com:8080 NO_PROXY=localhost,127.0.0.1 node client.js copy

Или флаг --use-env-proxy.

HTTP_PROXY=http://proxy.example.com:8080 NO_PROXY=localhost,127.0.0.1 node --use-env-proxy client.js copy

Чтобы динамически включить поддержку прокси для всего приложения с помощью process.env (значения по умолчанию для http.setGlobalProxyFromEnv()):

const http = require('node:http');

// Reads proxy-related environment variables from process.env
const restore = http.setGlobalProxyFromEnv();

// Subsequent requests will use the configured proxies from environment variables
http.get('http://www.example.com', (res) => {
  // This request will be proxied if HTTP_PROXY or http_proxy is set
});

fetch('https://www.example.com', (res) => {
  // This request will be proxied if HTTPS_PROXY or https_proxy is set
});

// To restore the original global agent and dispatcher settings, call the returned function.
// restore();

import http from 'node:http';

// Reads proxy-related environment variables from process.env
http.setGlobalProxyFromEnv();

// Subsequent requests will use the configured proxies from environment variables
http.get('http://www.example.com', (res) => {
  // This request will be proxied if HTTP_PROXY or http_proxy is set
});

fetch('https://www.example.com', (res) => {
  // This request will be proxied if HTTPS_PROXY or https_proxy is set
});

// To restore the original global agent and dispatcher settings, call the returned function.
// restore();

Чтобы динамически включить поддержку прокси для всего приложения с пользовательскими настройками:

const http = require('node:http');

const restore = http.setGlobalProxyFromEnv({
  http_proxy: 'http://proxy.example.com:8080',
  https_proxy: 'https://proxy.example.com:8443',
  no_proxy: 'localhost,127.0.0.1,.internal.example.com',
});

// Subsequent requests will use the configured proxies
http.get('http://www.example.com', (res) => {
  // This request will be proxied through proxy.example.com:8080
});

fetch('https://www.example.com', (res) => {
  // This request will be proxied through proxy.example.com:8443
});

import http from 'node:http';

http.setGlobalProxyFromEnv({
  http_proxy: 'http://proxy.example.com:8080',
  https_proxy: 'https://proxy.example.com:8443',
  no_proxy: 'localhost,127.0.0.1,.internal.example.com',
});

// Subsequent requests will use the configured proxies
http.get('http://www.example.com', (res) => {
  // This request will be proxied through proxy.example.com:8080
});

fetch('https://www.example.com', (res) => {
  // This request will be proxied through proxy.example.com:8443
});

Чтобы создать пользовательский агент со встроенной поддержкой прокси:

const http = require('node:http');

// Creating a custom agent with custom proxy support.
const agent = new http.Agent({ proxyEnv: { HTTP_PROXY: 'http://proxy.example.com:8080' } });

http.request({
  hostname: 'www.example.com',
  port: 80,
  path: '/',
  agent,
}, (res) => {
  // This request will be proxied through proxy.example.com:8080 using the HTTP protocol.
  console.log(`STATUS: ${res.statusCode}`);
}); copy

Также можно использовать следующий вариант:

const http = require('node:http');
// Use lower-cased option name.
const agent1 = new http.Agent({ proxyEnv: { http_proxy: 'http://proxy.example.com:8080' } });
// Use values inherited from the environment variables, if the process is started with
// HTTP_PROXY=http://proxy.example.com:8080 this will use the proxy server specified
// in process.env.HTTP_PROXY.
const agent2 = new http.Agent({ proxyEnv: process.env }); copy