Node.js v14.20.0 文档


目录

http 超文本传输协议#

中英对照

要使用 HTTP 服务器和客户端,则必须 require('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() 时触发。

                          'connect' 事件#

                          中英对照

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

                            
                            

                            'continue' 事件#

                            中英对照

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

                            '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.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.getRawHeaderNames()#

                                                  中英对照

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

                                                    
                                                    

                                                    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.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 上访问。

                                                                                              'request' 事件#

                                                                                              中英对照

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

                                                                                                'upgrade' 事件#

                                                                                                中英对照

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

                                                                                                  server.close([callback])#

                                                                                                  中英对照

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

                                                                                                    server.headersTimeout#

                                                                                                    中英对照

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

                                                                                                      server.listen()#

                                                                                                      中英对照

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

                                                                                                      server.listening#

                                                                                                      中英对照

                                                                                                        server.maxHeadersCount#

                                                                                                        中英对照

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

                                                                                                          server.requestTimeout#

                                                                                                          中英对照

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

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

                                                                                                            中英对照

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

                                                                                                              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.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.destroy([error])#

                                                                                                                                                                  中英对照

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

                                                                                                                                                                    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.url#

                                                                                                                                                                                          中英对照

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

                                                                                                                                                                                            
                                                                                                                                                                                            

                                                                                                                                                                                            
                                                                                                                                                                                            

                                                                                                                                                                                            
                                                                                                                                                                                            

                                                                                                                                                                                            http.OutgoingMessage#

                                                                                                                                                                                            中英对照

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

                                                                                                                                                                                              drain 事件#

                                                                                                                                                                                              中英对照

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

                                                                                                                                                                                              finish 事件#

                                                                                                                                                                                              中英对照

                                                                                                                                                                                              当传输成功完成时触发。

                                                                                                                                                                                              prefinish 事件#

                                                                                                                                                                                              中英对照

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

                                                                                                                                                                                              outgoingMessage.addTrailers(headers)#

                                                                                                                                                                                              中英对照

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

                                                                                                                                                                                                
                                                                                                                                                                                                

                                                                                                                                                                                                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 的标头名称数组。 所有名称均为小写。

                                                                                                                                                                                                        outgoingMessage.getHeaders()#

                                                                                                                                                                                                        中英对照

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

                                                                                                                                                                                                          
                                                                                                                                                                                                          

                                                                                                                                                                                                          outgoingMessage.hasHeader(name)#

                                                                                                                                                                                                          中英对照

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

                                                                                                                                                                                                            
                                                                                                                                                                                                            

                                                                                                                                                                                                            outgoingMessage.headersSent#

                                                                                                                                                                                                            中英对照

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

                                                                                                                                                                                                              outgoingMessage.pipe()#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                              覆盖旧版 Stream 的管道方法,其是 http.outgoingMessage 的父类。

                                                                                                                                                                                                              outgoingMessage.removeHeader()#

                                                                                                                                                                                                              中英对照

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

                                                                                                                                                                                                              
                                                                                                                                                                                                              

                                                                                                                                                                                                              outgoingMessage.setHeader(name, value)#

                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                为标头对象设置单个标头值。

                                                                                                                                                                                                                outgoingMessage.setTimeout(msesc[, callback])#

                                                                                                                                                                                                                中英对照

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

                                                                                                                                                                                                                  outgoingMessage.socket#

                                                                                                                                                                                                                  中英对照

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

                                                                                                                                                                                                                    outgoingMessage.uncork()#

                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                    参见 writable.uncork()

                                                                                                                                                                                                                    outgoingMessage.writableCorked#

                                                                                                                                                                                                                    中英对照

                                                                                                                                                                                                                      outgoingMessage.writableCorked 将返回调用了多少 outgoingMessage.cork() 的时间。

                                                                                                                                                                                                                      outgoingMessage.writableEnded#

                                                                                                                                                                                                                      中英对照

                                                                                                                                                                                                                        只读,如果 outgoingMessage.end() 已被调用,则为 true。 注意,这个属性不反映数据是否已经刷新。 为此目的,则改用 message.writableFinished

                                                                                                                                                                                                                        outgoingMessage.writableFinished#

                                                                                                                                                                                                                        中英对照

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

                                                                                                                                                                                                                          outgoingMessage.writableHighWaterMark#

                                                                                                                                                                                                                          中英对照

                                                                                                                                                                                                                            如果套接字存在,则此 outgoingMessage.writableHighWaterMark 将是底层套接字的 highWaterMark。 否则,它将是默认的 highWaterMark

                                                                                                                                                                                                                            outgoingMessage.writableLength#

                                                                                                                                                                                                                            中英对照

                                                                                                                                                                                                                              只读,此 outgoingMessage.writableLength 包含缓冲区中准备发送的字节数(或对象)。

                                                                                                                                                                                                                              outgoingMessage.writableObjectMode#

                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                只读,总是返回 false

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

                                                                                                                                                                                                                                中英对照

                                                                                                                                                                                                                                  如果调用这个方法并且没有发送标头,则会调用 this._implicitHeader 来刷新隐式标头。 如果消息不应该有正文(由 this._hasBody 指示),则忽略调用并且不会发送 chunk。 在处理不能包含正文的特定消息时,它可能很有用。 例如响应 HEAD 请求,204304 响应。

                                                                                                                                                                                                                                  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 标头的最大允许大小(以字节为单位)。 默认为 8KB。 可使用 --max-http-header-size 命令行选项进行配置。

                                                                                                                                                                                                                                              http.request(options[, callback])#

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

                                                                                                                                                                                                                                              中英对照

                                                                                                                                                                                                                                                Node.js 为每个服务器维护多个连接以发出 HTTP 请求。 此函数允许显式地发出请求。

                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                      http.validateHeaderName(name)#

                                                                                                                                                                                                                                                                      中英对照

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

                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                        http.validateHeaderValue(name, value)#

                                                                                                                                                                                                                                                                        中英对照

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

                                                                                                                                                                                                                                                                            返回顶部