Сеть

Модуль net предоставляет асинхронный сетевой API для создания основанных на потоках TCP или IPC серверов (net.createServer()) и клиентов (net.createConnection()).

К нему можно получить доступ, используя:

const net = require('net');

Поддержка IPC

Модуль net поддерживает IPC с именованными каналами на Windows и сокетами доменной области UNIX на других операционных системах.

Определение путей для подключений IPC

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

В UNIX, локальная область также известна как область UNIX. Путь — это имя пути в файловой системе. Он обрезается до sizeof(sockaddr_un.sun_path) - 1, что варьируется в разных операционных системах от 91 до 107 байтов. Типичные значения составляют 107 в Linux и 103 в macOS. Путь подчиняется тем же правилам именования и проверкам прав, что и при создании файла. Он будет виден в файловой системе и сохранится до удаления.

В Windows локальная область реализована с использованием именованного канала. Путь обязательно должен ссылаться на запись в \\?\pipe\ или \\.\pipe\. Разрешены любые символы, но последний может выполнить некоторую обработку имён каналов, например, разрешение .. последовательностей. Несмотря на внешнее представление, пространство имён каналов плоское. Каналы не сохраняются; они удаляются, когда закрывается последняя ссылка на них. Не забывайте, что в JavaScript для экранирования строк пути требуются двойные обратные косые черты, такие как:

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

Класс: net.Server

Этот класс используется для создания TCP или IPC сервера.

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

См. net.createServer([options][, connectionListener]).

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

Событие: 'close'

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

Событие: 'connection'

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

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

Событие: 'error'

• <Error>

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

Событие: 'listening'

Выполняется, когда сервер привязан после вызова server.listen().

server.address()

Возвращает связанный адрес, имя семейства адресов и порт сервера, как сообщает операционная система, если сервер слушает на IP-сокет. Полезно для определения назначенного порта при получении адреса, назначенного ОС. Возвращает объект со свойствами port, family, и address: { 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());
});

Не вызывайте server.address() до тех пор, пока не будет выполнено событие 'listening'.

server.close([callback])

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

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

Возвращает server.

server.connections

Количество одновременных подключений на сервере.

Это становится null при отправке сокета дочернему процессу с помощью child_process.fork(). Для опроса вилок и получения текущего количества активных подключений используйте асинхронную функцию server.getConnections() вместо этого.

server.getConnections(callback)

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

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

Обработчик должен принять два аргумента err и count.

server.listen()

Начать сервер, слушающий подключения. Сервер может быть 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() может вызываться несколько раз. Каждый последующий вызов переоткрывает сервер с использованием указанных параметров.

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

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

server.listen(handle[, backlog][, callback])

• handle <Объект>
• backlog <число> Общий параметр функций server.listen()
• callback <Функция> Общий параметр функций server.listen()
• Возвращает: <net.Server>

Начать сервер, слушающий подключения на заданном handle, который уже привязан к порту, сокету доменной области UNIX или именованному каналу Windows.

Объект handle может быть либо сервером, сокетом (любой объект с внутренним членом _handle), или объектом с членом fd, который является допустимым дескриптором файла.

Примечание: Прослушивание по дескриптору файла не поддерживается в Windows.

server.listen(options[, callback])

• options <Объект> Обязательно. Поддерживает следующие свойства:
  • port <число>
  • host <строка>
  • path <строка> Будет проигнорирована, если port указано. См. Определение путей для соединений IPC.
  • backlog <число> Общий параметр функций server.listen().
  • exclusive <логическое значение> По умолчанию: false
• callback <Функция> Общий параметр функций server.listen().
• Возвращает: <net.Сервер>

Если port указано, оно ведет себя так же, как server.listen([port][, hostname][, backlog][, callback]). В противном случае, если path указано, оно ведет себя так же, как server.listen(path[, backlog][, callback]). Если ни один из них не указан, будет выброшено исключение.

Если exclusive равно false (по умолчанию), тогда рабочие процессы кластера будут использовать тот же базовый обработчик, что позволит совместно использовать обязанности по обработке соединений. Когда exclusive равно true, обработчик не совместно используется, а попытка совместного использования порта приводит к ошибке. Ниже показан пример прослушивания на эксклюзивном порту.

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

server.listen(path[, backlog][, callback])

• path <строка> Путь, на котором сервер должен прослушивать соединения. См. Определение путей для соединений IPC.
• backlog <число> Общий параметр функций server.listen().
• callback <Функция> Общий параметр функций server.listen().
• Возвращает: <net.Сервер>

Запуск сервера IPC, прослушивающего соединения на указанном path.

server.listen([port][, host][, backlog][, callback])

• port <число>
• host <строка>
• backlog <число> Общий параметр функций server.listen().
• callback <Функция> Общий параметр функций server.listen().
• Возвращает: <net.Сервер>

Запуск TCP-сервера, прослушивающего соединения на указанном port и host.

Если port опущено или равно 0, операционная система назначит произвольный свободный порт, который можно получить, используя server.address().port после того, как событие 'listening' было излучено.

Если host опущено, сервер будет принимать соединения на неопределенном IPv6-адресе (::) при наличии IPv6 или неопределенном IPv4-адресе (0.0.0.0) в противном случае.

Примечание: В большинстве операционных систем прослушивание на неопределенном IPv6-адресе (::) может привести к тому, что net.Server также будет прослушивать на неопределенном IPv4-адресе (0.0.0.0).

server.listening

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

server.maxConnections

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

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

server.ref()

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

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

server.unref()

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

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

Класс: net.Сокет

Этот класс является абстракцией TCP-сокета или потокового конечного пункта IPC (использует именованные каналы на Windows и сокеты доменных узлов в противном случае). Сокет также является потоком дуплексного типа, поэтому он может быть как читаемым, так и записываемым, а также является EventEmitter.

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

Он также может быть создан Node.js и передан пользователю при получении соединения. Например, он передаётся слушателям события 'connection', излучаемого net.Server, поэтому пользователь может использовать его для взаимодействия с клиентом.

new net.Сокет([options])

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

• options <Объект> Доступные параметры:
  • fd: <число> Если указано, оборачивает существующий сокет с заданным дескриптором файла, в противном случае создаётся новый сокет.
  • allowHalfOpen <логическое значение> Указывает, разрешены ли полуоткрытые TCP-соединения. См. net.createServer() и событие 'end' для получения подробностей. По умолчанию: false.
  • readable <логическое значение> Разрешить чтение в сокете, когда передан fd, в противном случае игнорируется. По умолчанию: false.
  • writable <логическое значение> Разрешить запись в сокете, когда передан fd, в противном случае игнорируется. По умолчанию: false.
• Возвращает: <net.Сокет>

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

Событие: 'close'

• had_error <логическое значение> true если у сокета была ошибка передачи.

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

Событие: 'connect'

Излучается, когда соединение сокета успешно установлено. См. net.createConnection().

Событие: 'data'

• <Буфер>

Излучается, когда получены данные. Аргумент data будет Buffer или String. Кодировка данных задаётся socket.setEncoding(). (См. раздел Поток Readable для получения дополнительной информации.)

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

Событие: 'drain'

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

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

Событие: 'end'

Вызывается, когда противоположный конец сокета отправляет пакет FIN, завершая чтение сокета.

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

Событие: 'error'

• <Ошибка>

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

Событие: 'lookup'

Вызывается после разрешения имени хоста, но перед подключением. Не применимо к сокетам UNIX.

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

Событие: 'timeout'

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

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

socket.address()

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

socket.bufferSize

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

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

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

socket.bytesRead

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

socket.bytesWritten

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

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' один раз.

socket.connect(options[, connectListener])

• options <Объект>
• connectListener <Функция> Общий параметр методов socket.connect(). Будет добавлен как обработчик события 'connect' один раз.
• Возвращает: <net.Socket> Сам сокет.

Инициализирует соединение на данном сокете. Обычно этот метод не нужен, сокет должен быть создан и открыт с помощью net.createConnection(). Используйте только при реализации пользовательского сокета.

Для TCP-соединений доступны options:

• port <число> Требуется. Порт, к которому должен подключиться сокет.
• host <строка> Хост, к которому должен подключиться сокет. По умолчанию: 'localhost'.
• localAddress <строка> Локальный адрес, с которого должен подключиться сокет.
• localPort <число> Локальный порт, с которого должен подключиться сокет.
• family <число>: Версия стека IP, может быть 4 или 6. По умолчанию: 4.
• hints <число> Необязательные dns.lookup() подсказки.
• lookup <Функция> Пользовательская функция поиска. По умолчанию: dns.lookup().

Для IPC-соединений доступны options:

• path <строка> Требуется. Путь, к которому должен подключиться клиент. См. Идентификация путей для IPC-соединений. Если указан, TCP-специфические параметры игнорируются.

Возвращает socket.

socket.connect(path[, connectListener])

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

Псевдоним для socket.connect(options[, connectListener]), вызываемый с { path: path } как options.

Возвращает socket.

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

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

Инициализация TCP-соединения на данном сокете.

Псевдоним для socket.connect(options[, connectListener]), вызываемого с {port: port, host: host} в качестве options.

Возвращает socket.

socket.connecting

Если true - socket.connect(options[, connectListener]) был вызван и еще не завершен. Будет установлено в false перед выводом события connect и/или вызовом обратного вызова socket.connect(options[, connectListener]).

socket.destroy([exception])

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

Обеспечивает, что больше нет активности ввода-вывода на этом сокете. Необходимо только в случае ошибок (ошибка разбора и т. д.).

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

socket.destroyed

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

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

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

Полузакрывает сокет. Т.е., отправляет пакет FIN. Возможно, сервер всё ещё отправит данные.

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

socket.localAddress

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

socket.localPort

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

socket.pause()

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

socket.ref()

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

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

socket.remoteAddress

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

socket.remoteFamily

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

socket.remotePort

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

socket.resume()

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

socket.setEncoding([encoding])

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

Устанавливает кодировку для сокета как Поток чтения. Подробнее см. stream.setEncoding().

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

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

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

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

socket.setNoDelay([noDelay])

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

Отключает алгоритм Nagle. По умолчанию TCP-соединения используют алгоритм Nagle, буферизируя данные перед отправкой. Установка true для noDelay немедленно отправит данные каждый раз, когда вызывается socket.write().

socket.setTimeout(timeout[, callback])

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

Устанавливает тайм-аут сокета после timeout миллисекунд неактивности на сокете. По умолчанию у net.Socket нет таймаута.

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

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

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

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

socket.unref()

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

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

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

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

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

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

net.connect()

Псевдоним для net.createConnection().

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

• net.connect(options[, connectListener])
• net.connect(path[, connectListener]) для соединений IPC.
• net.connect(port[, host][, connectListener]) для TCP-соединений.

net.connect(options[, connectListener])

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

net.connect(path[, connectListener])

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

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

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

net.createConnection()

Функция-фабрика, которая создает новый net.Socket, немедленно инициирует соединение с socket.connect(), а затем возвращает net.Socket, которая запускает соединение.

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

Возможные подписи:

• net.createConnection(options[, connectListener])
• net.createConnection(path[, connectListener]) для подключений IPC.
• net.createConnection(port[, host][, connectListener]) для подключений TCP.

Примечание: Функция net.connect() является псевдонимом для этой функции.

net.createConnection(options[, connectListener])

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

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

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

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

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

const net = require('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' });

net.createConnection(path[, connectListener])

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

Инициализирует подключение IPC.

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

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

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

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

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

net.createServer([options][, connectionListener])

Создает новый TCP или IPC сервер.

• options <Объект>
  • allowHalfOpen <логическое> Указывает, разрешены ли полуоткрытые TCP-соединения. По умолчанию: false.
  • pauseOnConnect <логическое> Указывает, должен ли сокет приостанавливаться при входящих подключениях. По умолчанию: false.
• connectionListener <Функция> Автоматически устанавливается в качестве слушателя события 'connection'.
• Возвращает: <net.Server>

Если allowHalfOpen установлено в true, когда другой конец сокета отправляет пакет FIN, сервер отправит пакет FIN обратно только при явном вызове socket.end(), до тех пор, пока подключение не будет полуоткрытым (нечитаемым, но все еще записываемым). См. событие 'end' и RFC 1122 (раздел 4.2.2.13) для получения дополнительной информации.

Если pauseOnConnect установлено в true, то сокет, связанный с каждым входящим подключением, будет приостановлен, и никакие данные не будут считываться из его дескриптора. Это позволяет передавать подключения между процессами без чтения каких-либо данных исходным процессом. Чтобы начать чтение данных из приостановленного сокета, вызовите socket.resume().

Сервер может быть TCP-сервером или IPC-сервером, в зависимости от того, к чему он listen().

Вот пример TCP-эхо-сервера, который прослушивает подключения на порту 8124:

const net = require('net');
const server = net.createServer((c) => {
  // 'connection' listener
  console.log('client connected');
  c.on('end', () => {
    console.log('client disconnected');
  });
  c.write('hello\r\n');
  c.pipe(c);
});
server.on('error', (err) => {
  throw err;
});
server.listen(8124, () => {
  console.log('server bound');
});

Протестируйте это, используя telnet:

$ telnet localhost 8124

Чтобы прослушивать на сокете /tmp/echo.sock третья строка с конца будет изменена на

server.listen('/tmp/echo.sock', () => {
  console.log('server bound');
});

Используйте nc для подключения к серверу сокета UNIX-домена:

$ nc -U /tmp/echo.sock

net.isIP(input)

Проверяет, является ли входной параметр IP-адресом. Возвращает 0 для недопустимых строк, возвращает 4 для IP-адресов версии 4 и возвращает 6 для IP-адресов версии 6.

net.isIPv4(input)

Возвращает true, если входной параметр — адрес IP версии 4, в противном случае возвращает false.

net.isIPv6(input)

Возвращает true, если входной параметр — адрес IP версии 6, в противном случае возвращает false.