Определение путей для IPC-соединений

net.connect(), net.createConnection(), server.listen() и socket.connect() принимают параметр path для указания конечных точек IPC.

В Unix локальный домен также известен как домен Unix. Путь представляет собой путь в файловой системе. Если длина пути превышает длину sizeof(sockaddr_un.sun_path), будет выброшена ошибка. Типичные значения — 107 байт в Linux и 103 байта в macOS. Если абстракция API Node.js создает сокет домена Unix, она также удалит его. Например, net.createServer() может создать сокет домена Unix, а server.close() удалит его. Если же пользователь создает сокет домена Unix за пределами этих абстракций, ему нужно будет удалить его самостоятельно. То же относится к ситуации, когда API Node.js создает сокет домена Unix, но затем программа аварийно завершается. Иными словами, сокет домена Unix виден в файловой системе и сохраняется до тех пор, пока не будет удален. В Linux можно использовать абстрактный сокет Unix, добавив \0 в начало пути, например \0abstract. Путь к абстрактному сокету Unix не виден в файловой системе, и сокет исчезает автоматически после закрытия всех открытых ссылок на него.

В Windows локальный домен реализован с помощью именованного канала. Путь должен указывать на запись в \\?\pipe\ или \\.\pipe\. Допускаются любые символы, но последний вариант может выполнять обработку имен каналов, например разрешать последовательности ... Несмотря на внешний вид, пространство имен каналов является плоским. Каналы не сохраняются. Они удаляются после закрытия последней ссылки на них. В отличие от сокетов домена Unix, Windows закрывает и удаляет канал после завершения процесса-владельца.

Для экранирования строк JavaScript пути необходимо указывать с дополнительным экранированием обратной косой черты, например:

net.createServer().listen(
  path.join('\\\\?\\pipe', process.cwd(), 'myctl')); copy

blockList.addAddress(address[, type])

• address <string> | <net.SocketAddress> IPv4- или IPv6-адрес.
• type <string> Либо 'ipv4', либо 'ipv6'. По умолчанию: 'ipv4'.

Добавляет правило для блокировки указанного IP-адреса.

blockList.addRange(start, end[, type])

• start <string> | <net.SocketAddress> Начальный IPv4- или IPv6-адрес диапазона.
• end <string> | <net.SocketAddress> Конечный IPv4- или IPv6-адрес диапазона.
• type <string> Либо 'ipv4', либо 'ipv6'. По умолчанию: 'ipv4'.

Добавляет правило для блокировки диапазона IP-адресов от start (включительно) до end (включительно).

blockList.addSubnet(net, prefix[, type])

• net <string> | <net.SocketAddress> Сетевой IPv4- или IPv6-адрес.
• prefix <number> Количество бит префикса CIDR. Для IPv4 значение должно находиться в диапазоне от 0 до 32. Для IPv6 — в диапазоне от 0 до 128.
• type <string> Либо 'ipv4', либо 'ipv6'. По умолчанию: 'ipv4'.

Добавляет правило для блокировки диапазона IP-адресов, заданного маской подсети.

blockList.check(address[, type])

• address <string> | <net.SocketAddress> IP-адрес для проверки
• type <string> Либо 'ipv4', либо 'ipv6'. По умолчанию: 'ipv4'.
• Возвращает: <boolean>

Возвращает true, если указанный IP-адрес соответствует какому-либо правилу, добавленному в BlockList.

const blockList = new net.BlockList();
blockList.addAddress('123.123.123.123');
blockList.addRange('10.0.0.1', '10.0.0.10');
blockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');

console.log(blockList.check('123.123.123.123'));  // Prints: true
console.log(blockList.check('10.0.0.3'));  // Prints: true
console.log(blockList.check('222.111.111.222'));  // Prints: false

// IPv6 notation for IPv4 addresses works:
console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true
console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true copy

blockList.rules

• Тип: <string[]>

Список правил, добавленных в список блокировки.

BlockList.isBlockList(value)

• value <any> Любое значение JS
• Возвращает true, если value является net.BlockList.

blockList.fromJSON(value)

const blockList = new net.BlockList();
const data = [
  'Subnet: IPv4 192.168.1.0/24',
  'Address: IPv4 10.0.0.5',
  'Range: IPv4 192.168.2.1-192.168.2.10',
  'Range: IPv4 10.0.0.1-10.0.0.10',
];
blockList.fromJSON(data);
blockList.fromJSON(JSON.stringify(data)); copy

• value Blocklist.rules

blockList.toJSON()

• Возвращает Blocklist.rules

new net.SocketAddress([options])

• options <Object>
  • address <string> Сетевой адрес в виде строки IPv4 или IPv6. По умолчанию: '127.0.0.1', если family — 'ipv4'; '::', если family — 'ipv6'.
  • family <string> Одно из значений: 'ipv4' или 'ipv6'. По умолчанию: 'ipv4'.
  • flowlabel <number> Метка потока IPv6, используемая только если family — 'ipv6'.
  • port <number> IP-порт.

socketaddress.address

• Тип: <string>

socketaddress.family

• Тип: <string> Либо 'ipv4', либо 'ipv6'.

socketaddress.flowlabel

• Тип: <number>

socketaddress.port

• Тип: <number>

SocketAddress.parse(input)

• input <string> Входная строка, содержащая IP-адрес и необязательный порт, например 123.1.2.3:1234 или [1::1]:1234.
• Возвращает: <net.SocketAddress> Возвращает SocketAddress, если разбор выполнен успешно. В противном случае возвращает undefined.

new net.Server([options][, connectionListener])

• options <Object> См. net.createServer([options][, connectionListener]).
• connectionListener <Function> Автоматически устанавливается в качестве обработчика события 'connection'.
• Возвращает: <net.Server>

net.Server — это EventEmitter со следующими событиями:

Событие: 'close'

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

Событие: 'connection'

• Тип: <net.Socket> Объект подключения

Генерируется при установлении нового подключения. socket является экземпляром net.Socket.

Событие: 'error'

• Тип: <Error>

Генерируется при возникновении ошибки. В отличие от net.Socket, событие 'close' не будет сгенерировано сразу после этого события, если только не вызвать вручную server.close(). См. пример в обсуждении server.listen().

Событие: 'listening'

Генерируется после привязки сервера при вызове server.listen().

Событие: 'drop'

Когда число подключений достигает порогового значения server.maxConnections, сервер будет отклонять новые подключения и вместо этого генерировать событие 'drop'. Для TCP-сервера аргумент имеет следующий вид, в противном случае аргументом является undefined.

• data <Object> Аргумент, передаваемый обработчику события.
  • localAddress <string> Локальный адрес.
  • localPort <number> Локальный порт.
  • localFamily <string> Локальное семейство адресов.
  • remoteAddress <string> Удалённый адрес.
  • remotePort <number> Удалённый порт.
  • remoteFamily <string> Семейство IP-адресов удалённого узла. 'IPv4' или 'IPv6'.

server.address()

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

Возвращает связанный address, имя адреса family и port сервера, указанные операционной системой, если сервер прослушивает IP-сокет (это полезно для определения назначенного системой порта при получении адреса, назначенного ОС): { port: 12346, family: 'IPv4', address: '127.0.0.1' }.

Для сервера, прослушивающего канал или доменный сокет Unix, имя возвращается в виде строки.

const server = net.createServer((socket) => {
  socket.end('goodbye\n');
}).on('error', (err) => {
  // Handle errors here.
  throw err;
});

// Grab an arbitrary unused port.
server.listen(() => {
  console.log('opened server on', server.address());
}); copy

server.address() возвращает null до генерации события 'listening' или после вызова server.close().

server.close([callback])

• callback <Function> Вызывается при закрытии сервера.
• Возвращает: <net.Server>

Прекращает приём новых подключений сервером, сохраняя существующие подключения. Эта функция асинхронна: сервер окончательно закрывается, когда все подключения завершены и сервер генерирует событие 'close'. Необязательный параметр callback будет вызван при возникновении события 'close'. В отличие от этого события, он получит Error в качестве единственного аргумента, если сервер не был открыт на момент закрытия.

server[Symbol.asyncDispose]()

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

server.getConnections(callback)

• callback <Function>
• Возвращает: <net.Server>

Асинхронно получает число одновременных подключений к серверу. Работает, даже если сокеты были переданы дочерним процессам.

Функция обратного вызова должна принимать два аргумента: err и count.

server.listen()

Запускает сервер, прослушивающий подключения. net.Server может быть TCP- или IPC-сервером в зависимости от того, что он прослушивает.

Возможные сигнатуры:

• server.listen(handle[, backlog][, callback])
• server.listen(options[, callback])
• server.listen(path[, backlog][, callback]) для IPC-серверов
• server.listen([port[, host[, backlog]]][, callback]) для TCP-серверов

Эта функция асинхронна. Когда сервер начинает прослушивать подключения, генерируется событие 'listening'. Последний параметр callback будет добавлен в качестве обработчика события 'listening'.

Все методы listen() могут принимать параметр backlog, задающий максимальную длину очереди ожидающих подключений. Фактическую длину определяет ОС с помощью настроек sysctl, таких как tcp_max_syn_backlog и somaxconn в Linux. Значение этого параметра по умолчанию — 511 (не 512).

Для всех net.Socket устанавливается значение SO_REUSEADDR (подробности см. в socket(7)).

Метод server.listen() можно вызвать повторно только в том случае, если при первом вызове server.listen() произошла ошибка или был вызван server.close(). В противном случае будет выброшена ошибка ERR_SERVER_ALREADY_LISTEN.

Одна из наиболее распространённых ошибок при начале прослушивания — EADDRINUSE. Она возникает, когда другой сервер уже прослушивает запрошенные port/path/handle. Один из способов обработать её — повторить попытку через некоторое время:

server.on('error', (e) => {
  if (e.code === 'EADDRINUSE') {
    console.error('Address in use, retrying...');
    setTimeout(() => {
      server.close();
      server.listen(PORT, HOST);
    }, 1000);
  }
}); copy

server.listen({
  host: 'localhost',
  port: 80,
  exclusive: true,
}); copy

const controller = new AbortController();
server.listen({
  host: 'localhost',
  port: 80,
  signal: controller.signal,
});
// Later, when you want to close the server.
controller.abort(); copy

server.listening

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

server.maxConnections

• Тип: <integer>

Когда число подключений достигает порогового значения server.maxConnections:

1. Если процесс не запущен в режиме кластера, Node.js закроет подключение.

2. Если процесс запущен в режиме кластера, Node.js по умолчанию перенаправит подключение в другой рабочий процесс. Чтобы вместо этого закрыть подключение, установите server.dropMaxConnection в значение true.

Не рекомендуется использовать этот параметр после передачи сокета дочернему процессу с помощью child_process.fork().

server.dropMaxConnection

• Тип: <boolean>

Установите для этого свойства значение true, чтобы начать закрывать подключения при достижении порогового значения [server.maxConnections][]. Эта настройка действует только в режиме кластера.

server.ref()

• Возвращает: <net.Server>

Противоположность unref(): вызов ref() для сервера, ранее помеченного как unref, не позволит программе завершиться, если это единственный оставшийся сервер (поведение по умолчанию). Если сервер уже помечен как ref, повторный вызов ref() не повлияет на него.

server.unref()

• Возвращает: <net.Server>

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

new net.Socket([options])

• options <Object> Доступны следующие параметры:
  • allowHalfOpen <boolean> Если задано значение false, сокет автоматически завершит записываемую сторону при завершении читаемой стороны. Подробности см. в разделе net.createServer() и описании события 'end'. По умолчанию: false.
  • blockList <net.BlockList> blockList можно использовать для отключения исходящего доступа к определённым IP-адресам, диапазонам IP-адресов или подсетям.
  • fd <number> Если задано, оборачивает существующий сокет с указанным файловым дескриптором; в противном случае создаётся новый сокет.
  • keepAlive <boolean> Если задано значение true, сразу после установления соединения на сокете включается функция keep-alive, аналогично тому, как это делается в socket.setKeepAlive(). По умолчанию: false.
  • keepAliveInitialDelay <number> Если задано положительное число, оно устанавливает начальную задержку перед отправкой первого keepalive-запроса через бездействующий сокет. По умолчанию: 0.
  • noDelay <boolean> Если задано значение true, сразу после установления соединения для сокета отключается алгоритм Нагла. По умолчанию: false.
  • onread <Object> Если задано, входящие данные сохраняются в одном buffer и передаются указанному callback при поступлении данных в сокет. При этом потоковая функциональность не будет предоставлять данные. Сокет по-прежнему будет генерировать события, такие как 'error', 'end' и 'close'. Методы, такие как pause() и resume(), также будут работать ожидаемым образом.
    • buffer <Buffer> | <Uint8Array> | <Function> Либо повторно используемый фрагмент памяти для хранения входящих данных, либо функция, возвращающая такой фрагмент.
    • callback <Function> Эта функция вызывается для каждого фрагмента входящих данных. Ей передаются два аргумента: количество байтов, записанных в buffer, и ссылка на buffer. Возврат false из этой функции неявно приводит к вызову pause() сокета. Эта функция будет выполняться в глобальном контексте.
  • readable <boolean> Разрешает чтение из сокета, если передан fd; в противном случае игнорируется. По умолчанию: false.
  • signal <AbortSignal> Сигнал Abort, который можно использовать для уничтожения сокета.
  • writable <boolean> Разрешает запись в сокет, если передан fd; в противном случае игнорируется. По умолчанию: false.
• Возвращает: <net.Socket>

Создаёт новый объект сокета.

Созданный сокет может быть TCP-сокетом или потоковой конечной точкой IPC — в зависимости от того, к чему он connect().

Событие: 'close'

• hadError <boolean> true, если в сокете произошла ошибка передачи данных.

Генерируется после полного закрытия сокета. Аргумент hadError — логическое значение, указывающее, был ли сокет закрыт из-за ошибки передачи данных.

Событие: 'connect'

Генерируется при успешном установлении соединения сокета. См. net.createConnection().

Событие: 'connectionAttempt'

• ip <string> IP-адрес, к которому пытается подключиться сокет.
• port <number> Порт, к которому пытается подключиться сокет.
• family <number> Семейство IP-адреса. Может быть 6 для IPv6 или 4 для IPv4.

Генерируется при начале новой попытки подключения. Событие может генерироваться несколько раз, если в параметрах socket.connect(options) включён алгоритм автоматического выбора семейства адресов.

Событие: 'connectionAttemptFailed'

• ip <string> IP-адрес, к которому сокет пытался подключиться.
• port <number> Порт, к которому сокет пытался подключиться.
• family <number> Семейство IP-адреса. Может быть 6 для IPv6 или 4 для IPv4.
• error <Error> Ошибка, связанная со сбоем.

Генерируется при неудачной попытке подключения. Событие может генерироваться несколько раз, если в параметрах socket.connect(options) включён алгоритм автоматического выбора семейства адресов.

Событие: 'connectionAttemptTimeout'

• ip <string> IP-адрес, к которому сокет пытался подключиться.
• port <number> Порт, к которому сокет пытался подключиться.
• family <number> Семейство IP-адреса. Может быть 6 для IPv6 или 4 для IPv4.

Генерируется при превышении времени ожидания попытки подключения. Событие генерируется только (и может генерироваться несколько раз), если в параметрах socket.connect(options) включён алгоритм автоматического выбора семейства адресов.

Событие: 'data'

• Тип: <Buffer> | <string>

Генерируется при получении данных. Аргумент data будет иметь тип Buffer или String. Кодировка данных задаётся методом socket.setEncoding().

Данные будут потеряны, если у Socket нет обработчика в момент генерации события 'data'.

Событие: 'drain'

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

См. также возвращаемые значения метода socket.write().

Событие: 'end'

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

По умолчанию (allowHalfOpen имеет значение false) сокет отправляет ответный пакет завершения передачи и уничтожает файловый дескриптор после отправки всех ожидающих данных из очереди записи. Однако, если allowHalfOpen имеет значение true, сокет не будет автоматически вызывать end() для записываемой стороны, позволяя пользователю записывать произвольные объёмы данных. Чтобы закрыть соединение (то есть отправить ответный пакет FIN), пользователь должен явно вызвать end().

Событие: 'error'

• Тип: <Error>

Генерируется при возникновении ошибки. Сразу после этого события вызывается событие 'close'.

Событие: 'lookup'

Генерируется после разрешения имени хоста, но до подключения. Не применяется к сокетам Unix.

• err <Error> | <null> Объект ошибки. См. dns.lookup().
• address <string> IP-адрес.
• family <number> | <null> Тип адреса. См. dns.lookup().
• host <string> Имя хоста.

Событие: 'ready'

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

Вызывается сразу после 'connect'.

Событие: 'timeout'

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

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

socket.address()

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

Возвращает привязанные к сокету address, имя family адреса и port сокета согласно данным операционной системы: { port: 12346, family: 'IPv4', address: '127.0.0.1' }

socket.autoSelectFamilyAttemptedAddresses

• Тип: <string[]>

Это свойство присутствует только в том случае, если в параметрах socket.connect(options) включён алгоритм автоматического выбора семейства адресов. Оно представляет собой массив адресов, к которым предпринимались попытки подключения.

Каждый адрес — это строка в формате $IP:$PORT. Если подключение прошло успешно, последний адрес — это адрес, к которому в данный момент подключён сокет.

socket.bufferSize

• Тип: <integer>

Это свойство показывает количество символов, буферизованных для записи. Буфер может содержать строки, длина которых после кодирования ещё неизвестна. Поэтому это число является лишь приблизительной оценкой количества байтов в буфере.

Для net.Socket характерно, что socket.write() всегда работает. Это упрощает начало работы. Компьютер не всегда может обрабатывать данные с той же скоростью, с которой они записываются в сокет. Сетевое соединение может оказаться слишком медленным. Node.js помещает данные, записанные в сокет, во внутреннюю очередь и отправляет их по сети, когда это становится возможным.

Из-за такой внутренней буферизации объём памяти может увеличиваться. Пользователям, столкнувшимся с большим или растущим значением bufferSize, следует попытаться ограничить потоки данных в программе с помощью методов socket.pause() и socket.resume().

socket.bytesRead

• Тип: <integer>

Количество полученных байтов.

socket.bytesWritten

• Тип: <integer>

Количество отправленных байтов.

socket.connect()

Инициирует соединение для заданного сокета.

Возможные сигнатуры:

• socket.connect(options[, connectListener])
• socket.connect(path[, connectListener]) для соединений IPC.
• socket.connect(port[, host][, connectListener]) для TCP-соединений.
• Возвращает: <net.Socket> Сам сокет.

Эта функция выполняется асинхронно. После установления соединения генерируется событие 'connect'. Если возникнет проблема с подключением, вместо события 'connect' будет сгенерировано событие 'error', а ошибка будет передана обработчику 'error'. Последний параметр connectListener, если он указан, будет однократно добавлен в качестве обработчика события 'connect'.

Эту функцию следует использовать только для повторного подключения сокета после генерации события 'close'; в противном случае это может привести к неопределённому поведению.

socket.connecting

• Тип: <boolean>

Если значение равно true, был вызван метод socket.connect(options[, connectListener]), который ещё не завершил работу. Значение останется равным true, пока сокет не подключится; после этого оно изменится на false и будет сгенерировано событие 'connect'. Обратите внимание, что функция обратного вызова socket.connect(options[, connectListener]) является обработчиком события 'connect'.

socket.destroy([error])

• error <Object>
• Возвращает: <net.Socket>

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

Дополнительные сведения см. в разделе writable.destroy().

socket.destroyed

• Тип: <boolean> Указывает, уничтожено ли соединение. После уничтожения соединения передача данных через него невозможна.

Дополнительные сведения см. в разделе writable.destroyed.

socket.destroySoon()

Уничтожает сокет после записи всех данных. Если событие 'finish' уже было создано, сокет уничтожается немедленно. Если сокет всё ещё доступен для записи, неявно вызывается socket.end().

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

• data <string> | <Buffer> | <Uint8Array>
• encoding <string> Используется только в том случае, если данные имеют тип string. По умолчанию: 'utf8'.
• callback <Function> Необязательная функция обратного вызова, вызываемая после завершения работы с сокетом.
• Возвращает: <net.Socket> Сам сокет.

Закрывает сокет для передачи данных в одном направлении. То есть отправляет пакет FIN. Сервер всё ещё может отправить некоторые данные.

Дополнительные сведения см. в разделе writable.end().

socket.localAddress

• Тип: <string>

Строковое представление локального IP-адреса, по которому подключается удалённый клиент. Например, если сервер прослушивает '0.0.0.0', а клиент подключается по адресу '192.168.1.1', значение socket.localAddress будет равно '192.168.1.1'.

socket.localPort

• Тип: <integer>

Числовое представление локального порта. Например, 80 или 21.

socket.localFamily

• Тип: <string>

Строковое представление локального семейства IP-адресов: 'IPv4' или 'IPv6'.

socket.pause()

• Возвращает: <net.Socket> Сам сокет.

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

socket.pending

• Тип: <boolean>

Значение равно true, если сокет ещё не подключён: либо потому, что .connect() ещё не был вызван, либо потому, что подключение всё ещё выполняется (см. socket.connecting).

socket.ref()

• Возвращает: <net.Socket> Сам сокет.

Противоположность unref(): вызов ref() для сокета, ранее вызвавшего unref, не позволит программе завершиться, если это единственный оставшийся сокет (поведение по умолчанию). Если для сокета уже был вызван ref, повторный вызов ref не повлияет на результат.

socket.remoteAddress

• Тип: <string>

Строковое представление удалённого IP-адреса. Например, '74.125.127.100' или '2001:4860:a005::68'. Если сокет уничтожен (например, если клиент отключился), значение может быть undefined.

socket.remoteFamily

• Тип: <string>

Строковое представление удалённого семейства IP-адресов: 'IPv4' или 'IPv6'. Если сокет уничтожен (например, если клиент отключился), значение может быть undefined.

socket.remotePort

• Тип: <integer>

Числовое представление удалённого порта. Например, 80 или 21. Если сокет уничтожен (например, если клиент отключился), значение может быть undefined.

socket.resetAndDestroy()

• Возвращает: <net.Socket>

Закрывает TCP-соединение, отправляя пакет RST, и уничтожает поток. Если TCP-сокет находится в состоянии подключения, он отправит пакет RST и уничтожит этот TCP-сокет после установления соединения. В противном случае будет вызван socket.destroy с ошибкой ERR_SOCKET_CLOSED. Если это не TCP-сокет (например, канал), вызов этого метода немедленно приведёт к ошибке ERR_INVALID_HANDLE_TYPE.

socket.resume()

• Возвращает: <net.Socket> Сам сокет.

Возобновляет чтение после вызова socket.pause().

socket.setEncoding([encoding])

• encoding <string>
• Возвращает: <net.Socket> Сам сокет.

Задаёт кодировку сокета как читаемого потока. Дополнительные сведения см. в разделе readable.setEncoding().

socket.setKeepAlive([enable][, initialDelay])

• enable <boolean> По умолчанию: false
• initialDelay <number> По умолчанию: 0
• Возвращает: <net.Socket> Сам сокет.

Включает или отключает функцию keep-alive и при необходимости задаёт задержку перед отправкой первой проверки keep-alive для неактивного сокета.

Задайте initialDelay (в миллисекундах), чтобы установить задержку между получением последнего пакета данных и первой проверкой keep-alive. Если для initialDelay задано значение 0, значение останется неизменным относительно настройки по умолчанию (или предыдущей настройки).

При включении функции keep-alive задаются следующие параметры сокета:

• SO_KEEPALIVE=1
• TCP_KEEPIDLE=initialDelay
• TCP_KEEPCNT=10
• TCP_KEEPINTVL=1

socket.setNoDelay([noDelay])

• noDelay <boolean> По умолчанию: true
• Возвращает: <net.Socket> Сам сокет.

Включает или отключает алгоритм Нейгла.

При создании TCP-соединения алгоритм Нейгла включён.

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

Передача true для noDelay или отсутствие аргумента отключает алгоритм Нейгла для сокета. Передача false для noDelay включает алгоритм Нейгла.

socket.setTimeout(timeout[, callback])

• timeout <number>
• callback <Function>
• Возвращает: <net.Socket> Сам сокет.

Задаёт время ожидания сокета в timeout миллисекунд бездействия. По умолчанию у net.Socket время ожидания не задано.

При срабатывании тайм-аута бездействия сокет получит событие 'timeout', но соединение не будет разорвано. Пользователь должен вручную вызвать socket.end() или socket.destroy(), чтобы завершить соединение.

socket.setTimeout(3000);
socket.on('timeout', () => {
  console.log('socket timeout');
  socket.end();
}); copy

Если значение timeout равно 0, существующий тайм-аут бездействия отключается.

Необязательный параметр callback будет добавлен как одноразовый обработчик события 'timeout'.

socket.timeout

• Тип: <number> | <undefined>

Время ожидания сокета в миллисекундах, заданное методом socket.setTimeout(). Если время ожидания не задано, значение равно undefined.

socket.unref()

• Возвращает: <net.Socket> Сам сокет.

Вызов unref() для сокета позволяет программе завершиться, если это единственный активный сокет в системе событий. Если для сокета уже был вызван unref, повторный вызов unref() не повлияет на результат.

socket.write(data[, encoding][, callback])

• data <string> | <Buffer> | <Uint8Array>
• encoding <string> Используется только в том случае, если данные имеют тип string. По умолчанию: utf8.
• callback <Function>
• Возвращает: <boolean>

Отправляет данные через сокет. Второй параметр задаёт кодировку, используемую для строки. По умолчанию используется кодировка UTF8.

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

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

Дополнительные сведения см. в описании метода write() потока Writable.

socket.readyState

• Тип: <string>

Это свойство представляет состояние соединения в виде строки.

• Если поток находится в процессе подключения, socket.readyState имеет значение opening.
• Если поток доступен для чтения и записи, значение равно open.
• Если поток доступен для чтения, но не для записи, значение равно readOnly.
• Если поток недоступен ни для чтения, ни для записи, значение равно writeOnly.

net.connect(options[, connectListener])

• options <Object>
• connectListener <Function>
• Возвращает: <net.Socket>

Псевдоним net.createConnection(options[, connectListener]).

net.connect(path[, connectListener])

• path <string>
• connectListener <Function>
• Возвращает: <net.Socket>

Псевдоним net.createConnection(path[, connectListener]).

net.connect(port[, host][, connectListener])

• port <number>
• host <string>
• connectListener <Function>
• Возвращает: <net.Socket>

Псевдоним net.createConnection(port[, host][, connectListener]).

net.createConnection(options[, connectListener])

• options <Object> Обязательный параметр. Будет передан как в вызов new net.Socket([options]), так и в метод socket.connect(options[, connectListener]).
• connectListener <Function> Общий параметр функций net.createConnection(). Если указан, будет однократно добавлен как обработчик события 'connect' для возвращённого сокета.
• Возвращает: <net.Socket> Созданный сокет, используемый для начала соединения.

Доступные параметры см. в разделах new net.Socket([options]) и socket.connect(options[, connectListener]).

Дополнительные параметры:

• timeout <number> Если задан, используется для вызова socket.setTimeout(timeout) после создания сокета, но до начала соединения.

Ниже приведён пример клиента сервера эхо, описанного в разделе net.createServer():

import net from 'node:net';
const client = net.createConnection({ port: 8124 }, () => {
  // 'connect' listener.
  console.log('connected to server!');
  client.write('world!\r\n');
});
client.on('data', (data) => {
  console.log(data.toString());
  client.end();
});
client.on('end', () => {
  console.log('disconnected from server');
});

const net = require('node:net');
const client = net.createConnection({ port: 8124 }, () => {
  // 'connect' listener.
  console.log('connected to server!');
  client.write('world!\r\n');
});
client.on('data', (data) => {
  console.log(data.toString());
  client.end();
});
client.on('end', () => {
  console.log('disconnected from server');
});

Для подключения к сокету /tmp/echo.sock:

const client = net.createConnection({ path: '/tmp/echo.sock' }); copy

Ниже приведён пример клиента, использующего параметры port и onread. В этом случае параметр onread будет использоваться только для вызова new net.Socket([options]), а параметр port — для вызова socket.connect(options[, connectListener]).

import net from 'node:net';
import { Buffer } from 'node:buffer';
net.createConnection({
  port: 8124,
  onread: {
    // Reuses a 4KiB Buffer for every read from the socket.
    buffer: Buffer.alloc(4 * 1024),
    callback: function(nread, buf) {
      // Received data is available in `buf` from 0 to `nread`.
      console.log(buf.toString('utf8', 0, nread));
    },
  },
});

const net = require('node:net');
net.createConnection({
  port: 8124,
  onread: {
    // Reuses a 4KiB Buffer for every read from the socket.
    buffer: Buffer.alloc(4 * 1024),
    callback: function(nread, buf) {
      // Received data is available in `buf` from 0 to `nread`.
      console.log(buf.toString('utf8', 0, nread));
    },
  },
});

net.createConnection(path[, connectListener])

• path <string> Путь, по которому должен подключиться сокет. Будет передан в socket.connect(path[, connectListener]). См. раздел Определение путей для IPC-соединений.
• connectListener <Function> Общий параметр функций net.createConnection(), однократный обработчик события 'connect' для инициирующего сокета. Будет передан в socket.connect(path[, connectListener]).
• Возвращает: <net.Socket> Созданный сокет, используемый для начала соединения.

Инициирует соединение IPC.

Эта функция создаёт новый объект net.Socket со всеми параметрами по умолчанию, немедленно инициирует соединение с помощью socket.connect(path[, connectListener]), а затем возвращает net.Socket, инициирующий соединение.

net.createConnection(port[, host][, connectListener])

• port <number> Порт, к которому должен подключиться сокет. Будет передан в socket.connect(port[, host][, connectListener]).
• host <string> Узел, к которому должен подключиться сокет. Будет передан в socket.connect(port[, host][, connectListener]). По умолчанию: 'localhost'.
• connectListener <Function> Общий параметр функций net.createConnection(), однократный обработчик события 'connect' для инициирующего сокета. Будет передан в socket.connect(port[, host][, connectListener]).
• Возвращает: <net.Socket> Созданный сокет, используемый для начала соединения.

Инициирует TCP-соединение.

Эта функция создаёт новый объект net.Socket со всеми параметрами по умолчанию, немедленно инициирует соединение с помощью socket.connect(port[, host][, connectListener]), а затем возвращает net.Socket, инициирующий соединение.