Net

稳定性：2 - 稳定

node:net 模块提供了一个异步网络 API，用于创建基于流的 TCP 或 IPC 服务器（net.createServer()）和客户端 （net.createConnection()）。

可以使用以下方式访问它：

import net from 'node:net';

node:net 模块在 Windows 上支持使用命名管道进行 IPC，在其他 操作系统上支持 Unix 域套接字。

net.connect()、net.createConnection()、server.listen() 和 socket.connect() 接受一个 path 参数来识别 IPC 端点。

在 Unix 上，本地域也称为 Unix 域。路径是一个 文件系统路径名。当路径名的长度 大于 sizeof(sockaddr_un.sun_path) 的长度时，它将抛出错误。典型值在 Linux 上为 107 字节，在 macOS 上为 103 字节。如果 Node.js API 抽象创建 了 Unix 域套接字，它也会取消链接该 Unix 域套接字。例如，net.createServer() 可能创建一个 Unix 域套接字，而 server.close() 将取消链接它。但是如果用户在这些抽象之外创建 Unix 域 套接字，用户将需要手动移除它。当 Node.js API 创建 Unix 域套接字但程序随后 崩溃时，同样适用。简而言之，Unix 域套接字将在文件系统中可见，并且 将持续存在直到被取消链接。在 Linux 上，你可以通过在路径开头添加 \0 来使用 Unix 抽象套接字，例如 \0abstract。Unix 抽象套接字的路径 在文件系统中不可见，并且当所有对套接字的开放引用关闭时它将自动消失。

在 Windows 上，本地域是使用命名管道实现的。路径 必须 引用 \\?\pipe\ 或 \\.\pipe\ 中的条目。允许使用任何字符， 但后者可能会对管道名称进行一些处理，例如解析 .. 序列。尽管它看起来可能如何，管道命名空间是扁平的。管道将 不会持久存在。当对它们的最后一个引用关闭时，它们会被移除。 与 Unix 域套接字不同，当拥有进程退出时，Windows 将关闭并移除管道。

JavaScript 字符串转义要求路径使用额外的反斜杠转义来指定，例如：

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

BlockList 对象可与某些网络 API 一起使用，以指定规则 禁用对特定 IP 地址、IP 范围或 IP 子网的入站或出站访问。

blockList.addAddress(address, type?): void

添加一条规则以阻止给定的 IP 地址。

blockList.addRange(start, end, type?): void

添加一条规则以阻止从 start（包含）到 end（包含）的 IP 地址范围。

blockList.addSubnet(net, prefix, type?): void

添加一条规则以阻止指定为子网掩码的 IP 地址范围。

blockList.check(address, type?): void

如果给定的 IP 地址匹配添加到 BlockList 的任何规则，则返回 true。

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

console.log(blockList.check('123.123.123.123'));  // 输出：true
console.log(blockList.check('10.0.0.3'));  // 输出：true
console.log(blockList.check('222.111.111.222'));  // 输出：false

// IPv4 地址的 IPv6 表示法有效：
console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // 输出：true
console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // 输出：true

• 类型：<string[]>

添加到阻止列表的规则列表。

BlockList.isBlockList(value): void

blockList.fromJSON(value): void

稳定性：1 - 实验性

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

• value Blocklist.rules

blockList.toJSON(): void

稳定性：1 - 实验性

• 返回 Blocklist.rules

new net.SocketAddress(options?): void

• 类型：<string>

• 类型：<string> 'ipv4' 或 'ipv6'。

• 类型：<number>

• 类型：<number>

SocketAddress.parse(input): void

• 继承自：{EventEmitter}

此类用于创建 TCP 或 IPC 服务器。

new net.Server(options?, connectionListener?): void

net.Server 是一个 EventEmitter，具有以下事件：

当服务器关闭时发出。如果存在连接，则此 事件直到所有连接结束后才会发出。

• 类型：<net.Socket> 连接对象

当建立新连接时发出。socket 是 net.Socket 的实例。

• 类型：<Error>

当发生错误时发出。与 net.Socket 不同，'close' 事件不会在此事件之后直接发出，除非 手动调用 server.close()。参见 server.listen() 讨论中的示例。

当调用 server.listen() 后服务器已绑定时发出。

当连接数达到 server.maxConnections 的阈值时， 服务器将丢弃新连接并发出 'drop' 事件。如果是 TCP 服务器，则参数如下，否则参数为 undefined。

server.address(): void

• 返回：<Object> | <string> | <null>

如果在监听 IP 套接字，则返回操作系统报告的服务器绑定的 address、地址 family 名称和 port （当获取操作系统分配的地址时，用于查找分配了哪个端口很有用）： { port: 12346, family: 'IPv4', address: '127.0.0.1' }。

对于监听管道或 Unix 域套接字的服务器，名称作为 字符串返回。

const server = net.createServer((socket) => {
  socket.end('goodbye\n');
}).on('error', (err) => {
  // 在此处处理错误。
  throw err;
});

// 获取一个任意未使用的端口。
server.listen(() => {
  console.log('opened server on', server.address());
});

在 'listening' 事件发出之前或调用 server.close() 之后， server.address() 返回 null。

server.close(callback?): void

停止服务器接受新连接并保持现有 连接。此函数是异步的，当所有连接结束且服务器发出 'close' 事件时，服务器最终关闭。 可选的 callback 将在 'close' 事件发生时调用一次。与该事件不同，如果服务器 在关闭时未开启，它将仅带有一个 Error 作为其参数被调用。

server[Symbol.asyncDispose](): void

调用 server.close() 并返回一个 promise，当服务器 关闭时该 promise 会被兑现。

server.getConnections(callback): void

异步获取服务器上的并发连接数。当套接字被发送到 叉进程时有效。

回调应接受两个参数 err 和 count。

server.listen(): void

启动服务器监听连接。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 设置确定，例如 Linux 上的 tcp_max_syn_backlog 和 somaxconn。此参数的默认值为 511（不是 512）。

所有 net.Socket 都设置为 SO_REUSEADDR（详见 socket(7)）。

当且仅当第一次 server.listen() 调用期间发生错误或已调用 server.close() 时，才可以再次调用 server.listen() 方法。否则，将抛出 ERR_SERVER_ALREADY_LISTEN 错误。

监听时引发的最常见错误之一是 EADDRINUSE。 当另一个服务器已经在监听从请求的 port/path/handle 时，会发生这种情况。处理此问题的一种方法是在 一定时间后重试：

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

server.listen(handle, backlog?, callback?): void

在已经绑定到端口、Unix 域套接字或 Windows 命名管道的给定 handle 上 启动服务器监听连接。

handle 对象可以是服务器、套接字（任何具有底层 _handle 成员的对象），或具有 有效文件描述符的 fd 成员的对象。

Windows 上不支持监听文件描述符。

server.listen(options, callback?): void

如果指定了 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,
});

当 exclusive 为 true 且底层句柄被共享时， 几个工作进程可能会使用不同的 backlog 查询句柄。 在这种情况下，将使用传递给主进程的第一个 backlog。

以 root 身份启动 IPC 服务器可能会导致服务器路径对 非特权用户不可访问。使用 readableAll 和 writableAll 将使服务器 对所有用户可访问。

如果启用了 signal 选项，在相应的 AbortController 上调用 .abort() 类似于在服务器上调用 .close()：

const controller = new AbortController();
server.listen({
  host: 'localhost',
  port: 80,
  signal: controller.signal,
});
// 稍后，当你想要关闭服务器时。
controller.abort();

server.listen(path, backlog?, callback?): void

启动 IPC 服务器监听给定 path 上的连接。

server.listen(port?, host?, backlog?, callback?): void

启动 TCP 服务器监听给定 port 和 host 上的连接。

如果省略 port 或为 0，操作系统将分配一个任意 未使用的端口，可以在 'listening' 事件发出后 通过使用 server.address().port 检索该端口。

如果省略 host，当 IPv6 可用时，服务器将接受 未指定的 IPv6 地址 (::) 上的连接，否则接受 未指定的 IPv4 地址 (0.0.0.0) 上的连接。

在大多数操作系统中，监听 未指定的 IPv6 地址 (::) 可能会导致 net.Server 也监听 未指定的 IPv4 地址 (0.0.0.0)。

• 类型：<boolean> 指示服务器是否正在监听连接。

• 类型：<integer>

当连接数达到 server.maxConnections 阈值时：

1. 如果进程未在集群模式下运行，Node.js 将关闭连接。

2. 如果进程在集群模式下运行，默认情况下，Node.js 会将连接路由到另一个工作进程。要改为关闭连接，请将 server.dropMaxConnection 设置为 true。

一旦套接字已通过 child_process.fork() 发送到子进程， 不建议使用此选项。

• 类型：<boolean>

将此属性设置为 true 以在连接数达到 server.maxConnections 阈值时开始关闭连接。此设置仅在集群模式下有效。

server.ref(): void

• 返回：<net.Server>

unref() 的反操作，对之前 unref 的服务器调用 ref() 将 不会 让程序退出，如果它是唯一剩下的服务器（默认行为）。 如果服务器已 ref，再次调用 ref() 将无效。

server.unref(): void

• 返回：<net.Server>

在服务器上调用 unref() 将允许程序退出，如果这是 事件系统中唯一的活跃服务器。如果服务器已经 unref，再次调用 unref() 将无效。

• 继承自：<stream.Duplex>

此类是 TCP Socket 或流式 IPC 端点（在 Windows 上使用命名管道，在其他系统上使用 Unix 域套接字）的抽象。它也是一个 EventEmitter。

net.Socket 可以由用户创建并直接用于与服务器交互。例如，它由 net.createConnection() 返回，因此用户可以使用它与服务器通信。

它也可以由 Node.js 创建并在收到连接时传递给用户。例如，它被传递给 net.Server 上发出的 'connection' 事件的监听器，因此用户可以使用它与客户端交互。

new net.Socket(options?): void

创建一个新的 Socket 对象。

新创建的 Socket 可以是 TCP Socket 或流式 IPC 端点，具体取决于它 connect() 到什么。

在 Socket 完全关闭后发出。参数 hadError 是一个布尔值，表示 Socket 是否因传输错误而关闭。

在 Socket 连接成功建立时发出。 详见 net.createConnection()。

在新的连接尝试启动时发出。如果在 socket.connect(options) 中启用了族自动选择算法，则可能会多次发出此事件。

在连接尝试失败时发出。如果在 socket.connect(options) 中启用了族自动选择算法，则可能会多次发出此事件。

在连接尝试超时时发出。仅当在 socket.connect(options) 中启用了族自动选择算法时才会发出此事件（并且可能会多次发出）。

• 类型：<string>

在收到数据时发出。参数 data 将是 Buffer 或 String。数据的编码由 socket.setEncoding() 设置。

如果 Socket 发出 'data' 事件时没有监听器，数据将会丢失。

在写入缓冲区变为空时发出。可用于限制上传。

另见：socket.write() 的返回值。

当 Socket 的另一端信号传输结束时发出，从而结束 Socket 的可读端。

默认情况下（allowHalfOpen 为 false），Socket 将发送一个传输结束包，并在写出其待处理的写入队列后销毁其文件描述符。但是，如果 allowHalfOpen 设置为 true，则 Socket 不会自动 end() 其可写端，允许用户写入任意数量的数据。用户必须显式调用 end() 来关闭连接（即发送一个 FIN 包回来）。

• 类型：<Error>

在发生错误时发出。'close' 事件将在此事件之后直接调用。

在解析主机名之后但在连接之前发出。 不适用于 Unix 套接字。

在 Socket 准备好使用时发出。

在 'connect' 之后立即触发。

如果 Socket 因不活动而超时时发出。这仅用于通知 Socket 处于空闲状态。用户必须手动关闭连接。

另见：socket.setTimeout()。

socket.address(): void

• 返回：<Object>

返回操作系统报告的 Socket 绑定的 address、地址 family 名称和 port： { port: 12346, family: 'IPv4', address: '127.0.0.1' }

• 类型：<string[]>

仅当在 socket.connect(options) 中启用了族自动选择算法时，此属性才存在，它是已尝试地址的数组。

每个地址都是 $IP:$PORT 形式的字符串。如果连接成功，则最后一个地址是 Socket 当前连接的地址。

稳定性：0 - 已废弃：改用 writable.writableLength。

• 类型：<integer>

此属性显示缓冲用于写入的字符数。缓冲区可能包含编码后长度未知的字符串。因此这个数字只是缓冲区中字节数的近似值。

net.Socket 具有 socket.write() 始终有效的属性。这是为了帮助用户快速上手。计算机无法总是跟上写入 Socket 的数据量。网络连接可能 просто 太慢。Node.js 将在内部队列化写入 Socket 的数据，并在可能时通过线路发送出去。

此内部缓冲的后果是内存可能会增长。遇到大型或不断增长的 bufferSize 的用户应尝试使用 socket.pause() 和 socket.resume() 在其程序中“限制”数据流。

• 类型：<integer>

接收的字节数。

• 类型：<integer>

发送的字节数。

socket.connect(): void

在给定的 Socket 上发起连接。

可能的签名：

• socket.connect(options[, connectListener])
• socket.connect(path[, connectListener]) 用于 IPC 连接。
• socket.connect(port[, host][, connectListener]) 用于 TCP 连接。
• 返回：<net.Socket> Socket 本身。

此函数是异步的。当连接建立时，将发出 'connect' 事件。如果连接有问题，将发出 'error' 事件而不是 'connect' 事件，错误将传递给 'error' 监听器。 最后一个参数 connectListener，如果提供，将作为 'connect' 事件的监听器添加一次。

此函数仅应用于在发出 'close' 后重新连接 Socket，否则可能导致未定义的行为。

socket.connect(options, connectListener?): void

在给定的 Socket 上发起连接。通常不需要此方法，Socket 应使用 net.createConnection() 创建和打开。仅在实现自定义 Socket 时使用此方法。

对于 TCP 连接，可用的 options 包括：

对于 IPC 连接，可用的 options 包括：

socket.connect(path, connectListener?): void

在给定的 Socket 上发起 IPC 连接。

别名于 socket.connect(options[, connectListener]) 调用时 { path: path } 作为 options。

socket.connect(port, host?, connectListener?): void

在给定的 Socket 上发起 TCP 连接。

别名于 socket.connect(options[, connectListener]) 调用时 {port: port, host: host} 作为 options。

• 类型：<boolean>

如果为 true， socket.connect(options[, connectListener]) 已 调用但尚未完成。它将保持 true 直到 Socket 连接，然后设置为 false 并发出 'connect' 事件。注意 socket.connect(options[, connectListener]) 回调是 'connect' 事件的监听器。

socket.destroy(error?): void

确保此 Socket 上不再发生 I/O 活动。 销毁流并关闭连接。

详见 writable.destroy() 以获取更多详情。

• 类型：<boolean> 指示连接是否已销毁。一旦连接被销毁，不能再使用它传输任何数据。

详见 writable.destroyed 以获取更多详情。

socket.destroySoon(): void

在所有数据写入后销毁 Socket。如果 'finish' 事件已经发出，则立即销毁 Socket。如果 Socket 仍可写，则隐式调用 socket.end()。

socket.end(data?, encoding?, callback?): void

半关闭 Socket。即，它发送一个 FIN 包。服务器可能仍会发送一些数据。

详见 writable.end() 以获取更多详情。

• 类型：<string>

远程客户端连接的本地 IP 地址的字符串表示。例如，在监听 '0.0.0.0' 的服务器中，如果客户端在 '192.168.1.1' 上连接，则 socket.localAddress 的值将是 '192.168.1.1'。

• 类型：<integer>

本地端口的数字表示。例如，80 或 21。

• 类型：<string>

本地 IP 族的字符串表示。'IPv4' 或 'IPv6'。

socket.pause(): void

• 返回：<net.Socket> Socket 本身。

暂停数据读取。即，'data' 事件将不会发出。 可用于限制上传。

• 类型：<boolean>

如果 Socket 尚未连接，则为 true，要么是因为 .connect() 尚未调用，要么是因为它仍在连接过程中（详见 socket.connecting）。

socket.ref(): void

• 返回：<net.Socket> Socket 本身。

unref() 的反义词，在先前 unref 的 Socket 上调用 ref() 将 不 允许程序退出，如果它是唯一剩下的 Socket（默认行为）。如果 Socket 已 ref，再次调用 ref 将无效。

• 类型：<string>

远程 IP 地址的字符串表示。例如， '74.125.127.100' 或 '2001:4860:a005::68'。如果 Socket 已销毁（例如，如果客户端断开连接），值可能为 undefined。

• 类型：<string>

远程 IP 族的字符串表示。'IPv4' 或 'IPv6'。如果 Socket 已销毁（例如，如果客户端断开连接），值可能为 undefined。

• 类型：<integer>

远程端口的数字表示。例如，80 或 21。如果 Socket 已销毁（例如，如果客户端断开连接），值可能为 undefined。

socket.resetAndDestroy(): void

• 返回：<net.Socket>

通过发送 RST 包关闭 TCP 连接并销毁流。 如果此 TCP Socket 处于连接状态，它将在连接后发送 RST 包并销毁此 TCP Socket。 否则，它将使用 ERR_SOCKET_CLOSED 错误调用 socket.destroy。 如果这不是 TCP Socket（例如，管道），调用此方法将立即抛出 ERR_INVALID_HANDLE_TYPE 错误。

socket.resume(): void

• 返回：<net.Socket> Socket 本身。

在调用 socket.pause() 后恢复读取。

socket.setEncoding(encoding?): void

将 Socket 的编码设置为 可读流。详见 readable.setEncoding() 以获取更多信息。

socket.setKeepAlive(enable?, initialDelay?): void

启用/禁用保活功能，并可选设置在空闲 Socket 上发送第一个保活探测之前的初始延迟。

设置 initialDelay（以毫秒为单位）以设置最后一个数据包接收和第一个保活探测之间的延迟。将 0 设置为 initialDelay 将使值保持与默认值（或之前的设置）不变。

启用保活功能将设置以下 Socket 选项：

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

socket.setNoDelay(noDelay?): void

启用/禁用 Nagle 算法的使用。

创建 TCP 连接时，将启用 Nagle 算法。

Nagle 算法在网络发送之前延迟数据。它试图以延迟为代价优化吞吐量。

为 noDelay 传递 true 或不传递参数将禁用 Socket 的 Nagle 算法。为 noDelay 传递 false 将启用 Nagle 算法。

socket.setTimeout(timeout, callback?): void

设置 Socket 在 Socket 上不活动 timeout 毫秒后超时。默认情况下 net.Socket 没有超时。

当触发空闲超时时，Socket 将收到 'timeout' 事件，但连接不会被切断。用户必须手动调用 socket.end() 或 socket.destroy() 来结束连接。

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

如果 timeout 为 0，则禁用现有的空闲超时。

可选的 callback 参数将作为 'timeout' 事件的一次性监听器添加。

socket.getTypeOfService(): void

• 返回：<integer> 当前的 TOS 值。

返回此 Socket 的 IPv4 数据包的当前服务类型 (TOS) 字段或 IPv6 数据包的流量类别。

setTypeOfService() 可以在 Socket 连接之前调用；值将被缓存并在 Socket 建立连接时应用。 getTypeOfService() 甚至在连接之前也会返回当前设置的值。

在某些平台（例如，Linux）上，某些 TOS/ECN 位可能被屏蔽或忽略，并且行为在 IPv4 和 IPv6 或双栈 Socket 之间可能不同。调用者应验证特定于平台的语义。

socket.setTypeOfService(tos): void

设置从此 Socket 发送的 IPv4 数据包的服務類型 (TOS) 字段或 IPv6 数据包的流量类别。这可用于优先处理网络流量。

setTypeOfService() 可以在 Socket 连接之前调用；值将被缓存并在 Socket 建立连接时应用。 getTypeOfService() 甚至在连接之前也会返回当前设置的值。

在某些平台（例如，Linux）上，某些 TOS/ECN 位可能被屏蔽或忽略，并且行为在 IPv4 和 IPv6 或双栈 Socket 之间可能不同。调用者应验证特定于平台的语义。

• 类型：<number> | <undefined>

由 socket.setTimeout() 设置的 Socket 超时（毫秒）。 如果未设置超时，则为 undefined。

socket.unref(): void

• 返回：<net.Socket> Socket 本身。

在 Socket 上调用 unref() 将允许程序退出，如果这是事件系统中唯一活动的 Socket。如果 Socket 已经 unref，再次调用 unref() 将无效。

socket.write(data, encoding?, callback?): void

在 Socket 上发送数据。第二个参数指定字符串情况下的编码。默认为 UTF8 编码。

如果整个数据成功刷新到内核缓冲区，则返回 true。如果全部或部分数据排队在用户内存中，则返回 false。当缓冲区再次空闲时，将发出 'drain'。

可选的 callback 参数将在数据最终写出时执行，这可能不是立即的。

详见 Writable 流 write() 方法以获取更多信息。

• 类型：<string>

此属性表示连接的状态（字符串）。

• 如果流正在连接，socket.readyState 为 opening。
• 如果流可读且可写，则为 open。
• 如果流可读但不可写，则为 readOnly。
• 如果流不可读但可写，则为 writeOnly。

net.connect(): void

别名于 net.createConnection()。

可能的签名：

• net.connect(options[, connectListener])
• net.connect(path[, connectListener]) 用于 IPC 连接。
• net.connect(port[, host][, connectListener]) 用于 TCP 连接。

net.connect(options, connectListener?): void

别名于 net.createConnection(options[, connectListener])。

net.connect(path, connectListener?): void

别名于 net.createConnection(path[, connectListener])。

net.connect(port, host?, connectListener?): void

别名于 net.createConnection(port[, host][, connectListener])。

net.createConnection(): void

一个工厂函数，它创建一个新的 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?): void

可用选项参见 new net.Socket([options]) 和 socket.connect(options[, connectListener])。

其他选项：

以下是 net.createServer() 部分描述的回显服务器的客户端示例：

import net from 'node:net';
const client = net.createConnection({ port: 8124 }, () => {
  // 'connect' 监听器。
  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' });

以下是使用 port 和 onread 选项的客户端示例。 在这种情况下，onread 选项将仅用于调用 new net.Socket([options])，而 port 选项将用于 调用 socket.connect(options[, connectListener])。

import net from 'node:net';
import { Buffer } from 'node:buffer';
net.createConnection({
  port: 8124,
  onread: {
    // 为每次从套接字读取重用 4KiB Buffer。
    buffer: Buffer.alloc(4 * 1024),
    callback: function(nread, buf) {
      // 接收到的数据在 `buf` 中从 0 到 `nread` 可用。
      console.log(buf.toString('utf8', 0, nread));
    },
  },
});

net.createConnection(path, connectListener?): void

发起一个 IPC 连接。

此函数创建一个所有选项设置为默认值的新 net.Socket， 立即使用 socket.connect(path[, connectListener]) 发起连接， 然后返回启动连接的 net.Socket。

net.createConnection(port, host?, connectListener?): void

发起一个 TCP 连接。

此函数创建一个所有选项设置为默认值的新 net.Socket， 立即使用 socket.connect(port[, host][, connectListener]) 发起连接， 然后返回启动连接的 net.Socket。

net.createServer(options?, connectionListener?): void

创建一个新的 TCP 或 IPC 服务器。

如果 allowHalfOpen 设置为 true，当套接字的另一端信号传输结束时， 服务器将仅在显式调用 socket.end() 时才发回传输结束信号。 例如，在 TCP 上下文中，当收到 FIN 包时，仅在显式调用 socket.end() 时才发回 FIN 包。 在此之前，连接是半关闭的（不可读但仍可写）。 参见 'end' 事件和 [RFC 1122][half-closed]（第 4.2.2.13 节）以获取更多信息。

如果 pauseOnConnect 设置为 true，则与每个传入连接关联的套接字将被暂停， 并且不会从其句柄读取数据。 这允许在进程之间传递连接，而原始进程不读取任何数据。 要开始从暂停的套接字读取数据，调用 socket.resume()。

服务器可以是 TCP 服务器或 IPC 服务器，取决于它 listen() 什么。

这是一个监听端口 8124 连接的 TCP 回显服务器示例：

import net from 'node:net';
const server = net.createServer((c) => {
  // 'connection' 监听器。
  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.getDefaultAutoSelectFamily(): void

获取 socket.connect(options) 的 autoSelectFamily 选项的当前默认值。 初始默认值为 true，除非提供了命令行选项 --no-network-family-autoselection。

• 返回：<boolean> autoSelectFamily 选项的当前默认值。

net.setDefaultAutoSelectFamily(value): void

设置 socket.connect(options) 的 autoSelectFamily 选项的默认值。

net.getDefaultAutoSelectFamilyAttemptTimeout(): void

获取 socket.connect(options) 的 autoSelectFamilyAttemptTimeout 选项的当前默认值。 初始默认值为 500 或通过命令行选项 --network-family-autoselection-attempt-timeout 指定的值。

• 返回：<number> autoSelectFamilyAttemptTimeout 选项的当前默认值。

net.setDefaultAutoSelectFamilyAttemptTimeout(value): void

设置 socket.connect(options) 的 autoSelectFamilyAttemptTimeout 选项的默认值。

net.isIP(input): void

如果 input 是 IPv6 地址，则返回 6。如果 input 是 点分十进制表示法 且没有前导零的 IPv4 地址，则返回 4。否则，返回 0。

net.isIP('::1'); // 返回 6
net.isIP('127.0.0.1'); // 返回 4
net.isIP('127.000.000.001'); // 返回 0
net.isIP('127.0.0.1/24'); // 返回 0
net.isIP('fhqwhgads'); // 返回 0

net.isIPv4(input): void

如果 input 是 点分十进制表示法 且没有前导零的 IPv4 地址，则返回 true。否则，返回 false。

net.isIPv4('127.0.0.1'); // 返回 true
net.isIPv4('127.000.000.001'); // 返回 false
net.isIPv4('127.0.0.1/24'); // 返回 false
net.isIPv4('fhqwhgads'); // 返回 false

net.isIPv6(input): void

如果 input 是 IPv6 地址，则返回 true。否则，返回 false。

net.isIPv6('::1'); // 返回 true
net.isIPv6('fhqwhgads'); // 返回 false