Поддержка IPC

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

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

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

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

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

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

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

Класс: net.Server

• Расширяет: <EventEmitter>

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

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

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

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

Событие: 'close'

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

Событие: 'connection'

• <net.Socket> Объект соединения

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

Событие: 'error'

• <Ошибка>

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

Событие: 'listening'

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

server.address()

• Возвращает: <Объект> | <строка> | <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());
});

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

server.close([callback])

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

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

server.connections

• <целое> | <null>

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

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

server.getConnections(callback)

• callback <Функция>
• Возвращает: <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.log('Address in use, retrying...');
    setTimeout(() => {
      server.close();
      server.listen(PORT, HOST);
    }, 1000);
  }
});

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

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

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

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

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

server.listen(options[, callback])

• options <Object> Требуется. Поддерживает следующие свойства:
  • port <число>
  • host <строка>
  • path <строка> Будет проигнорировано, если port указано. См. Определение путей для соединений IPC.
  • backlog <число> Общий параметр функций server.listen().
  • exclusive <булево> По умолчанию: false
  • readableAll <булево> Для серверов IPC делает канал доступным для чтения всем пользователям. По умолчанию: false.
  • writableAll <булево> Для серверов IPC делает канал доступным для записи всем пользователям. По умолчанию: false.
  • ipv6Only <булево> Для TCP-серверов, установка ipv6Only на true отключит поддержку двойного стека, т.е. привязка к хосту :: не приведет к тому, что 0.0.0.0 будет привязан. По умолчанию: false.
• callback <Функция> функции.
• Возвращает: <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 от имени администратора может сделать путь к серверу недоступным для непривилегированных пользователей. Использование readableAll и writableAll сделает сервер доступным для всех пользователей.

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

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

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

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

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

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

server.maxConnections

• <целое>

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

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

server.ref()

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

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

server.unref()

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

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

Класс: net.Socket

• Расширяет: <stream.Duplex>

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

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

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

new net.Socket([options])

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

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

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

Событие: 'close'

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

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

Событие: 'connect'

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

Событие: 'data'

• <Буфер> | <строка>

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

Данные будут потеряны, если нет слушателя, когда Socket вызывает событие '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 <имя хоста>.

Событие: 'ready'

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

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

Событие: 'timeout'

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

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

socket.address()

• Возвращает: <Объект>

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

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

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

• 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.connect(options[, connectListener])

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

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

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

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

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

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

Для обоих типов доступны параметры:

• onread <Объект> Если указано, входящие данные хранятся в одном buffer и передаются предоставленной callback при поступлении данных на сокет. Это заставит функцию потоковой передачи не предоставлять никаких данных. Сокет будет генерировать события, такие как 'error', 'end', и 'close', как обычно. Методы, такие как pause() и resume(), также будут работать как ожидается.
  • buffer <Буфер> | <Uint8 массив> | <Функция> Либо повторно используемый фрагмент памяти для хранения входящих данных, либо функция, возвращающая такой фрагмент.
  • callback <Функция> Эта функция вызывается для каждого фрагмента входящих данных. Ей передаются два аргумента: количество байтов, записанных в buffer, и ссылка на buffer. Возврат false из этой функции неявно pause() сокет. Эта функция будет выполнена в глобальном контексте.

Ниже приведен пример клиента, использующего параметр onread:

const net = require('net');
net.connect({
  port: 80,
  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));
    }
  }
});

socket.connect(path[, connectListener])

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

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

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

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

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

Инициализировать 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([error])

• error <Объект>
• Возвращает: <net.Сокет>

Обеспечивает, что больше нет активности ввода-вывода на этом сокете. Уничтожает поток и закрывает соединение.

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

socket.destroyed

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

См. writable.destroyed для получения дополнительной информации.

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

• data <строка> | <Буфер> | <Uint8Массив>
• encoding <строка> Используется только при передаче данных string. По умолчанию: 'utf8'.
• callback <Функция> Необязательный обратный вызов при завершении работы сокета.
• Возвращает: <net.Сокет> Сам сокет.

Закрывает сокет наполовину. Т.е., отправляет пакет FIN. Возможна дальнейшая отправка данных сервером.

См. writable.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.Сокет> Сам сокет.

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

socket.pending

• <логическое>

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

socket.ref()

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

Противоположность unref(), вызов ref() для ранее unref сокета не позволит программе завершиться, если это единственный оставшийся сокет (по умолчанию). Если сокет refed, вызов 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.pause().

socket.setEncoding([encoding])

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

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

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

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

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

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

socket.setNoDelay([noDelay])

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

Включает/отключает использование алгоритма Nagle.

При создании TCP-соединения алгоритм Nagle включен по умолчанию.

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

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

socket.setTimeout(timeout[, callback])

• timeout <число>
• callback <Функция>
• Возвращает: <net.Сокет> Сам сокет.

Устанавливает таймаут сокета после 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.timeout

• <число> | <неопределено>

Таймаут сокета в миллисекундах, установленный с помощью socket.setTimeout(). Он undefined если таймаут не установлен.

socket.unref()

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

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

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

• data <строка> | <Буфер> | <Uint8Массив>
• encoding <строка> Используется только при передаче данных string. По умолчанию: utf8.
• callback <Функция>
• Возвращает: <логическое>

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

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

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

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

socket.readyState

• <строка>

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

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

net.connect()

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

Возможные варианты:

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

net.connect(options[, connectListener])

• options <Объект>
• connectListener <Функция>
• Возвращает: <net.Socket>

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

net.connect(path[, connectListener])

• path <строка>
• connectListener <Функция>
• Возвращает: <net.Socket>

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

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

• port <число>
• host <строка>
• connectListener <Функция>
• Возвращает: <net.Socket>

Псевдоним для 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(port[, host][, connectListener]).
• Возвращает: <net.Socket> Созданный сокет, используемый для запуска подключения.

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

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

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

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

Создаёт новый 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 <строка>
• Возвращает: <целое число>

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

net.isIPv4(input)

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

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

net.isIPv6(input)

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

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