Node.js v18.8.0 文档


目录

http 超文本传输协议#

中英对照

要使用 HTTP 服务器和客户端,则必须 require('node:http')



http.Agent#

中英对照

Agent 负责管理 HTTP 客户端连接的持久性和重用。 它维护一个给定主机和端口的待处理请求队列,为每个请求重用单个套接字连接,直到队列为空,此时套接字要么被销毁,要么放入池中,在那里它会被再次用于请求到相同的主机和端口。 是销毁还是池化取决于 keepAlive 选项



new Agent([options])#

中英对照

    socket.connect() 中的 options 也受支持。

    
    

    agent.createConnection(options[, callback])#

    中英对照

      生成用于 HTTP 请求的套接字/流。

      agent.keepSocketAlive(socket)#

      中英对照

        socket 从请求中分离并且可以由 Agent 持久化时调用。 默认行为是:

        
        

        agent.reuseSocket(socket, request)#

        中英对照

          socket 由于保持活动选项而持久化后附加到 request 时调用。 默认行为是:

          
          

          agent.destroy()#

          中英对照

          销毁代理当前正在使用的所有套接字。

          agent.freeSockets#

          中英对照

            当启用 keepAlive 时,包含当前等待代理使用的套接字数组的对象。 不要修改。

            agent.getName([options])#

            中英对照

              获取一组请求选项的唯一名称,以确定是否可以重用连接。 对于 HTTP 代理,则这将返回 host:port:localAddresshost:port:localAddress:family。 对于 HTTPS 代理,则名称包括 CA、证书、密码和其他确定套接字可重用性的 HTTPS/TLS 特定选项。

              agent.maxFreeSockets#

              中英对照

                默认设置为 256。 对于启用了 keepAlive 的代理,这将设置在空闲状态下将保持打开的最大套接字数量。

                agent.maxSockets#

                中英对照

                  默认设置为 Infinity。 确定代理可以为每个来源打开多少个并发套接字。 来源是 agent.getName() 的返回值。

                  agent.maxTotalSockets#

                  中英对照

                    默认设置为 Infinity。 确定代理可以打开多少个并发套接字。 与 maxSockets 不同,此参数适用于所有来源。

                    agent.requests#

                    中英对照

                      包含尚未分配给套接字的请求队列的对象。 不要修改。

                      agent.sockets#

                      中英对照

                        包含代理当前正在使用的套接字数组的对象。 不要修改。

                        http.ClientRequest#

                        中英对照

                          此对象从 http.request() 内部创建并返回。 它表示正在进行的请求,其标头已入队。 使用 setHeader(name, value)getHeader(name)removeHeader(name) API 时,标头仍然是可变的。 实际标头将与第一个数据块一起发送或在调用 request.end() 时发送。

                          'abort' 事件#

                          中英对照

                          当请求被客户端中止时触发。 此事件仅在第一次调用 abort() 时触发。

                          'close' 事件#

                          中英对照

                          表示请求已完成,或者其底层连接提前终止(在响应完成之前)。

                          'connect' 事件#

                          中英对照

                            每次服务器使用 CONNECT 方法响应请求时触发。 如果未监听此事件,则接收 CONNECT 方法的客户端将关闭其连接。

                            
                            

                            'continue' 事件#

                            中英对照

                            当服务器发送 '100 Continue' HTTP 响应时触发,通常是因为请求包含 'Expect: 100-continue'。 这是客户端应该发送请求正文的指令。

                            'finish' 事件#

                            中英对照

                            当发送请求时触发。 更具体地说,当响应头和正文的最后一段已移交给操作系统以通过网络传输时,则将触发此事件。 这并不意味着服务器已经收到任何东西。

                            'information' 事件#

                            中英对照

                              当服务器发送 1xx 中间响应(不包括 101 升级)时触发。 此事件的监听器将接收一个对象,其中包含 HTTP 版本、状态码、状态消息、键值标头对象和带有原始标头名称及其各自值的数组。

                              
                              

                              'response' 事件#

                              中英对照

                                当接收到对此请求的响应时触发。 此事件仅触发一次。

                                'socket' 事件#

                                中英对照

                                  除非用户指定 <net.Socket> 以外的套接字类型,否则此事件保证传入 <net.Socket> 类(<stream.Duplex> 的子类)的实例。

                                  'timeout' 事件#

                                  中英对照

                                  当底层套接字因不活动而超时时触发。 这仅通知套接字已空闲。 必须手动销毁请求。

                                  'upgrade' 事件#

                                  中英对照

                                    每次服务器响应升级请求时触发。 如果未监听此事件且响应状态码为 101 Switching Protocols,则接收升级标头的客户端将关闭其连接。

                                    
                                    

                                    request.abort()#

                                    中英对照

                                    将请求标记为中止。 调用它会导致响应中的剩余数据被丢弃并销毁套接字。

                                    request.aborted#

                                    中英对照

                                      如果请求已中止,则 request.aborted 属性将为 true

                                      request.connection#

                                      中英对照

                                        参见 request.socket

                                        request.cork()#

                                        中英对照

                                        参见 writable.cork()

                                        request.end([data[, encoding]][, callback])#

                                        中英对照

                                          完成发送请求。 如果正文的任何部分未发送,则会将它们刷新到流中。 如果请求被分块,则将发送终止的 '0\r\n\r\n'

                                          request.destroy([error])#

                                          中英对照

                                            销毁请求。 可选地触发 'error' 事件,并发出 'close' 事件。 调用它会导致响应中的剩余数据被丢弃并销毁套接字。

                                            request.destroyed#

                                            中英对照

                                              在调用 request.destroy() 之后是 true

                                              request.finished#

                                              中英对照

                                                如果 request.end() 已被调用,则 request.finished 属性将为 true。 如果请求是通过 http.get() 发起的,则会自动调用 request.end()

                                                request.flushHeaders()#

                                                中英对照

                                                刷新请求头。

                                                request.getHeader(name)#

                                                中英对照

                                                  读取请求的标头。 该名称不区分大小写。 返回值的类型取决于提供给 request.setHeader() 的参数。

                                                  
                                                  

                                                  request.getHeaderNames()#

                                                  中英对照

                                                    返回包含当前传出标头的唯一名称的数组。 所有标头名称均为小写。

                                                    
                                                    

                                                    request.getHeaders()#

                                                    中英对照

                                                      返回当前传出标头的浅拷贝。 由于使用了浅拷贝,因此无需额外调用各种与标头相关的 http 模块方法即可更改数组值。 返回对象的键是标头名称,值是相应的标头值。 所有标头名称均为小写。

                                                      
                                                      

                                                      request.getRawHeaderNames()#

                                                      中英对照

                                                        返回包含当前传出原始标头的唯一名称的数组。 标头名称返回并设置了它们的确切大小写。

                                                        
                                                        

                                                        request.hasHeader(name)#

                                                        中英对照

                                                          如果 name 标识的标头当前设置在传出标头中,则返回 true。 标头名称匹配不区分大小写。

                                                          
                                                          

                                                          request.maxHeadersCount#

                                                          中英对照

                                                            限制最大响应头计数。 如果设置为 0,则不会应用任何限制。

                                                            request.path#

                                                            中英对照

                                                              request.method#

                                                              中英对照

                                                                request.host#

                                                                中英对照

                                                                  request.protocol#

                                                                  中英对照

                                                                    request.removeHeader(name)#

                                                                    中英对照

                                                                      删除已定义到标头对象中的标头。

                                                                      
                                                                      

                                                                      request.reusedSocket#

                                                                      中英对照

                                                                        当通过启用保持活动的代理发送请求时,可能会重用底层套接字。 但是如果服务器在不幸的时间关闭连接,客户端可能会遇到 'ECONNRESET' 错误。

                                                                        
                                                                        

                                                                        
                                                                        

                                                                        request.setHeader(name, value)#

                                                                        中英对照

                                                                          为标头对象设置单个标头值。 如果该标头已经存在于待发送的标头中,则其值将被替换。 在此处使用字符串数组发送具有相同名称的多个标头。 非字符串值将不加修改地存储。 因此,request.getHeader() 可能返回非字符串值。 但是,非字符串值将转换为字符串以进行网络传输。

                                                                          
                                                                          

                                                                          
                                                                          

                                                                          
                                                                          

                                                                          request.setNoDelay([noDelay])#

                                                                          中英对照

                                                                            一旦套接字被分配给这个请求并被连接,则 socket.setNoDelay() 将被调用。

                                                                            request.setSocketKeepAlive([enable][, initialDelay])#

                                                                            中英对照

                                                                              一旦套接字被分配给这个请求并被连接,则 socket.setKeepAlive() 将被调用。

                                                                              request.setTimeout(timeout[, callback])#

                                                                              中英对照

                                                                                一旦套接字被分配给这个请求并被连接,则 socket.setTimeout() 将被调用。

                                                                                request.socket#

                                                                                中英对照

                                                                                  对底层套接字的引用。 通常用户不会想要访问这个属性。 特别是,由于协议解析器附加到套接字的方式,套接字将不会触发 'readable' 事件。

                                                                                  
                                                                                  

                                                                                  request.uncork()#

                                                                                  中英对照

                                                                                  参见 writable.uncork()

                                                                                  request.writableEnded#

                                                                                  中英对照

                                                                                    在调用 request.end() 之后是 true。 此属性不指示数据是否已刷新,为此则使用 request.writableFinished 代替。

                                                                                    request.writableFinished#

                                                                                    中英对照

                                                                                      如果所有数据都已在 'finish' 事件触发之前立即刷新到底层系统,则为 true

                                                                                      request.write(chunk[, encoding][, callback])#

                                                                                      中英对照

                                                                                        发送一块正文。 此方法可以被多次调用。 如果没有设置 Content-Length,则数据将自动使用 HTTP 分块传输编码进行编码,以便服务器知道数据何时结束。 Transfer-Encoding: chunked 标头会被添加。 需要调用 request.end() 来完成发送请求。

                                                                                        http.Server#

                                                                                        'checkContinue' 事件#

                                                                                        中英对照

                                                                                          每次收到带有 HTTP Expect: 100-continue 的请求时触发。 如果未监听此事件,则服务器将根据需要自动响应 100 Continue

                                                                                          'checkExpectation' 事件#

                                                                                          中英对照

                                                                                            每次收到带有 HTTP Expect 标头的请求时触发,其中值不是 100-continue。 如果未监听此事件,则服务器将根据需要自动响应 417 Expectation Failed

                                                                                            'clientError' 事件#

                                                                                            中英对照

                                                                                              如果客户端连接触发 'error' 事件,则会在此处转发。 此事件的监听器负责关闭/销毁底层套接字。 例如,可能希望使用自定义 HTTP 响应更优雅地关闭套接字,而不是突然切断连接。

                                                                                              
                                                                                              

                                                                                                
                                                                                                

                                                                                                'close' 事件#

                                                                                                中英对照

                                                                                                服务器关闭时触发。

                                                                                                'connect' 事件#

                                                                                                中英对照

                                                                                                  每次客户端请求 HTTP CONNECT 方法时触发。 如果未监听此事件,则请求 CONNECT 方法的客户端将关闭其连接。

                                                                                                  'connection' 事件#

                                                                                                  中英对照

                                                                                                    当建立新的 TCP 流时会触发此事件。 socket 通常是 net.Socket 类型的对象。 通常用户不会想访问这个事件。 特别是,由于协议解析器附加到套接字的方式,套接字将不会触发 'readable' 事件。 socket 也可以在 request.socket 上访问。

                                                                                                    'dropRequest' 事件#

                                                                                                    中英对照

                                                                                                      当套接字上的请求数达到 server.maxRequestsPerSocket 的阈值时,服务器会丢弃新的请求并触发 'dropRequest' 事件,然后将 503 发送给客户端。

                                                                                                      'request' 事件#

                                                                                                      中英对照

                                                                                                        每次有请求时触发。 每个连接可能有多个请求(在 HTTP Keep-Alive 连接的情况下)。

                                                                                                        'upgrade' 事件#

                                                                                                        中英对照

                                                                                                          每次客户端请求 HTTP 升级时触发。 监听此事件是可选的,客户端不能坚持协议更改。

                                                                                                          server.close([callback])#

                                                                                                          中英对照

                                                                                                            停止服务器接受新连接。 参见 net.Server.close()

                                                                                                            server.closeAllConnections()#

                                                                                                            中英对照

                                                                                                            关闭所有连接到此服务器的连接。

                                                                                                            server.closeIdleConnections()#

                                                                                                            中英对照

                                                                                                            关闭连接到此服务器的所有未发送请求或等待响应的连接。

                                                                                                            server.headersTimeout#

                                                                                                            中英对照

                                                                                                              限制解析器等待接收完整 HTTP 标头的时间。

                                                                                                              server.listen()#

                                                                                                              中英对照

                                                                                                              启动 HTTP 服务器监听连接。 此方法与 net.Server 中的 server.listen() 相同。

                                                                                                              server.listening#

                                                                                                              中英对照

                                                                                                                server.maxHeadersCount#

                                                                                                                中英对照

                                                                                                                  限制最大传入标头计数。 如果设置为 0,则不会应用任何限制。

                                                                                                                  server.requestTimeout#

                                                                                                                  中英对照

                                                                                                                    设置从客户端接收整个请求的超时值(以毫秒为单位)。

                                                                                                                    server.setTimeout([msecs][, callback])#

                                                                                                                    中英对照

                                                                                                                      设置套接字的超时值,并在服务器对象上触发 'timeout' 事件,如果发生超时,则将套接字作为参数传入。

                                                                                                                      server.maxRequestsPerSocket#

                                                                                                                      中英对照

                                                                                                                        关闭保持活动的连接之前,套接字可以处理的最大请求数。

                                                                                                                        server.timeout#

                                                                                                                        中英对照

                                                                                                                          假定套接字超时之前不活动的毫秒数。

                                                                                                                          server.keepAliveTimeout#

                                                                                                                          中英对照

                                                                                                                            在完成写入最后一个响应之后,在套接字将被销毁之前,服务器需要等待额外传入数据的不活动毫秒数。 如果服务器在 keep-alive 超时触发之前收到新数据,则将重置常规的不活动超时,即 server.timeout

                                                                                                                            http.ServerResponse#

                                                                                                                            中英对照

                                                                                                                              此对象由 HTTP 服务器内部创建,而不是由用户创建。 它作为第二个参数传给 'request' 事件。

                                                                                                                              'close' 事件#

                                                                                                                              中英对照

                                                                                                                              表示响应已完成,或者其底层连接提前终止(在响应完成之前)。

                                                                                                                              'finish' 事件#

                                                                                                                              中英对照

                                                                                                                              发送响应时触发。 更具体地说,当响应头和正文的最后一段已移交给操作系统以通过网络传输时,则将触发此事件。 这并不意味着客户端已收到任何东西。

                                                                                                                              response.addTrailers(headers)#

                                                                                                                              中英对照

                                                                                                                                此方法向响应添加 HTTP 尾随标头(标头,但位于消息末尾)。

                                                                                                                                
                                                                                                                                

                                                                                                                                response.connection#

                                                                                                                                中英对照

                                                                                                                                  参见 response.socket

                                                                                                                                  response.cork()#

                                                                                                                                  中英对照

                                                                                                                                  参见 writable.cork()

                                                                                                                                  response.end([data[, encoding]][, callback])#

                                                                                                                                  中英对照

                                                                                                                                    此方法向服务器发出信号,表明所有响应头和正文都已发送;该服务器应认为此消息已完成。 response.end() 方法必须在每个响应上调用。

                                                                                                                                    response.finished#

                                                                                                                                    中英对照

                                                                                                                                      如果 response.end() 已被调用,则 response.finished 属性将为 true

                                                                                                                                      response.flushHeaders()#

                                                                                                                                      中英对照

                                                                                                                                      刷新响应头。 另见: request.flushHeaders()

                                                                                                                                      response.getHeader(name)#

                                                                                                                                      中英对照

                                                                                                                                        读取已排队但未发送到客户端的标头。 该名称不区分大小写。 返回值的类型取决于提供给 response.setHeader() 的参数。

                                                                                                                                        
                                                                                                                                        

                                                                                                                                        response.getHeaderNames()#

                                                                                                                                        中英对照

                                                                                                                                          返回包含当前传出标头的唯一名称的数组。 所有标头名称均为小写。

                                                                                                                                          
                                                                                                                                          

                                                                                                                                          response.getHeaders()#

                                                                                                                                          中英对照

                                                                                                                                            返回当前传出标头的浅拷贝。 由于使用了浅拷贝,因此无需额外调用各种与标头相关的 http 模块方法即可更改数组值。 返回对象的键是标头名称,值是相应的标头值。 所有标头名称均为小写。

                                                                                                                                            
                                                                                                                                            

                                                                                                                                            response.hasHeader(name)#

                                                                                                                                            中英对照

                                                                                                                                              如果 name 标识的标头当前设置在传出标头中,则返回 true。 标头名称匹配不区分大小写。

                                                                                                                                              
                                                                                                                                              

                                                                                                                                              response.headersSent#

                                                                                                                                              中英对照

                                                                                                                                                布尔值(只读)。 如果标头被发送,则为真,否则为假。

                                                                                                                                                response.removeHeader(name)#

                                                                                                                                                中英对照

                                                                                                                                                  删除排队等待隐式发送的标头。

                                                                                                                                                  
                                                                                                                                                  

                                                                                                                                                  response.req#

                                                                                                                                                  中英对照

                                                                                                                                                    对原始的 HTTP request 对象的引用。

                                                                                                                                                    response.sendDate#

                                                                                                                                                    中英对照

                                                                                                                                                      如果为真,则 Date 标头将自动生成并在响应中发送,如果它尚未出现在标头中。 默认为真。

                                                                                                                                                      response.setHeader(name, value)#

                                                                                                                                                      中英对照

                                                                                                                                                        返回响应对象。

                                                                                                                                                        
                                                                                                                                                        

                                                                                                                                                        
                                                                                                                                                        

                                                                                                                                                        
                                                                                                                                                        

                                                                                                                                                        response.setTimeout(msecs[, callback])#

                                                                                                                                                        中英对照

                                                                                                                                                          将套接字的超时值设置为 msecs。 如果提供了回调,则将其添加为响应对象上 'timeout' 事件的监听器。

                                                                                                                                                          response.socket#

                                                                                                                                                          中英对照

                                                                                                                                                            对底层套接字的引用。 通常用户不会想要访问这个属性。 特别是,由于协议解析器附加到套接字的方式,套接字将不会触发 'readable' 事件。 在 response.end() 之后,该属性为空。

                                                                                                                                                            
                                                                                                                                                            

                                                                                                                                                            response.statusCode#

                                                                                                                                                            中英对照

                                                                                                                                                              使用隐式标头(不显式调用 response.writeHead())时,此属性控制在标头刷新时将发送到客户端的状态码。

                                                                                                                                                              
                                                                                                                                                              

                                                                                                                                                              response.statusMessage#

                                                                                                                                                              中英对照

                                                                                                                                                                当使用隐式标头(不显式调用 response.writeHead())时,此属性控制在标头刷新时将发送到客户端的状态消息。 如果保留为 undefined,则将使用状态码的标准消息。

                                                                                                                                                                
                                                                                                                                                                

                                                                                                                                                                response.uncork()#

                                                                                                                                                                中英对照

                                                                                                                                                                参见 writable.uncork()

                                                                                                                                                                response.writableEnded#

                                                                                                                                                                中英对照

                                                                                                                                                                  在调用 response.end() 之后是 true。 此属性不指示数据是否已刷新,为此则使用 response.writableFinished 代替。

                                                                                                                                                                  response.writableFinished#

                                                                                                                                                                  中英对照

                                                                                                                                                                    如果所有数据都已在 'finish' 事件触发之前立即刷新到底层系统,则为 true

                                                                                                                                                                    response.write(chunk[, encoding][, callback])#

                                                                                                                                                                    中英对照

                                                                                                                                                                      如果此方法被调用且 response.writeHead() 还没被调用,则会切换到隐式的标头模式并刷新隐式的标头。

                                                                                                                                                                      response.writeContinue()#

                                                                                                                                                                      中英对照

                                                                                                                                                                      向客户端发送 HTTP/1.1 100 Continue 消息,指示应发送请求正文。 请参阅 Server 上的 'checkContinue' 事件。

                                                                                                                                                                      response.writeHead(statusCode[, statusMessage][, headers])#

                                                                                                                                                                      中英对照

                                                                                                                                                                        向请求发送响应头。 状态码是 3 位的 HTTP 状态码,如 404。 最后一个参数 headers 是响应头。 可选地给定人类可读的 statusMessage 作为第二个参数。

                                                                                                                                                                        
                                                                                                                                                                        

                                                                                                                                                                        
                                                                                                                                                                        

                                                                                                                                                                        response.writeProcessing()#

                                                                                                                                                                        中英对照

                                                                                                                                                                        向客户端发送 HTTP/1.1 102 Processing 消息,表示应发送请求正文。

                                                                                                                                                                        http.IncomingMessage#

                                                                                                                                                                        中英对照

                                                                                                                                                                          IncomingMessage 对象由 http.Serverhttp.ClientRequest 创建,并分别作为第一个参数传给 'request''response' 事件。 它可用于访问响应状态、标头和数据。

                                                                                                                                                                          'aborted' 事件#

                                                                                                                                                                          中英对照

                                                                                                                                                                          当请求被中止时触发。

                                                                                                                                                                          'close' 事件#

                                                                                                                                                                          中英对照

                                                                                                                                                                          当请求完成时触发。

                                                                                                                                                                          message.aborted#

                                                                                                                                                                          中英对照

                                                                                                                                                                            如果请求已中止,则 message.aborted 属性将为 true

                                                                                                                                                                            message.complete#

                                                                                                                                                                            中英对照

                                                                                                                                                                              如果已接收并成功解析完整的 HTTP 消息,则 message.complete 属性将为 true

                                                                                                                                                                              
                                                                                                                                                                              

                                                                                                                                                                              message.connection#

                                                                                                                                                                              中英对照

                                                                                                                                                                              message.socket 的别名。

                                                                                                                                                                              message.destroy([error])#

                                                                                                                                                                              中英对照

                                                                                                                                                                                在接收到 IncomingMessage 的套接字上调用 destroy()。 如果提供了 error,则在套接字上触发 'error' 事件,并将 error 作为参数传给该事件的任何监听器。

                                                                                                                                                                                message.headers#

                                                                                                                                                                                中英对照

                                                                                                                                                                                  请求/响应头对象。

                                                                                                                                                                                  
                                                                                                                                                                                  

                                                                                                                                                                                    message.headersDistinct#

                                                                                                                                                                                    中英对照

                                                                                                                                                                                      类似于 message.headers,但没有连接逻辑,并且值始终是字符串数组,即使对于仅收到一次的标头也是如此。

                                                                                                                                                                                      
                                                                                                                                                                                      

                                                                                                                                                                                      message.httpVersion#

                                                                                                                                                                                      中英对照

                                                                                                                                                                                        在服务器请求的情况下,客户端发送的 HTTP 版本。 在客户端响应的情况下,连接到服务器的 HTTP 版本。 可能是 '1.1''1.0'

                                                                                                                                                                                        message.method#

                                                                                                                                                                                        中英对照

                                                                                                                                                                                          仅适用于从 http.Server 获得的请求。

                                                                                                                                                                                          message.rawHeaders#

                                                                                                                                                                                          中英对照

                                                                                                                                                                                            原始请求/响应头完全按照收到的方式列出。

                                                                                                                                                                                            
                                                                                                                                                                                            

                                                                                                                                                                                            message.rawTrailers#

                                                                                                                                                                                            中英对照

                                                                                                                                                                                              原始请求/响应尾标的键和值与收到的完全一样。 仅在 'end' 事件中填充。

                                                                                                                                                                                              message.setTimeout(msecs[, callback])#

                                                                                                                                                                                              中英对照

                                                                                                                                                                                                调用 message.socket.setTimeout(msecs, callback)

                                                                                                                                                                                                message.socket#

                                                                                                                                                                                                中英对照

                                                                                                                                                                                                  与连接关联的 net.Socket 对象。

                                                                                                                                                                                                  message.statusCode#

                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                    仅对从 http.ClientRequest 获得的响应有效。

                                                                                                                                                                                                    message.statusMessage#

                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                      仅对从 http.ClientRequest 获得的响应有效。

                                                                                                                                                                                                      message.trailers#

                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                        请求/响应尾标对象。 仅在 'end' 事件中填充。

                                                                                                                                                                                                        message.trailersDistinct#

                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                          类似于 message.trailers,但没有连接逻辑,并且值始终是字符串数组,即使对于仅收到一次的标头也是如此。 仅在 'end' 事件中填充。

                                                                                                                                                                                                          message.url#

                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                            仅适用于从 http.Server 获得的请求。

                                                                                                                                                                                                            
                                                                                                                                                                                                            

                                                                                                                                                                                                            
                                                                                                                                                                                                            

                                                                                                                                                                                                            
                                                                                                                                                                                                            

                                                                                                                                                                                                            http.OutgoingMessage#

                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                              该类作为 http.ClientRequesthttp.ServerResponse 的父类。 从 HTTP 事务的参与者的角度来看,这是抽象的传出消息。

                                                                                                                                                                                                              'drain' 事件#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                              当消息的缓冲区再次空闲时触发。

                                                                                                                                                                                                              'finish' 事件#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                              当传输成功完成时触发。

                                                                                                                                                                                                              'prefinish' 事件#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                              调用 outgoingMessage.end() 后触发。 触发事件时,所有数据都已处理,但不一定完全刷新。

                                                                                                                                                                                                              outgoingMessage.addTrailers(headers)#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                添加 HTTP 尾标(标头,但在消息末尾)到消息。

                                                                                                                                                                                                                
                                                                                                                                                                                                                

                                                                                                                                                                                                                outgoingMessage.appendHeader(name, value)#

                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                  为标头对象附加单一个标头值。

                                                                                                                                                                                                                  outgoingMessage.connection#

                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                  outgoingMessage.socket 的别名。

                                                                                                                                                                                                                  outgoingMessage.cork()#

                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                  参见 writable.cork()

                                                                                                                                                                                                                  outgoingMessage.destroy([error])#

                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                    销毁消息。 一旦套接字与消息关联并连接,则该套接字也将被销毁。

                                                                                                                                                                                                                    outgoingMessage.end(chunk[, encoding][, callback])#

                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                      完成传出消息。 如果正文的任何部分未发送,则会将它们刷新到底层系统。 如果消息被分块,则它将发送终止块 0\r\n\r\n,并发送块尾(如果有)。

                                                                                                                                                                                                                      outgoingMessage.flushHeaders()#

                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                      刷新消息标头。

                                                                                                                                                                                                                      outgoingMessage.getHeader(name)#

                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                        获取具有给定名称的 HTTP 标头的值。 如果未设置该标头,则返回值为 undefined

                                                                                                                                                                                                                        outgoingMessage.getHeaderNames()#

                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                          返回包含当前传出标头的唯一名称的数组。 所有名称均为小写。

                                                                                                                                                                                                                          outgoingMessage.getHeaders()#

                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                            返回当前传出标头的浅拷贝。 由于使用了浅拷贝,因此无需额外调用各种与标头相关的 HTTP 模块方法即可更改数组值。 返回对象的键是标头名称,值是相应的标头值。 所有标头名称均为小写。

                                                                                                                                                                                                                            
                                                                                                                                                                                                                            

                                                                                                                                                                                                                            outgoingMessage.hasHeader(name)#

                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                              如果 name 标识的标头当前设置在传出标头中,则返回 true。 标头名称不区分大小写。

                                                                                                                                                                                                                              
                                                                                                                                                                                                                              

                                                                                                                                                                                                                              outgoingMessage.headersSent#

                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                只读。 如果标头已发送,则为 true,否则为 false

                                                                                                                                                                                                                                outgoingMessage.pipe()#

                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                覆盖继承自旧版的 Stream 类(http.OutgoingMessage 的父类)的 stream.pipe() 方法。

                                                                                                                                                                                                                                outgoingMessage.removeHeader(name)#

                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                  删除排队等待隐式发送的标头。

                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  outgoingMessage.setHeader(name, value)#

                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                    设置单个标头值。 如果待发送标头中已经存在该标头,则替换其值。 使用字符串数组发送多个同名标头。

                                                                                                                                                                                                                                    outgoingMessage.setTimeout(msesc[, callback])#

                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                      一旦套接字与消息关联并连接,则 socket.setTimeout() 将被调用,msecs 作为第一个参数。

                                                                                                                                                                                                                                      outgoingMessage.socket#

                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                        对底层套接字的引用。 通常,用户不会希望访问此属性。

                                                                                                                                                                                                                                        outgoingMessage.uncork()#

                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                        参见 writable.uncork()

                                                                                                                                                                                                                                        outgoingMessage.writableCorked#

                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                          调用 outgoingMessage.cork() 的次数。

                                                                                                                                                                                                                                          outgoingMessage.writableEnded#

                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                            如果调用了 outgoingMessage.end(),则为 true。 该属性不表示数据是否被刷新。 为此目的,则改用 message.writableFinished

                                                                                                                                                                                                                                            outgoingMessage.writableFinished#

                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                              如果所有数据都已刷新到底层系统,则为 true

                                                                                                                                                                                                                                              outgoingMessage.writableHighWaterMark#

                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                如果分配了底层套接字的 highWaterMark。 否则,writable.write() 开始时的默认缓冲级别返回 false(16384)。

                                                                                                                                                                                                                                                outgoingMessage.writableLength#

                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                  缓冲的字节数。

                                                                                                                                                                                                                                                  outgoingMessage.writableObjectMode#

                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                    始终为 false

                                                                                                                                                                                                                                                    outgoingMessage.write(chunk[, encoding][, callback])#

                                                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                                                      发送一块正文。 此方法可以被多次调用。

                                                                                                                                                                                                                                                      http.METHODS#

                                                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                                                        解析器支持的 HTTP 方法列表。

                                                                                                                                                                                                                                                        http.STATUS_CODES#

                                                                                                                                                                                                                                                        中英对照

                                                                                                                                                                                                                                                          所有标准 HTTP 响应状态代码的集合,以及每个的简短描述。 例如,http.STATUS_CODES[404] === 'Not Found'

                                                                                                                                                                                                                                                          http.createServer([options][, requestListener])#

                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                            返回 http.Server 的新实例。

                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                            http.get(options[, callback])#

                                                                                                                                                                                                                                                            http.get(url[, options][, callback])#

                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                              由于大多数请求是没有正文的 GET 请求,因此 Node.js 提供了这个便捷的方法。 此方法与 http.request() 的唯一区别在于,它将方法设置为 GET 并自动调用 req.end()。 因为 http.ClientRequest 章节所述的原因,回调必须注意消费响应数据。

                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                              http.globalAgent#

                                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                                Agent 的全局实例,用作所有 HTTP 客户端请求的默认值。

                                                                                                                                                                                                                                                                http.maxHeaderSize#

                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                  只读属性,指定 HTTP 标头的最大允许大小(以字节为单位)。 默认为 16 KiB。 可使用 --max-http-header-size 命令行选项进行配置。

                                                                                                                                                                                                                                                                  http.request(options[, callback])#

                                                                                                                                                                                                                                                                  http.request(url[, options][, callback])#

                                                                                                                                                                                                                                                                  中英对照

                                                                                                                                                                                                                                                                    socket.connect() 中的 options 也受支持。

                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                          http.validateHeaderName(name)#

                                                                                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                                                                                            在调用 res.setHeader(name, value) 时对提供的 name 执行低层验证。

                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                            http.validateHeaderValue(name, value)#

                                                                                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                                                                                              在调用 res.setHeader(name, value) 时对提供的 value 执行低层验证。

                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                http.setMaxIdleHTTPParsers#

                                                                                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                                                                                  设置最大空闲 HTTP 解析器数。 默认值: 1000

                                                                                                                                                                                                                                                                                                  返回顶部