Node.js v8.1.2 文档


目录

net (网络)#

查看英文版 / 参与翻译

稳定性: 2 - 稳定

net模块提供了一个用于创建基于tcp或IPC servers (net.createServer())和clients(net.createConnection()) 的异步api

通过以下方式引入:

const net = require('net');

IPC Support#

查看英文版 / 参与翻译

net模块支持Windows上命名管道的IPC和其他操作系统上的UNIX域套接字。

Identifying paths for IPC connections#

查看英文版 / 参与翻译

net.connect(), net.createConnection(), server.listen() and socket.connect() take a path parameter to identify IPC endpoints.

On UNIX, the local domain is also known as the UNIX domain. The path is a filesystem path name. It gets truncated to sizeof(sockaddr_un.sun_path) - 1, which varies on different operating system between 91 and 107 bytes. The typical values are 107 on Linux and 103 on macOS. The path is subject to the same naming conventions and permissions checks as would be done on file creation. It will be visible in the filesystem, and will persist until unlinked.

On Windows, the local domain is implemented using a named pipe. The path must refer to an entry in \\?\pipe\ or \\.\pipe\. Any characters are permitted, but the latter may do some processing of pipe names, such as resolving .. sequences. Despite appearances, the pipe name space is flat. Pipes will not persist, they are removed when the last reference to them is closed. Do not forget JavaScript string escaping requires paths to be specified with double-backslashes, such as:

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

net.Server 类#

查看英文版 / 参与翻译

这个类用于创建TCP或IPC server.。

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

查看英文版 / 参与翻译

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

net.Server is an EventEmitter实现了以下事件:

'close' 事件#

查看英文版 / 参与翻译

当server关闭的时候触发. 注意,如果connections存在, 直到所有的connections结束才会触发这个事件

'connection' 事件#

查看英文版 / 参与翻译

当一个新的connection建立的时候触发. socket 是一个 net.Socket的实例对象.

'error' 事件#

查看英文版 / 参与翻译

当错误出现的时候触发. 不同与 net.Socket, 'close' 事件不会在这个事件触发后继续触发 除非 server.close() 是手动调用. 在 server.listen()中的例子.

'listening' 事件#

查看英文版 / 参与翻译

当服务被绑定后调用 server.listen().

server.address()#

查看英文版 / 参与翻译

如果在IP socket上监听,则返回绑定的ip地址, 地址族和操作系统报告的服务端口 在找到操作系统分配的地址时,找到指定的端口是有用的.返回一个有 port, family, 和 address 属性: { port: 12346, family: 'IPv4', address: '127.0.0.1' }的对象

对于在管道或UNIX域套接字上侦听的server,该名称将返回为字符串

例子:

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

只有到了 'listening' 事件被触发时候.才可以调用 server.address()

server.close([callback])#

查看英文版 / 参与翻译

停止 server接受建立新的connections并保持已经存在的connections.此功能是异步的,当所有的connections关闭同时server响应 'close'事件的时候,server将会最终关闭. 一旦'close'发生将会调用可选的回调函数. 与该事件不同, 如果服务器在关闭时未打开,则将使用错误作为唯一参数。

server.connections#

查看英文版 / 参与翻译

Stability: 0 - Deprecated: Use server.getConnections() instead.

The number of concurrent connections on the server.

This becomes null when sending a socket to a child with child_process.fork(). To poll forks and get current number of active connections use asynchronous server.getConnections instead.

server.getConnections(callback)#

查看英文版 / 参与翻译

Asynchronously get the number of concurrent connections on the server. Works when sockets were sent to forks.

Callback should take two arguments err and count.

server.listen()#

查看英文版 / 参与翻译

Start a server listening for connections. A net.Server can be a TCP or a IPC server depending on what it listens to.

Possible signatures:

This function is asynchronous. When the server starts listening, the 'listening' event will be emitted. The last parameter callback will be added as a listener for the 'listening' event.

All listen() methods can take a backlog parameter to specify the maximum length of the queue of pending connections. The actual length will be determined by the OS through sysctl settings such as tcp_max_syn_backlog and somaxconn on Linux. The default value of this parameter is 511 (not 512).

Note:

  • All net.Socket are set to SO_REUSEADDR (See socket(7) for details).

  • The server.listen() method may be called multiple times. Each subsequent call will re-open the server using the provided options.

One of the most common errors raised when listening is EADDRINUSE. This happens when another server is already listening on the requested port / path / handle. One way to handle this would be to retry after a certain amount of time:

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])#

查看英文版 / 参与翻译

Start a server listening for connections on a given handle that has already been bound to a port, a UNIX domain socket, or a Windows named pipe.

The handle object can be either a server, a socket (anything with an underlying _handle member), or an object with a fd member that is a valid file descriptor.

Note: Listening on a file descriptor is not supported on Windows.

server.listen(options[, callback])#

查看英文版 / 参与翻译

If port is specified, it behaves the same as server.listen([port][, hostname][, backlog][, callback]). Otherwise, if path is specified, it behaves the same as server.listen(path[, backlog][, callback]). If none of them is specified, an error will be thrown.

If exclusive is false (default), then cluster workers will use the same underlying handle, allowing connection handling duties to be shared. When exclusive is true, the handle is not shared, and attempted port sharing results in an error. An example which listens on an exclusive port is shown below.

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

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

查看英文版 / 参与翻译

Start a IPC server listening for connections on the given path.

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

查看英文版 / 参与翻译

Start a TCP server listening for connections on the given port and host.

If port is omitted or is 0, the operating system will assign an arbitrary unused port, which can be retrieved by using server.address().port after the 'listening' event has been emitted.

If host is omitted, the server will accept connections on the unspecified IPv6 address (::) when IPv6 is available, or the unspecified IPv4 address (0.0.0.0) otherwise.

Note: In most operating systems, listening to the unspecified IPv6 address (::) may cause the net.Server to also listen on the unspecified IPv4 address (0.0.0.0).

server.listening#

查看英文版 / 参与翻译

A Boolean indicating whether or not the server is listening for connections.

server.maxConnections#

查看英文版 / 参与翻译

Set this property to reject connections when the server's connection count gets high.

It is not recommended to use this option once a socket has been sent to a child with child_process.fork().

server.ref()#

查看英文版 / 参与翻译

Opposite of unref, calling ref on a previously unrefd server will not let the program exit if it's the only server left (the default behavior). If the server is refd calling ref again will have no effect.

Returns server.

server.unref()#

查看英文版 / 参与翻译

Calling unref on a server will allow the program to exit if this is the only active server in the event system. If the server is already unrefd calling unref again will have no effect.

Returns server.

net.Socket 类#

查看英文版 / 参与翻译

This class is an abstraction of a TCP socket or a streaming IPC endpoint (uses named pipes on Windows, and UNIX domain sockets otherwise). A net.Socket is also a duplex stream, so it can be both readable and writable, and it is also a EventEmitter.

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

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

new net.Socket([options])#

查看英文版 / 参与翻译

Creates a new socket object.

  • options <Object> Available options are:
    • fd: <number> If specified, wrap around an existing socket with the given file descriptor, otherwise a new socket will be created.
    • allowHalfOpen <boolean> Indicates whether half-opened TCP connections are allowed. See net.createServer() and the 'end' event for details. Defaults to false.
    • readable <boolean> Allow reads on the socket when a fd is passed, otherwise ignored. Defaults to false.
    • writable <boolean> Allow reads on the socket when a fd is passed, otherwise ignored. Defaults to false.
  • Returns: <net.Socket>

The newly created socket can be either a TCP socket or a streaming IPC endpoint, depending on what it connect() to.

'close' 事件#

查看英文版 / 参与翻译

  • had_error <boolean> true if the socket had a transmission error.

Emitted once the socket is fully closed. The argument had_error is a boolean which says if the socket was closed due to a transmission error.

'connect' 事件#

查看英文版 / 参与翻译

Emitted when a socket connection is successfully established. See net.createConnection().

'data' 事件#

查看英文版 / 参与翻译

Emitted when data is received. The argument data will be a Buffer or String. Encoding of data is set by socket.setEncoding(). (See the Readable Stream section for more information.)

Note that the data will be lost if there is no listener when a Socket emits a 'data' event.

'drain' 事件#

查看英文版 / 参与翻译

Emitted when the write buffer becomes empty. Can be used to throttle uploads.

See also: the return values of socket.write()

'end' 事件#

查看英文版 / 参与翻译

Emitted when the other end of the socket sends a FIN packet, thus ending the readable side of the socket.

By default (allowHalfOpen is false) the socket will send a FIN packet back and destroy its file descriptor once it has written out its pending write queue. However, if allowHalfOpen is set to true, the socket will not automatically end() its writable side, allowing the user to write arbitrary amounts of data. The user must call end() explicitly to close the connection (i.e. sending a FIN packet back).

'error' 事件#

查看英文版 / 参与翻译

Emitted when an error occurs. The 'close' event will be called directly following this event.

'lookup' 事件#

查看英文版 / 参与翻译

Emitted after resolving the hostname but before connecting. Not applicable to UNIX sockets.

'timeout' 事件#

查看英文版 / 参与翻译

Emitted if the socket times out from inactivity. This is only to notify that the socket has been idle. The user must manually close the connection.

See also: socket.setTimeout()

socket.address()#

查看英文版 / 参与翻译

Returns the bound address, the address family name and port of the socket as reported by the operating system. Returns an object with three properties, e.g. { port: 12346, family: 'IPv4', address: '127.0.0.1' }

socket.bufferSize#

查看英文版 / 参与翻译

net.Socket has the property that socket.write() always works. This is to help users get up and running quickly. The computer cannot always keep up with the amount of data that is written to a socket - the network connection simply might be too slow. Node.js will internally queue up the data written to a socket and send it out over the wire when it is possible. (Internally it is polling on the socket's file descriptor for being writable).

The consequence of this internal buffering is that memory may grow. This property shows the number of characters currently buffered to be written. (Number of characters is approximately equal to the number of bytes to be written, but the buffer may contain strings, and the strings are lazily encoded, so the exact number of bytes is not known.)

Users who experience large or growing bufferSize should attempt to "throttle" the data flows in their program with socket.pause() and socket.resume().

socket.bytesRead#

查看英文版 / 参与翻译

The amount of received bytes.

socket.bytesWritten#

查看英文版 / 参与翻译

The amount of bytes sent.

socket.connect()#

查看英文版 / 参与翻译

Initiate a connection on a given socket.

Possible signatures:

This function is asynchronous. When the connection is established, the 'connect' event will be emitted. If there is a problem connecting, instead of a 'connect' event, an 'error' event will be emitted with the error passed to the 'error' listener. The last parameter connectListener, if supplied, will be added as a listener for the 'connect' event once.

socket.connect(options[, connectListener])#

查看英文版 / 参与翻译

Initiate a connection on a given socket. Normally this method is not needed, the socket should be created and opened with net.createConnection(). Use this only when implementing a custom Socket.

For TCP connections, available options are:

  • port <number> Required. Port the socket should connect to.
  • host <string> Host the socket should connect to. Defaults to 'localhost'.
  • localAddress <string> Local address the socket should connect from.
  • localPort <number> Local port the socket should connect from.
  • family <number>: Version of IP stack, can be either 4 or 6. Defaults to 4.
  • hints <number> Optional dns.lookup() hints.
  • lookup <Function> Custom lookup function. Defaults to dns.lookup().

For IPC connections, available options are:

socket.connect(path[, connectListener])#

查看英文版 / 参与翻译

Initiate an IPC connection on the given socket.

Alias to socket.connect(options[, connectListener]) called with { path: path } as options.

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

查看英文版 / 参与翻译

Initiate a TCP connection on the given socket.

Alias to socket.connect(options[, connectListener]) called with {port: port, host: host} as options.

socket.connecting#

查看英文版 / 参与翻译

If true - socket.connect(options[, connectListener]) was called and haven't yet finished. Will be set to false before emitting connect event and/or calling socket.connect(options[, connectListener])'s callback.

socket.destroy([exception])#

查看英文版 / 参与翻译

Ensures that no more I/O activity happens on this socket. Only necessary in case of errors (parse error or so).

If exception is specified, an 'error' event will be emitted and any listeners for that event will receive exception as an argument.

socket.destroyed#

查看英文版 / 参与翻译

A Boolean value that indicates if the connection is destroyed or not. Once a connection is destroyed no further data can be transferred using it.

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

查看英文版 / 参与翻译

Half-closes the socket. i.e., it sends a FIN packet. It is possible the server will still send some data.

If data is specified, it is equivalent to calling socket.write(data, encoding) followed by socket.end().

Returns socket.

socket.localAddress#

查看英文版 / 参与翻译

The string representation of the local IP address the remote client is connecting on. For example, in a server listening on '0.0.0.0', if a client connects on '192.168.1.1', the value of socket.localAddress would be '192.168.1.1'.

socket.localPort#

查看英文版 / 参与翻译

The numeric representation of the local port. For example, 80 or 21.

socket.pause()#

查看英文版 / 参与翻译

Pauses the reading of data. That is, 'data' events will not be emitted. Useful to throttle back an upload.

socket.ref()#

查看英文版 / 参与翻译

Opposite of unref, calling ref on a previously unrefd socket will not let the program exit if it's the only socket left (the default behavior). If the socket is refd calling ref again will have no effect.

Returns socket.

socket.remoteAddress#

查看英文版 / 参与翻译

The string representation of the remote IP address. For example, '74.125.127.100' or '2001:4860:a005::68'. Value may be undefined if the socket is destroyed (for example, if the client disconnected).

socket.remoteFamily#

查看英文版 / 参与翻译

The string representation of the remote IP family. 'IPv4' or 'IPv6'.

socket.remotePort#

查看英文版 / 参与翻译

The numeric representation of the remote port. For example, 80 or 21.

socket.resume()#

查看英文版 / 参与翻译

Resumes reading after a call to socket.pause().

socket.setEncoding([encoding])#

查看英文版 / 参与翻译

Set the encoding for the socket as a Readable Stream. See stream.setEncoding() for more information.

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

查看英文版 / 参与翻译

Enable/disable keep-alive functionality, and optionally set the initial delay before the first keepalive probe is sent on an idle socket. enable defaults to false.

Set initialDelay (in milliseconds) to set the delay between the last data packet received and the first keepalive probe. Setting 0 for initialDelay will leave the value unchanged from the default (or previous) setting. Defaults to 0.

Returns socket.

socket.setNoDelay([noDelay])#

查看英文版 / 参与翻译

Disables the Nagle algorithm. By default TCP connections use the Nagle algorithm, they buffer data before sending it off. Setting true for noDelay will immediately fire off data each time socket.write() is called. noDelay defaults to true.

Returns socket.

socket.setTimeout(timeout[, callback])#

查看英文版 / 参与翻译

Sets the socket to timeout after timeout milliseconds of inactivity on the socket. By default net.Socket do not have a timeout.

When an idle timeout is triggered the socket will receive a 'timeout' event but the connection will not be severed. The user must manually call socket.end() or socket.destroy() to end the connection.

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

If timeout is 0, then the existing idle timeout is disabled.

The optional callback parameter will be added as a one time listener for the 'timeout' event.

Returns socket.

socket.unref()#

查看英文版 / 参与翻译

Calling unref on a socket will allow the program to exit if this is the only active socket in the event system. If the socket is already unrefd calling unref again will have no effect.

Returns socket.

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

查看英文版 / 参与翻译

Sends data on the socket. The second parameter specifies the encoding in the case of a string--it defaults to UTF8 encoding.

Returns true if the entire data was flushed successfully to the kernel buffer. Returns false if all or part of the data was queued in user memory. 'drain' will be emitted when the buffer is again free.

The optional callback parameter will be executed when the data is finally written out - this may not be immediately.

net.connect()#

查看英文版 / 参与翻译

Aliases to net.createConnection().

Possible signatures:

net.connect(options[, connectListener])#

查看英文版 / 参与翻译

Alias to net.createConnection(options[, connectListener]).

net.connect(path[, connectListener])#

查看英文版 / 参与翻译

Alias to net.createConnection(path[, connectListener]).

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

查看英文版 / 参与翻译

Alias to net.createConnection(port[, host][, connectListener]).

net.createConnection()#

查看英文版 / 参与翻译

A factory function, which creates a new net.Socket, immediately initiates connection with socket.connect(), then returns the net.Socket that starts the connection.

When the connection is established, a 'connect' event will be emitted on the returned socket. The last parameter connectListener, if supplied, will be added as a listener for the 'connect' event once.

Possible signatures:

Note: The net.connect() function is an alias to this function.

net.createConnection(options[, connectListener])#

查看英文版 / 参与翻译

For available options, see new net.Socket([options]) and socket.connect(options[, connectListener]).

Additional options:

Following is an example of a client of the echo server described in the net.createServer() section:

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');
});

To connect on the socket /tmp/echo.sock the second line would just be changed to

const client = net.createConnection({ path: '/tmp/echo.sock' });

net.createConnection(path[, connectListener])#

查看英文版 / 参与翻译

Initiates an IPC connection.

This function creates a new net.Socket with all options set to default, immediately initiates connection with socket.connect(path[, connectListener]), then returns the net.Socket that starts the connection.

net.createConnection(port[, host][, connectListener])#

查看英文版 / 参与翻译

Initiates a TCP connection.

This function creates a new net.Socket with all options set to default, immediately initiates connection with socket.connect(port[, host][, connectListener]), then returns the net.Socket that starts the connection.

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

查看英文版 / 参与翻译

Creates a new TCP or IPC server.

  • options <Object>
    • allowHalfOpen <boolean> Default to false. Indicates whether half-opened TCP connections are allowed.
    • pauseOnConnect <boolean> Default to false. Indicates whether the socket should be paused on incoming connections.
  • connectionListener <Function> Automatically set as a listener for the 'connection' event

If allowHalfOpen is set to true, when the other end of the socket sends a FIN packet, the server will only send a FIN packet back when socket.end() is explicitly called, until then the connection is half-closed (non-readable but still writable). See 'end' event and RFC 1122 for more information.

If pauseOnConnect is set to true, then the socket associated with each incoming connection will be paused, and no data will be read from its handle. This allows connections to be passed between processes without any data being read by the original process. To begin reading data from a paused socket, call socket.resume().

The server can be a TCP server or a IPC server, depending on what it listen() to.

Here is an example of an TCP echo server which listens for connections on port 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');
});

Test this by using telnet:

$ telnet localhost 8124

To listen on the socket /tmp/echo.sock the third line from the last would just be changed to

server.listen('/tmp/echo.sock', () => {
  console.log('server bound');
});

Use nc to connect to a UNIX domain socket server:

$ nc -U /tmp/echo.sock

net.isIP(input)#

查看英文版 / 参与翻译

Tests if input is an IP address. Returns 0 for invalid strings, returns 4 for IP version 4 addresses, and returns 6 for IP version 6 addresses.

net.isIPv4(input)#

查看英文版 / 参与翻译

Returns true if input is a version 4 IP address, otherwise returns false.

net.isIPv6(input)#

查看英文版 / 参与翻译

Returns true if input is a version 6 IP address, otherwise returns false.