稳定性：2 - 稳定

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

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

import net from 'node:net';

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

在 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 子网的入站或出站访问。

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

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

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

如果给定的 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

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

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.rules

• 继承：<EventEmitter>

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

一个正在监听的 TCP net.Server 可以通过将其列入 worker_threads 的 postMessage() 调用中的 transferList，转移到工作线程。 这会将底层监听套接字移到接收线程，在那里它会继续 接受连接。参见 [将 TCP 句柄转移到其他线程][]。

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

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

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

返回已绑定的 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) => {
  // 在这里处理错误。
  throw err;
});

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

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

停止服务器接受新连接，并保留现有连接。此函数是异步的，当所有连接都结束且服务器发出 'close' 事件时，服务器最终会关闭。可选的 callback 会在 'close' 事件发生后被调用。与该事件不同的是，如果服务器在关闭时并未处于打开状态，它将以一个 Error 作为唯一参数被调用。

异步获取服务器上的并发连接数。当套接字被发送到子进程时也能正常工作。

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

可能的签名：

• 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('地址正在使用中，正在重试...');
    setTimeout(() => {
      server.close();
      server.listen(PORT, HOST);
    }, 1000);
  }
});

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

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

当 handle 是 BoundSocket 时，服务器会接管该已绑定的 套接字并开始在其上监听。接管会消耗该已绑定套接字（参见 所有权转移）。

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

如果指定了 handle，服务器会接管该预绑定套接字。否则，如果 指定了 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();

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

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

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

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

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

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

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

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

不建议在套接字已通过 child_process.fork() 发送给子进程后再使用此选项。

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

与 unref() 相反，在之前已 unref 的服务器上调用 ref() 将 不会 让程序在它是唯一剩余服务器时退出（默认行为）。 如果服务器已 ref，再次调用 ref() 将没有效果。

在服务器上调用 unref() 将允许程序在它是事件系统中唯一 活动服务器时退出。如果服务器已经 unref，再次调用 unref() 将没有效果。

This class is an abstraction of a TCP socket or a streaming IPC endpoint (using named pipes on Windows, and Unix domain sockets on other systems). It is also an EventEmitter.

net.Socket can be created by users and used directly to interact with a server. For example, it is returned by net.createConnection(), so users can use it to communicate with a server.

It can also be created by Node.js and passed to users upon receiving a connection. For example, it is passed to listeners of the 'connection' event emitted on net.Server so users can use it to interact with clients.

该 socket 必须是一个新近接受或创建的 TCP 连接：它仍然必须绑定到一个存活的句柄，不能处于连接中或已销毁状态，也不能已经开始读取或缓存任何数据。否则 postMessage() 会抛出 ERR_WORKER_HANDLE_NOT_TRANSFERABLE。仅支持 TCP socket，并且仅限于类 Unix 平台；在 Windows 上，postMessage() 会抛出 ERR_WORKER_HANDLE_TRANSFER_UNSUPPORTED。

const net = require('node:net');
const { Worker } = require('node:worker_threads');

// worker.js 接收 `{ socket }` 消息并处理每个连接。
const worker = new Worker('./worker.js');

const server = net.createServer((socket) => {
  // 将新接受的连接交给 worker 线程。
  worker.postMessage({ socket }, [socket]);
});
server.listen(8000);

监听中的 net.Server 也可以用相同的方式传递，这会将监听 socket 本身（以及其待处理的 accept 队列）移动到接收线程。

创建一个新的 Socket 对象。

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

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

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

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

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

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

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

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

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

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

在 'connect' 之后立即触发。

另见：socket.setTimeout()】【。

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

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

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

• 类型：<integer>

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

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

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

接收的字节数。

发送的字节数。

可能的签名：

• 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 上发起连接。通常不需要此方法，Socket 应使用 net.createConnection() 创建和打开。仅在实现自定义 Socket 时使用此方法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

可能的签名：

• socket.setKeepAlive([options])
• socket.setKeepAlive([enable][, initialDelay][, interval][, count])

启用 keep-alive 会设置在空闲 socket 上发送第一条 keepalive 探测之前的初始延迟。

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

设置 interval（以毫秒为单位）可设置 keepalive 探测开始后连续探测之间的延迟（TCP_KEEPINTVL）。将 count 设置为在连接被断开前发送但未得到确认的探测次数（TCP_KEEPCNT）。这两个参数仅在启用 keep-alive 时生效。省略 interval 或 count 时，分别使用 1000 毫秒和 10 的默认值。与 initialDelay 一样，非正的 interval 或 count 会使相应的系统默认值保持不变。

initialDelay 和 interval 以毫秒为单位指定，但底层 socket 选项会按整秒配置；在应用之前，这些值会除以 1000 并向下取整。

启用 keep-alive 功能将设置以下 socket 选项：

• SO_KEEPALIVE=1
• TCP_KEEPIDLE=initialDelay / 1000
• TCP_KEEPCNT=count
• TCP_KEEPINTVL=interval / 1000

在早于 build 1709 的 Windows 版本上，keep-alive 通过 SIO_KEEPALIVE_VALS 配置，它没有探测计数字段，因此在这些平台上会忽略 count。

使用选项对象配置 keep-alive。有关每个属性的说明，请参见 socket.setKeepAlive()。

socket.setKeepAlive({ enable: true, initialDelay: 1000, interval: 1000, count: 10 });

使用位置参数配置保持活动。有关每个参数的说明，请参见 socket.setKeepAlive().

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

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

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

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

设置 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 的 IPv4 数据包的当前服务类型 (TOS) 字段或 IPv6 数据包的流量类别。

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

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

Sets the Type of Service (TOS) field for IPv4 packets or the traffic class for IPv6 packets sent from this Socket. This can be used to prioritize network traffic.

setTypeOfService() can be called before the Socket is connected; the value will be cached and applied when the Socket establishes a connection. getTypeOfService() returns the current setting even before connection.

On some platforms, such as Linux, certain TOS/ECN bits may be masked or ignored, and behavior may differ between IPv4 and IPv6 or dual-stack sockets. Callers should verify platform-specific semantics.

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

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

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

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

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

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

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

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

允许同步创建一个预绑定的套接字，之后可以将其传递给 listen() 或 new net.Socket()。对于 listen()，这可实现同步端口预留；而对于 new net.Socket()，它允许通过 bind(2) 语义来控制本地出站端口/IP。

接管会转移套接字的所有权；之后 address() 和 close() 会抛出 ERR_SOCKET_HANDLE_ADOPTED。从未被接管的句柄必须关闭，以避免泄漏套接字。

import net from 'node:net';

const bound = new net.BoundSocket();
const { port } = bound.address();
console.log(`为服务器预留端口 ${port}`);

const server = net.createServer();
server.listen(bound); // 作为服务器接管，或者改为传给 new net.Socket()。

返回已绑定的本地地址。当使用 port: 0 绑定时，port 是操作系统分配的临时端口。

返回已绑定套接字的文件描述符。其所有权仍归 BoundSocket 所有，因此调用方不得关闭该描述符。 该描述符仅在句柄被接管之前可用；之后它属于接管它的 net.Server 或 net.Socket，并且 fd() 会抛出 ERR_SOCKET_HANDLE_ADOPTED。

别名于 net.createConnection()。

可能的签名：

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

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

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

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

这是一个工厂函数，它创建一个新的 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() 函数是此函数的别名。

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

其他选项：

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

import net from 'node:net';
const client = net.createConnection({ port: 8124 }, () => {
  // `'connect'` 监听器。
  console.log('已连接到服务器！');
  client.write('world!\r\n');
});
client.on('data', (data) => {
  console.log(data.toString());
  client.end();
});
client.on('end', () => {
  console.log('已与服务器断开连接');
});

要连接到套接字 /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));
    },
  },
});

发起一个 IPC 连接。

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

发起一个 TCP 连接。

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

创建一个新的 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

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

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

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

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

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

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

如果 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

如果 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

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

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