Сеть

Исходный код: lib/net.js

Модуль 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. Типичные значения составляют 107 байт на Linux и 103 байта на macOS. Если абстракция API Node.js создает сокет Unix-доменного имени, она также удалит сокет Unix-доменного имени. Например, net.createServer() может создать сокет Unix-доменного имени, а server.close() удалит его. Но если пользователь создаёт сокет Unix-доменного имени вне этих абстракций, ему нужно будет удалить его. То же самое относится к случаям, когда API Node.js создаёт сокет 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()

Запускает сервер, ожидающий подключения. Сервер может быть 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 <Объект> Обязательно. Поддерживает следующие свойства:
  • 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.Сервер>

Если указан 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])

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

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

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

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

server.unref()

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

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

Класс: net.Socket

• Расширяет: <stream.Дуплекс>

Этот класс является абстракцией TCP-сокета или потокового конечного пункта IPC (использует именованные каналы в Windows и сокеты доменных имен в противном случае). Он также является 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.Сокет>

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

Созданный сокет может быть либо 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()

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

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

socket.bufferSize

• <integer>

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

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

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

socket.bytesRead

• <integer>

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

socket.bytesWritten

• <integer>

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

socket.connect()

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

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

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

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

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

socket.connect(options[, connectListener])

• 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, или 0. Значение 0 указывает, что разрешены как IPv4, так и IPv6 адреса. По умолчанию: 0.
• hints <number> Необязательные dns.lookup() подсказки.
• lookup <Функция> Пользовательская функция поиска. По умолчанию: dns.lookup().

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

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

Для обоих типов, доступны options:

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

Установить соединение IPC на заданном сокете.

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

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

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

Установить TCP-соединение на заданном сокете.

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

socket.connecting

• <boolean>

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

socket.destroy([error])

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

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

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

socket.destroyed

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

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

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

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

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

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

socket.localAddress

• <string>

Строковое представление локального 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

• <boolean>

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

socket.ref()

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

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

socket.remoteAddress

• <string>

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

socket.remoteFamily

• <string>

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

socket.remotePort

• <целое>

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

socket.resume()

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

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

socket.setEncoding([encoding])

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

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

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

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

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

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

socket.setNoDelay([noDelay])

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

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

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

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

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

socket.setTimeout(timeout[, callback])

• 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() для сокета позволит программе выйти, если это единственный активный сокет в системе событий. Если сокет уже unrefed, вызов unref() снова не повлияет.

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

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

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

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

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

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

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.Сокет> Новый созданный сокет, используемый для начала подключения.

Инициализирует подключение 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.Сокет> Новый созданный сокет, используемый для начала подключения.

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

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

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

• options <Объект>
  • allowHalfOpen <логическое значение> Указывает, разрешены ли полуоткрытые TCP-соединения. По умолчанию: false.
  • pauseOnConnect <логическое значение> Указывает, должен ли сокет приостанавливаться при входящих подключениях. По умолчанию: 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 <строка>
• Возвращает: <логическое значение>

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

net.isIPv6(input)

• input <строка>
• Возвращает: <логическое значение>

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