Net

Модуль 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. К пути применяются те же соглашения об именовании и проверки прав доступа, что и при создании файла. Если сокет домена UNIX (видимый как путь в файловой системе) создан и используется вместе с одной из абстракций API Node.js, таких как net.createServer(), он будет удалён как часть server.close(). С другой стороны, если он создан и используется за пределами этих абстракций, пользователю потребуется удалить его вручную. То же самое относится к случаю, когда путь был создан API Node.js, но программа неожиданно завершилась. Вкратце, сокет домена UNIX после успешного создания будет виден в файловой системе и будет существовать до тех пор, пока не будет удалён.

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

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

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

Класс: net.Server[src]

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

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().

server.address()[src]

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

Возвращает привязанный 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());
});

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

server.close([callback])[src]

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

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

server.connections

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

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

server.getConnections(callback)[src]

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

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

Обратный вызов должен принимать два аргумента err и count.

server.listen()[src]

Запускает сервер для прослушивания соединений. 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.log('Address in use, retrying...');
    setTimeout(() => {
      server.close();
      server.listen(PORT, HOST);
    }, 1000);
  }
});

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

• handle <Object>
• backlog <number> Обычный параметр функций server.listen()
• callback <Function> Обычный параметр функций server.listen()
• Возвращает: <net.Server>

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

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

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

server.listen(options[, callback])[src]

• options <Object> Обязательно. Поддерживает следующие свойства:

  • port <number>
  • host <string>
  • path <string> Будет игнорироваться, если указан port. См. Идентификация путей для IPC-подключений.
  • backlog <number> Обычный параметр функций server.listen().
  • exclusive <boolean> По умолчанию: false
  • readableAll <boolean> Для IPC-серверов делает канал доступным для чтения для всех пользователей. По умолчанию: false
  • writableAll <boolean> Для IPC-серверов делает канал доступным для записи для всех пользователей. По умолчанию: false
• callback <Function> Обычный параметр функций server.listen().
• Возвращает: <net.Server>

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

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

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

Запуск IPC-сервера от имени root может привести к тому, что путь к серверу станет недоступен для непривилегированных пользователей. Использование readableAll и writableAll сделает сервер доступным для всех пользователей.

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

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

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

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

• port <number>
• host <string>
• backlog <number> Обычный параметр функций server.listen().
• callback <Function> Обычный параметр функций server.listen().
• Возвращает: <net.Server>

Запустить 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

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

server.maxConnections

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

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

server.ref()[src]

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

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

server.unref()[src]

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

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

Класс: net.Socket[src]

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

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

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

new net.Socket([options])

• options <Object> Доступные параметры:

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

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

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

Событие: 'close'

• hadError <boolean> true если у сокета произошла ошибка передачи.

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

Событие: 'connect'

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

Событие: 'data'

• <Buffer> | <string>

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

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

Событие: 'drain'

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

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

Событие: 'end'

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

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

Событие: 'error'

• <Error>

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

Событие: 'lookup'

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

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

Событие: 'ready'

Вызывается, когда сокет готов к использованию.

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

Событие: 'timeout'

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

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

socket.address()[src]

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

Возвращает связанный address, имя адреса family и port сокета, как сообщается операционной системой: { 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()[src]

Инициировать соединение на данном сокете.

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

• 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])[src]

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

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

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

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

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

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

socket.connect(path[, connectListener])[src]

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

Инициировать IPC соединение на данном сокете.

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

socket.connect(port[, host][, connectlistener])[src]

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

Инициировать TCP-соединение на данном сокете.

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

socket.connecting

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

socket.destroy([exception])

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

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

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

socket.destroyed

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

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

• data <string> | <Buffer> | <Uint8Array>
• encoding <string> Используется только тогда, когда данные являются string. По умолчанию: 'utf8'.
• callback <Function> Необязательный обратный вызов после завершения работы сокета.
• Возвращает: <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()

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

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

socket.pending

• <boolean>

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

socket.ref()[src]

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

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

socket.remoteAddress

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

socket.remoteFamily

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

socket.remotePort

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

socket.resume()

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

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

socket.setEncoding([encoding])

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

Устанавливает кодировку для сокета как Readable Stream. Смотрите readable.setEncoding() для получения дополнительной информации.

socket.setKeepAlive([enable][, initialdelay])[src]

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

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

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

socket.setNoDelay([noDelay])[src]

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

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

socket.setTimeout(timeout[, callback])[src]

• 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();
});

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

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

socket.unref()[src]

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

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

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

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

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

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

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

Смотрите метод потока Writable write() для получения дополнительной информации.

net.connect()[src]

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

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

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

net.connect(options[, connectListener])[src]

• options <Object>
• connectListener <Function>

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

net.connect(path[, connectListener])[src]

• path <string>
• connectListener <Function>

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

net.connect(port[, host][, connectlistener])[src]

• port <number>
• host <string>
• connectListener <Function>

Псевдоним для 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 <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():

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

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

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

net.createServer([options][, connectionlistener])[src]

• options <Object>

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

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

Если 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)

• input <string>
• Возвращает: <integer>

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

net.isIPv4(input)

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

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

net.isIPv6(input)

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

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