HTTP

[Stable: 2 - Stable]

소스 코드: lib/http.js

클라이언트와 서버를 모두 포함하는 이 모듈은 require('node:http') (CommonJS) 또는 import * as http from 'node:http' (ES 모듈)을 통해 가져올 수 있습니다.

Node.js의 HTTP 인터페이스는 전통적으로 사용하기 어려웠던 프로토콜의 많은 기능을 지원하도록 설계되었습니다. 특히, 크고, 청크 인코딩될 가능성이 있는 메시지입니다. 인터페이스는 전체 요청이나 응답을 버퍼링하지 않도록 주의하므로 사용자는 데이터를 스트리밍할 수 있습니다.

HTTP 메시지 헤더는 다음과 같은 객체로 표현됩니다.

json

{
  "content-length": "123",
  "content-type": "text/plain",
  "connection": "keep-alive",
  "host": "example.com",
  "accept": "*/*"
}

키는 소문자로 표시됩니다. 값은 수정되지 않습니다.

모든 가능한 HTTP 애플리케이션의 전체 스펙트럼을 지원하기 위해 Node.js HTTP API는 매우 저수준입니다. 스트림 처리 및 메시지 파싱만 처리합니다. 메시지를 헤더와 본문으로 파싱하지만 실제 헤더나 본문을 파싱하지는 않습니다.

중복 헤더 처리 방법에 대한 자세한 내용은 message.headers를 참조하십시오.

수신된 원시 헤더는 rawHeaders 속성에 [key, value, key2, value2, ...] 형태의 배열로 유지됩니다. 예를 들어, 이전 메시지 헤더 객체는 다음과 같은 rawHeaders 목록을 가질 수 있습니다.

;[
  'ConTent-Length',
  '123456',
  'content-LENGTH',
  '123',
  'content-type',
  'text/plain',
  'CONNECTION',
  'keep-alive',
  'Host',
  'example.com',
  'accepT',
  '*/*',
]

클래스: `http.Agent`

추가됨: v0.3.4

Agent는 HTTP 클라이언트에 대한 연결 지속성 및 재사용을 관리하는 역할을 합니다. 지정된 호스트와 포트에 대한 보류 중인 요청 큐를 유지 관리하고, 큐가 비어있을 때까지 각각에 대해 단일 소켓 연결을 재사용하며, 그런 다음 소켓이 파괴되거나 동일한 호스트와 포트에 대한 요청에 다시 사용될 수 있도록 풀에 저장됩니다. 파괴될지 풀에 저장될지는 keepAlive 옵션에 따라 달라집니다.

풀링된 연결에는 TCP Keep-Alive가 활성화되어 있지만, 서버는 여전히 유휴 연결을 닫을 수 있으며, 이 경우 풀에서 제거되고 해당 호스트와 포트에 대한 새 HTTP 요청이 있을 때 새 연결이 만들어집니다. 서버는 동일한 연결을 통한 여러 요청을 허용하지 않을 수도 있으며, 이 경우 매 요청마다 연결을 다시 만들어야 하며 풀링할 수 없습니다. Agent는 해당 서버에 대한 요청을 계속하지만 각 요청은 새 연결을 통해 발생합니다.

클라이언트 또는 서버가 연결을 닫으면 풀에서 제거됩니다. 풀의 사용되지 않은 소켓은 참조 해제되어 미해결 요청이 없을 때 Node.js 프로세스가 실행되도록 유지하지 않습니다. (socket.unref() 참조).

사용하지 않는 소켓은 OS 리소스를 소비하므로 더 이상 사용하지 않는 경우 Agent 인스턴스를 destroy()하는 것이 좋습니다.

소켓은 소켓이 'close' 이벤트 또는 'agentRemove' 이벤트를 방출할 때 에이전트에서 제거됩니다. 에이전트에 보관하지 않고 오랫동안 하나의 HTTP 요청을 열어 두려면 다음과 같은 작업을 수행할 수 있습니다.

http
  .get(options, res => {
    // 작업 수행
  })
  .on('socket', socket => {
    socket.emit('agentRemove')
  })

에이전트는 개별 요청에도 사용할 수 있습니다. http.get() 또는 http.request() 함수에 {agent: false}를 옵션으로 제공하면 기본 옵션을 사용하는 일회용 Agent가 클라이언트 연결에 사용됩니다.

agent:false:

http.get(
  {
    hostname: 'localhost',
    port: 80,
    path: '/',
    agent: false, // 이 요청에 대해서만 새 에이전트 생성
  },
  res => {
    // 응답으로 작업 수행
  }
)

`new Agent([options])`

[히스토리]

버전	변경 사항
v15.6.0, v14.17.0	기본 스케줄링을 'fifo'에서 'lifo'로 변경
v14.5.0, v12.20.0	사용 가능한 소켓 스케줄링 전략을 지정하는 `scheduling` 옵션 추가
v14.5.0, v12.19.0	에이전트 생성자에 `maxTotalSockets` 옵션 추가
v0.3.4	추가됨: v0.3.4

options <Object> 에이전트에 설정할 구성 가능한 옵션 집합입니다. 다음 필드를 가질 수 있습니다.
- keepAlive <boolean> 미처리 요청이 없더라도 소켓을 유지하여 TCP 연결을 다시 설정하지 않고도 향후 요청에 사용할 수 있도록 합니다. Connection 헤더의 keep-alive 값과 혼동하지 마십시오. Connection 헤더가 명시적으로 지정되거나 keepAlive 및 maxSockets 옵션이 각각 false 및 Infinity로 설정된 경우를 제외하고는 Connection: keep-alive 헤더가 항상 에이전트를 사용할 때 전송됩니다. 이 경우 Connection: close가 사용됩니다. 기본값: false.
- keepAliveMsecs <number> keepAlive 옵션을 사용하는 경우 TCP Keep-Alive 패킷의 초기 지연을 지정합니다. keepAlive 옵션이 false 또는 undefined인 경우 무시됩니다. 기본값: 1000.
- maxSockets <number> 호스트당 허용되는 최대 소켓 수입니다. 같은 호스트가 여러 개의 동시 연결을 열면 각 요청은 maxSockets 값에 도달할 때까지 새 소켓을 사용합니다. 호스트가 maxSockets보다 많은 연결을 열려고 시도하면 추가 요청은 보류 중인 요청 큐에 들어가고 기존 연결이 종료될 때 활성 연결 상태로 전환됩니다. 이렇게 하면 지정된 호스트에서 언제든지 최대 maxSockets개의 활성 연결이 유지됩니다. 기본값: Infinity.
- maxTotalSockets <number> 모든 호스트에 대해 허용되는 최대 소켓 수입니다. 최대값에 도달할 때까지 각 요청은 새 소켓을 사용합니다. 기본값: Infinity.
- maxFreeSockets <number> 사용 가능한 상태로 열어둘 호스트당 최대 소켓 수입니다. keepAlive가 true로 설정된 경우에만 관련이 있습니다. 기본값: 256.
- scheduling <string> 사용할 다음 사용 가능한 소켓을 선택할 때 적용할 스케줄링 전략입니다. 'fifo' 또는 'lifo'가 될 수 있습니다. 두 스케줄링 전략의 주요 차이점은 'lifo'가 가장 최근에 사용된 소켓을 선택하는 반면 'fifo'는 가장 오래 사용되지 않은 소켓을 선택한다는 것입니다. 초당 요청률이 낮은 경우 'lifo' 스케줄링은 비활성으로 인해 서버에서 닫혔을 수 있는 소켓을 선택할 위험을 줄입니다. 초당 요청률이 높은 경우 'fifo' 스케줄링은 열려 있는 소켓 수를 최대화하는 반면 'lifo' 스케줄링은 최대한 낮게 유지합니다. 기본값: 'lifo'.
- timeout <number> 밀리초 단위의 소켓 제한 시간입니다. 소켓이 생성될 때 제한 시간을 설정합니다.

socket.connect()[/api/net#socketconnectoptions-connectlistener]의 options도 지원됩니다.

이러한 옵션 중 하나를 구성하려면 사용자 지정 http.Agent 인스턴스를 생성해야 합니다.

ESMCJS

import { Agent, request } from 'node:http'
const keepAliveAgent = new Agent({ keepAlive: true })
options.agent = keepAliveAgent
request(options, onResponseCallback)

const http = require('node:http')
const keepAliveAgent = new http.Agent({ keepAlive: true })
options.agent = keepAliveAgent
http.request(options, onResponseCallback)

`agent.createConnection(options[, callback])`

추가됨: v0.11.4

options <Object> 연결 세부 정보가 포함된 옵션입니다. 옵션 형식은 net.createConnection()을 참조하십시오.
callback <Function> 생성된 소켓을 수신하는 콜백 함수입니다.
반환값: <stream.Duplex>

HTTP 요청에 사용할 소켓/스트림을 생성합니다.

기본적으로 이 함수는 net.createConnection()과 동일합니다. 그러나 더 큰 유연성이 필요한 경우 사용자 정의 에이전트에서 이 메서드를 재정의할 수 있습니다.

소켓/스트림은 두 가지 방법 중 하나로 제공될 수 있습니다. 이 함수에서 소켓/스트림을 반환하거나 소켓/스트림을 callback에 전달합니다.

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 메서드는 <net.Socket> 클래스의 인스턴스인 <stream.Duplex>의 하위 클래스를 반환합니다.

callback의 시그니처는 (err, stream)입니다.

`agent.keepSocketAlive(socket)`

추가됨: v8.1.0

socket <stream.Duplex>

socket이 요청에서 분리되고 Agent에 의해 유지될 수 있을 때 호출됩니다. 기본 동작은 다음과 같습니다.

socket.setKeepAlive(true, this.keepAliveMsecs)
socket.unref()
return true

이 메서드는 특정 Agent 하위 클래스에서 재정의될 수 있습니다. 이 메서드가 거짓 값을 반환하면 소켓은 유지되지 않고 대신 삭제됩니다.

socket 인수는 <stream.Duplex>의 하위 클래스인 <net.Socket>의 인스턴스일 수 있습니다.

`agent.reuseSocket(socket, request)`

추가됨: v8.1.0

socket <stream.Duplex>
request <http.ClientRequest>

keep-alive 옵션으로 인해 유지된 후 socket이 request에 연결될 때 호출됩니다. 기본 동작은 다음과 같습니다.

socket.ref()

이 메서드는 특정 Agent 하위 클래스에서 재정의될 수 있습니다.

socket 인수는 <stream.Duplex>의 하위 클래스인 <net.Socket>의 인스턴스일 수 있습니다.

`agent.destroy()`

추가됨: v0.11.4

에이전트에서 현재 사용 중인 모든 소켓을 파괴합니다.

일반적으로 이 작업이 필요하지 않습니다. 하지만 keepAlive를 활성화한 에이전트를 사용하는 경우 더 이상 필요하지 않을 때 에이전트를 명시적으로 종료하는 것이 가장 좋습니다. 그렇지 않으면 서버가 소켓을 종료하기 전에 소켓이 상당히 오랫동안 열려 있을 수 있습니다.

`agent.freeSockets`

[히스토리]

버전	변경 사항
v16.0.0	이제 속성에 `null` 프로토타입이 있습니다.
v0.11.4	추가됨: v0.11.4

<Object>

keepAlive가 활성화된 경우 에이전트에서 현재 사용을 기다리고 있는 소켓의 배열을 포함하는 객체입니다. 수정하지 마세요.

freeSockets 목록의 소켓은 'timeout'에서 자동으로 파괴되고 배열에서 제거됩니다.

`agent.getName([options])`

[히스토리]

버전	변경 사항
v17.7.0, v16.15.0	`options` 매개변수가 이제 선택 사항입니다.
v0.11.4	추가됨: v0.11.4

options <Object> 이름 생성에 대한 정보를 제공하는 옵션 집합
- host <string> 요청을 보낼 서버의 도메인 이름 또는 IP 주소
- port <number> 원격 서버의 포트
- localAddress <string> 요청을 보낼 때 네트워크 연결을 위해 바인딩할 로컬 인터페이스
- family <integer> 이 값이 undefined가 아니면 4 또는 6이어야 합니다.
반환값: <string>

연결을 재사용할 수 있는지 확인하기 위해 요청 옵션 집합에 대한 고유한 이름을 가져옵니다. HTTP 에이전트의 경우 host:port:localAddress 또는 host:port:localAddress:family를 반환합니다. HTTPS 에이전트의 경우 이름에는 소켓 재사용을 결정하는 CA, 인증서, 암호 및 기타 HTTPS/TLS 관련 옵션이 포함됩니다.

`agent.maxFreeSockets`

추가됨: v0.11.7

<숫자>

기본값은 256입니다. keepAlive가 활성화된 에이전트의 경우, 사용 가능한 상태로 유지될 소켓의 최대 수를 설정합니다.

`agent.maxSockets`

추가됨: v0.3.6

<숫자>

기본값은 Infinity입니다. 에이전트가 원본당 열 수 있는 동시 소켓 수를 결정합니다. 원본은 agent.getName()의 반환값입니다.

`agent.maxTotalSockets`

추가됨: v14.5.0, v12.19.0

<숫자>

기본값은 Infinity입니다. 에이전트가 열 수 있는 동시 소켓의 총 수를 결정합니다. maxSockets와 달리 이 매개변수는 모든 원본에 적용됩니다.

`agent.requests`

[히스토리]

버전	변경 사항
v16.0.0	이제 속성의 프로토타입이 `null`입니다.
v0.5.9	추가됨: v0.5.9

<객체>

아직 소켓에 할당되지 않은 요청 큐를 포함하는 객체입니다. 수정하지 마세요.

`agent.sockets`

[히스토리]

버전	변경 사항
v16.0.0	이제 속성의 프로토타입이 `null`입니다.
v0.3.6	추가됨: v0.3.6

<객체>

에이전트가 현재 사용 중인 소켓 배열을 포함하는 객체입니다. 수정하지 마세요.

클래스: `http.ClientRequest`

추가됨: v0.1.17

상속: <http.OutgoingMessage>

이 객체는 내부적으로 생성되어 http.request()에서 반환됩니다. 이미 헤더가 큐에 추가된 진행 중인 요청을 나타냅니다. 헤더는 setHeader(name, value), getHeader(name), removeHeader(name) API를 사용하여 수정할 수 있습니다. 실제 헤더는 첫 번째 데이터 청크와 함께 또는 request.end()를 호출할 때 전송됩니다.

응답을 얻으려면 요청 객체에 'response'에 대한 리스너를 추가합니다. 응답 헤더를 수신하면 요청 객체에서 'response'가 방출됩니다. 'response' 이벤트는 http.IncomingMessage 인스턴스인 하나의 인수로 실행됩니다.

'response' 이벤트 중에 응답 객체에 리스너를 추가할 수 있습니다. 특히 'data' 이벤트를 수신하기 위해서입니다.

'response' 핸들러가 추가되지 않으면 응답이 완전히 삭제됩니다. 그러나 'response' 이벤트 핸들러가 추가되면 응답 객체의 데이터를 response.read()를 호출하거나 'data' 핸들러를 추가하거나 .resume() 메서드를 호출하여 반드시 사용해야 합니다. 데이터가 사용될 때까지 'end' 이벤트가 발생하지 않습니다. 또한 데이터가 읽히기 전까지 메모리를 소비하여 결국 '프로세스 메모리 부족' 오류로 이어질 수 있습니다.

하위 호환성을 위해 res는 'error' 리스너가 등록된 경우에만 'error'를 방출합니다.

Content-Length 헤더를 설정하여 응답 본문 크기를 제한합니다. response.strictContentLength가 true로 설정된 경우 Content-Length 헤더 값이 일치하지 않으면 code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'로 식별되는 Error가 throw됩니다.

Content-Length 값은 문자가 아닌 바이트여야 합니다. 본문의 길이를 바이트 단위로 확인하려면 Buffer.byteLength()를 사용하십시오.

이벤트: `'abort'`

추가됨: v1.4.1

더 이상 사용되지 않음: v17.0.0, v16.12.0

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 0 안정성: 0 - 더 이상 사용되지 않습니다. 대신 'close' 이벤트를 수신하십시오.

클라이언트에 의해 요청이 중단되었을 때 발생합니다. 이 이벤트는 abort()에 대한 첫 번째 호출에서만 발생합니다.

이벤트: `'close'`

추가됨: v0.5.4

요청이 완료되었거나 기본 연결이 응답 완료 전에 조기에 종료되었음을 나타냅니다.

이벤트: `'connect'`

추가됨: v0.7.0

서버가 CONNECT 메서드를 사용하여 요청에 응답할 때마다 발생합니다. 이 이벤트를 수신하지 않으면 CONNECT 메서드를 수신하는 클라이언트의 연결이 끊어집니다.

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 이벤트는 <net.Socket> 클래스의 인스턴스인 <stream.Duplex>의 하위 클래스를 전달받는 것이 보장됩니다.

'connect' 이벤트 수신 방법을 보여주는 클라이언트와 서버 쌍:

ESMCJS

import { createServer, request } from 'node:http'
import { connect } from 'node:net'
import { URL } from 'node:url'

// HTTP 터널링 프록시 생성
const proxy = createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
proxy.on('connect', (req, clientSocket, head) => {
  // 원본 서버에 연결
  const { port, hostname } = new URL(`http://${req.url}`)
  const serverSocket = connect(port || 80, hostname, () => {
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n' + 'Proxy-agent: Node.js-Proxy\r\n' + '\r\n')
    serverSocket.write(head)
    serverSocket.pipe(clientSocket)
    clientSocket.pipe(serverSocket)
  })
})

// 프록시가 실행 중이므로
proxy.listen(1337, '127.0.0.1', () => {
  // 터널링 프록시에 요청 생성
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80',
  }

  const req = request(options)
  req.end()

  req.on('connect', (res, socket, head) => {
    console.log('got connected!')

    // HTTP 터널을 통해 요청 생성
    socket.write('GET / HTTP/1.1\r\n' + 'Host: www.google.com:80\r\n' + 'Connection: close\r\n' + '\r\n')
    socket.on('data', chunk => {
      console.log(chunk.toString())
    })
    socket.on('end', () => {
      proxy.close()
    })
  })
})

const http = require('node:http')
const net = require('node:net')
const { URL } = require('node:url')

// HTTP 터널링 프록시 생성
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
proxy.on('connect', (req, clientSocket, head) => {
  // 원본 서버에 연결
  const { port, hostname } = new URL(`http://${req.url}`)
  const serverSocket = net.connect(port || 80, hostname, () => {
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n' + 'Proxy-agent: Node.js-Proxy\r\n' + '\r\n')
    serverSocket.write(head)
    serverSocket.pipe(clientSocket)
    clientSocket.pipe(serverSocket)
  })
})

// 프록시가 실행 중이므로
proxy.listen(1337, '127.0.0.1', () => {
  // 터널링 프록시에 요청 생성
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80',
  }

  const req = http.request(options)
  req.end()

  req.on('connect', (res, socket, head) => {
    console.log('got connected!')

    // HTTP 터널을 통해 요청 생성
    socket.write('GET / HTTP/1.1\r\n' + 'Host: www.google.com:80\r\n' + 'Connection: close\r\n' + '\r\n')
    socket.on('data', chunk => {
      console.log(chunk.toString())
    })
    socket.on('end', () => {
      proxy.close()
    })
  })
})

이벤트: `'continue'`

추가됨: v0.3.2

서버가 '100 Continue' HTTP 응답을 보낼 때 발생합니다. 일반적으로 요청에 'Expect: 100-continue'가 포함되어 있기 때문입니다. 이는 클라이언트가 요청 본문을 보내야 함을 나타내는 지시입니다.

이벤트: `'finish'`

추가됨: v0.3.6

요청이 전송되었을 때 발생합니다. 보다 구체적으로, 이 이벤트는 응답 헤더와 본문의 마지막 세그먼트가 네트워크를 통한 전송을 위해 운영 체제에 전달되었을 때 발생합니다. 서버가 아직 아무것도 수신하지 않았음을 의미하지는 않습니다.

이벤트: `'information'`

추가됨: v10.0.0

info <Object>
- httpVersion <string>
- httpVersionMajor <integer>
- httpVersionMinor <integer>
- statusCode <integer>
- statusMessage <string>
- headers <Object>
- rawHeaders <string[]>

서버가 1xx 중간 응답(101 업그레이드 제외)을 보낼 때 발생합니다. 이 이벤트의 리스너는 HTTP 버전, 상태 코드, 상태 메시지, 키-값 헤더 객체, 해당 값이 뒤따르는 원시 헤더 이름을 포함하는 배열을 포함하는 객체를 수신합니다.

ESMCJS

import { request } from 'node:http'

const options = {
  host: '127.0.0.1',
  port: 8080,
  path: '/length_request',
}

// 요청 생성
const req = request(options)
req.end()

req.on('information', info => {
  console.log(`메인 응답 전에 정보 수신: ${info.statusCode}`)
})

const http = require('node:http')

const options = {
  host: '127.0.0.1',
  port: 8080,
  path: '/length_request',
}

// 요청 생성
const req = http.request(options)
req.end()

req.on('information', info => {
  console.log(`메인 응답 전에 정보 수신: ${info.statusCode}`)
})

웹 소켓, 제자리 TLS 업그레이드 또는 HTTP 2.0과 같은 기존 HTTP 요청/응답 체인에서 벗어나기 때문에 101 업그레이드 상태는 이 이벤트를 발생시키지 않습니다. 101 업그레이드 알림을 받으려면 대신 'upgrade' 이벤트를 수신하십시오.

이벤트: `'response'`

추가됨: v0.1.0

response <http.IncomingMessage>

이 요청에 대한 응답이 수신되면 발생합니다. 이 이벤트는 한 번만 발생합니다.

이벤트: `'socket'`

추가됨: v0.5.3

socket <stream.Duplex>

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 이벤트는 <net.Socket> 클래스의 인스턴스인 <stream.Duplex> 의 하위 클래스를 전달받는 것이 보장됩니다.

이벤트: `'timeout'`

추가됨: v0.7.8

기본 소켓이 비활동으로 인해 시간 초과되면 발생합니다. 소켓이 유휴 상태였음을 알리는 것만 합니다. 요청은 수동으로 삭제해야 합니다.

참고: request.setTimeout().

이벤트: `'upgrade'`

추가됨: v0.1.94

서버가 업그레이드를 사용하여 요청에 응답할 때마다 발생합니다. 이 이벤트를 수신 대기하지 않고 응답 상태 코드가 101 Switching Protocols인 경우 업그레이드 헤더를 수신하는 클라이언트의 연결이 끊어집니다.

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 이벤트는 <net.Socket> 클래스의 인스턴스인 <stream.Duplex> 의 하위 클래스를 전달받는 것이 보장됩니다.

'upgrade' 이벤트를 수신 대기하는 방법을 보여주는 클라이언트 서버 쌍입니다.

ESMCJS

import http from 'node:http'
import process from 'node:process'

// HTTP 서버 생성
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
server.on('upgrade', (req, socket, head) => {
  socket.write(
    'HTTP/1.1 101 Web Socket Protocol Handshake\r\n' + 'Upgrade: WebSocket\r\n' + 'Connection: Upgrade\r\n' + '\r\n'
  )

  socket.pipe(socket) // 에코 백
})

// 서버가 실행 중일 때
server.listen(1337, '127.0.0.1', () => {
  // 요청 생성
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      Connection: 'Upgrade',
      Upgrade: 'websocket',
    },
  }

  const req = http.request(options)
  req.end()

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!')
    socket.end()
    process.exit(0)
  })
})

const http = require('node:http')

// HTTP 서버 생성
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
server.on('upgrade', (req, socket, head) => {
  socket.write(
    'HTTP/1.1 101 Web Socket Protocol Handshake\r\n' + 'Upgrade: WebSocket\r\n' + 'Connection: Upgrade\r\n' + '\r\n'
  )

  socket.pipe(socket) // 에코 백
})

// 서버가 실행 중일 때
server.listen(1337, '127.0.0.1', () => {
  // 요청 생성
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      Connection: 'Upgrade',
      Upgrade: 'websocket',
    },
  }

  const req = http.request(options)
  req.end()

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!')
    socket.end()
    process.exit(0)
  })
})

`request.abort()`

추가됨: v0.3.8

사용 중단됨: v14.1.0, v13.14.0

[안정성: 0 - 사용 중단됨]

안정성: 0 안정성: 0 - 사용 중단됨: request.destroy()를 대신 사용하십시오.

요청을 중단하도록 표시합니다. 이 함수를 호출하면 응답의 나머지 데이터가 삭제되고 소켓이 파괴됩니다.

`request.aborted`

[이력]

버전	변경 사항
v17.0.0, v16.12.0	사용 중단됨: v17.0.0, v16.12.0
v11.0.0	`aborted` 속성이 더 이상 타임스탬프 숫자가 아닙니다.
v0.11.14	추가됨: v0.11.14

[안정성: 0 - 사용 중단됨]

안정성: 0 안정성: 0 - 사용 중단됨. request.destroyed를 대신 확인하십시오.

<boolean>

request.aborted 속성은 요청이 중단된 경우 true가 됩니다.

`request.connection`

추가됨: v0.3.0

사용 중단됨: v13.0.0

[안정성: 0 - 사용 중단됨]

안정성: 0 안정성: 0 - 사용 중단됨. request.socket을 사용하십시오.

<stream.Duplex>

request.socket을 참조하십시오.

`request.cork()`

추가됨: v13.2.0, v12.16.0

writable.cork()을 참조하십시오.

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

[이력]

버전	변경 사항
v15.0.0	`data` 매개변수는 이제 `Uint8Array`가 될 수 있습니다.
v10.0.0	이 메서드는 이제 `ClientRequest`에 대한 참조를 반환합니다.
v0.1.90	추가됨: v0.1.90

data <string> | <Buffer> | <Uint8Array>
encoding <string>
callback <Function>
반환값: <this>

요청 전송을 완료합니다. 본문의 일부가 전송되지 않은 경우 스트림에 플러시합니다. 요청이 청크화된 경우 종료 '0\r\n\r\n'을 보냅니다.

data가 지정된 경우 request.write(data, encoding)을 호출한 다음 request.end(callback)을 호출하는 것과 같습니다.

callback이 지정된 경우 요청 스트림이 완료되면 호출됩니다.

`request.destroy([error])`

[히스토리]

버전	변경 사항
v14.5.0	다른 Readable 스트림과의 일관성을 위해 함수가 `this`를 반환합니다.
v0.3.0	추가됨: v0.3.0

error <Error> 선택 사항, 'error' 이벤트와 함께 방출할 오류.
반환값: <this>

요청을 파괴합니다. 선택적으로 'error' 이벤트를 방출하고 'close' 이벤트를 방출합니다. 이 함수를 호출하면 응답의 나머지 데이터가 삭제되고 소켓이 파괴됩니다.

자세한 내용은 writable.destroy()를 참조하십시오.

`request.destroyed`

추가됨: v14.1.0, v13.14.0

<boolean>

request.destroy()가 호출된 후 true입니다.

자세한 내용은 writable.destroyed를 참조하십시오.

`request.finished`

추가됨: v0.0.1

더 이상 사용되지 않음: v13.4.0, v12.16.0

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 0 안정성: 0 - 더 이상 사용되지 않습니다. request.writableEnded를 사용하십시오.

<boolean>

request.end()가 호출된 경우 request.finished 속성은 true입니다. http.get()을 통해 요청이 시작된 경우 request.end()가 자동으로 호출됩니다.

`request.flushHeaders()`

추가됨: v1.6.0

요청 헤더를 플러시합니다.

효율성을 위해 Node.js는 일반적으로 request.end()가 호출되거나 첫 번째 요청 데이터 청크가 작성될 때까지 요청 헤더를 버퍼링합니다. 그런 다음 요청 헤더와 데이터를 단일 TCP 패킷으로 압축하려고 시도합니다.

이는 일반적으로 바람직하지만(TCP 왕복을 절약함), 첫 번째 데이터가 훨씬 나중에 전송될 때까지 전송되지 않는 경우에는 그렇지 않습니다. request.flushHeaders()는 최적화를 우회하고 요청을 시작합니다.

`request.getHeader(name)`

추가됨: v1.6.0

name <string>
반환값: <any>

요청의 헤더를 읽습니다. 이름은 대소문자를 구분하지 않습니다. 반환 값의 유형은 request.setHeader()에 제공된 인수에 따라 달라집니다.

request.setHeader('content-type', 'text/html')
request.setHeader('Content-Length', Buffer.byteLength(body))
request.setHeader('Cookie', ['type=ninja', 'language=javascript'])
const contentType = request.getHeader('Content-Type')
// 'contentType'은 'text/html'입니다.
const contentLength = request.getHeader('Content-Length')
// 'contentLength'는 숫자 유형입니다.
const cookie = request.getHeader('Cookie')
// 'cookie'는 string[] 유형입니다.

`request.getHeaderNames()`

추가됨: v7.7.0

반환값: <string[]>

현재 발신 헤더의 고유 이름을 포함하는 배열을 반환합니다. 모든 헤더 이름은 소문자입니다.

request.setHeader('Foo', 'bar')
request.setHeader('Cookie', ['foo=bar', 'bar=baz'])

const headerNames = request.getHeaderNames()
// headerNames === ['foo', 'cookie']

`request.getHeaders()`

추가됨: v7.7.0

반환값: <Object>

현재 발신 헤더의 얕은 복사본을 반환합니다. 얕은 복사본이 사용되므로 다양한 헤더 관련 http 모듈 메서드를 추가로 호출하지 않고도 배열 값을 변경할 수 있습니다. 반환된 객체의 키는 헤더 이름이고 값은 해당 헤더 값입니다. 모든 헤더 이름은 소문자입니다.

request.getHeaders() 메서드가 반환하는 객체는 JavaScript Object에서 프로토타입으로 상속되지 않습니다. 즉, obj.toString(), obj.hasOwnProperty() 등의 일반적인 Object 메서드는 정의되지 않으며 작동하지 않습니다.

request.setHeader('Foo', 'bar')
request.setHeader('Cookie', ['foo=bar', 'bar=baz'])

const headers = request.getHeaders()
// headers === { foo: 'bar', 'cookie': ['foo=bar', 'bar=baz'] }

`request.getRawHeaderNames()`

추가됨: v15.13.0, v14.17.0

반환값: <string[]>

현재 전송 중인 원시 헤더의 고유한 이름을 포함하는 배열을 반환합니다. 헤더 이름은 설정된 정확한 대소문자를 유지하여 반환됩니다.

request.setHeader('Foo', 'bar')
request.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headerNames = request.getRawHeaderNames()
// headerNames === ['Foo', 'Set-Cookie']

`request.hasHeader(name)`

추가됨: v7.7.0

name <string>
반환값: <boolean>

name으로 식별되는 헤더가 현재 전송 헤더에 설정되어 있는 경우 true를 반환합니다. 헤더 이름 일치는 대소문자를 구분하지 않습니다.

const hasContentType = request.hasHeader('content-type')

`request.maxHeadersCount`

<number> 기본값: 2000

최대 응답 헤더 수를 제한합니다. 0으로 설정하면 제한이 적용되지 않습니다.

`request.path`

추가됨: v0.4.0

<string> 요청 경로.

`request.method`

추가됨: v0.1.97

<string> 요청 메서드.

`request.host`

추가됨: v14.5.0, v12.19.0

<string> 요청 호스트.

`request.protocol`

추가됨: v14.5.0, v12.19.0

<string> 요청 프로토콜.

`request.removeHeader(name)`

추가됨: v1.6.0

name <string>

헤더 객체에 이미 정의된 헤더를 제거합니다.

request.removeHeader('Content-Type')

`request.reusedSocket`

추가됨: v13.0.0, v12.16.0

<boolean> 요청이 재사용된 소켓을 통해 전송되었는지 여부

keep-alive가 활성화된 에이전트를 통해 요청을 전송할 때 기본 소켓이 재사용될 수 있습니다. 하지만 서버가 적절하지 않은 시점에 연결을 끊으면 클라이언트는 'ECONNRESET' 오류가 발생할 수 있습니다.

ESMCJS

import http from 'node:http'

// 서버는 기본적으로 5초의 keep-alive 제한 시간을 갖습니다.
http
  .createServer((req, res) => {
    res.write('hello\n')
    res.end()
  })
  .listen(3000)

setInterval(() => {
  // keep-alive 에이전트 적용
  http.get('http://localhost:3000', { agent }, res => {
    res.on('data', data => {
      // 아무것도 하지 않음
    })
  })
}, 5000) // 5초 간격으로 요청을 보내므로 유휴 제한 시간에 쉽게 도달할 수 있습니다.

const http = require('node:http')

// 서버는 기본적으로 5초의 keep-alive 제한 시간을 갖습니다.
http
  .createServer((req, res) => {
    res.write('hello\n')
    res.end()
  })
  .listen(3000)

setInterval(() => {
  // keep-alive 에이전트 적용
  http.get('http://localhost:3000', { agent }, res => {
    res.on('data', data => {
      // 아무것도 하지 않음
    })
  })
}, 5000) // 5초 간격으로 요청을 보내므로 유휴 제한 시간에 쉽게 도달할 수 있습니다.

요청이 소켓을 재사용했는지 여부를 표시함으로써, 이를 기반으로 자동 오류 재시도를 수행할 수 있습니다.

ESMCJS

import http from 'node:http'
const agent = new http.Agent({ keepAlive: true })

function retriableRequest() {
  const req = http
    .get('http://localhost:3000', { agent }, res => {
      // ...
    })
    .on('error', err => {
      // 재시도가 필요한지 확인
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest()
      }
    })
}

retriableRequest()

const http = require('node:http')
const agent = new http.Agent({ keepAlive: true })

function retriableRequest() {
  const req = http
    .get('http://localhost:3000', { agent }, res => {
      // ...
    })
    .on('error', err => {
      // 재시도가 필요한지 확인
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest()
      }
    })
}

retriableRequest()

`request.setHeader(name, value)`

추가됨: v1.6.0

name <string>
value <any>

헤더 객체에 대한 단일 헤더 값을 설정합니다. 이미 전송할 헤더에 이 헤더가 존재하는 경우 해당 값이 바뀝니다. 같은 이름을 가진 여러 헤더를 보내려면 문자열 배열을 사용하세요. 문자열이 아닌 값은 수정 없이 저장됩니다. 따라서 request.getHeader()는 문자열이 아닌 값을 반환할 수 있습니다. 그러나 문자열이 아닌 값은 네트워크 전송을 위해 문자열로 변환됩니다.

request.setHeader('Content-Type', 'application/json')

또는

request.setHeader('Cookie', ['type=ninja', 'language=javascript'])

값이 문자열인 경우 latin1 인코딩 외부의 문자가 포함되어 있으면 예외가 발생합니다.

값에 UTF-8 문자를 전달해야 하는 경우 RFC 8187 표준을 사용하여 값을 인코딩하세요.

const filename = 'Rock 🎵.txt'
request.setHeader('Content-Disposition', `attachment; filename*=utf-8''${encodeURIComponent(filename)}`)

`request.setNoDelay([noDelay])`

추가됨: v0.5.9

noDelay <boolean>

이 요청에 소켓이 할당되고 연결되면 socket.setNoDelay()가 호출됩니다.

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

추가됨: v0.5.9

enable <boolean>
initialDelay <number>

이 요청에 소켓이 할당되고 연결되면 socket.setKeepAlive()가 호출됩니다.

`request.setTimeout(timeout[, callback])`

[히스토리]

버전	변경 사항
v9.0.0	소켓이 연결될 때만 일관되게 소켓 제한 시간을 설정합니다.
v0.5.9	추가됨: v0.5.9

timeout <number> 요청 제한 시간 전까지의 밀리초.
callback <Function> 제한 시간이 발생할 때 호출되는 선택적 함수. 'timeout' 이벤트에 바인딩하는 것과 같습니다.
반환값: <http.ClientRequest>

소켓이 이 요청에 할당되고 연결되면 socket.setTimeout()이 호출됩니다.

`request.socket`

추가됨: v0.3.0

<stream.Duplex>

기본 소켓에 대한 참조입니다. 일반적으로 사용자는 이 속성에 액세스할 필요가 없습니다. 특히, 프로토콜 파서가 소켓에 연결되는 방식 때문에 소켓은 'readable' 이벤트를 방출하지 않습니다.

ESMCJS

import http from 'node:http'
const options = {
  host: 'www.google.com',
}
const req = http.get(options)
req.end()
req.once('response', res => {
  const ip = req.socket.localAddress
  const port = req.socket.localPort
  console.log(`Your IP address is ${ip} and your source port is ${port}.`)
  // 응답 객체 사용
})

const http = require('node:http')
const options = {
  host: 'www.google.com',
}
const req = http.get(options)
req.end()
req.once('response', res => {
  const ip = req.socket.localAddress
  const port = req.socket.localPort
  console.log(`Your IP address is ${ip} and your source port is ${port}.`)
  // 응답 객체 사용
})

사용자가 <net.Socket>가 아닌 다른 소켓 유형을 지정하지 않는 한, 이 속성은 <net.Socket> 클래스의 인스턴스인 <stream.Duplex>의 하위 클래스임이 보장됩니다.

`request.uncork()`

추가됨: v13.2.0, v12.16.0

writable.uncork() 참조.

`request.writableEnded`

추가됨: v12.9.0

<boolean>

request.end()가 호출된 후 true가 됩니다. 이 속성은 데이터가 플러시되었는지 여부를 나타내지 않습니다. 이를 위해 request.writableFinished를 대신 사용하십시오.

`request.writableFinished`

추가됨: v12.7.0

<boolean>

'finish' 이벤트가 방출되기 직전에 모든 데이터가 기본 시스템에 플러시된 경우 true입니다.

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

[히스토리]

버전	변경 사항
v15.0.0	`chunk` 매개변수가 이제 `Uint8Array`가 될 수 있습니다.
v0.1.29	추가됨: v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string>
callback <Function>
반환값: <boolean>

본문의 청크를 전송합니다. 이 메서드는 여러 번 호출될 수 있습니다. Content-Length가 설정되지 않으면 데이터는 서버가 데이터가 끝나는 시점을 알 수 있도록 HTTP 청크 전송 인코딩으로 자동으로 인코딩됩니다. Transfer-Encoding: chunked 헤더가 추가됩니다. 요청 전송을 완료하려면 request.end()를 호출해야 합니다.

encoding 인수는 선택 사항이며 chunk가 문자열일 때만 적용됩니다. 기본값은 'utf8'입니다.

callback 인수는 선택 사항이며 이 데이터 청크가 플러시될 때 호출되지만, 청크가 비어 있지 않은 경우에만 호출됩니다.

전체 데이터가 커널 버퍼에 성공적으로 플러시된 경우 true를 반환합니다. 데이터의 전부 또는 일부가 사용자 메모리에 큐에 들어간 경우 false를 반환합니다. 버퍼가 다시 사용 가능해지면 'drain'이 방출됩니다.

write 함수가 빈 문자열이나 버퍼로 호출되면 아무 작업도 하지 않고 더 많은 입력을 기다립니다.

클래스: `http.Server`

추가됨: v0.1.17

상속: <net.Server>

이벤트: `'checkContinue'`

추가됨: v0.3.0

request <http.IncomingMessage>
response <http.ServerResponse>

HTTP Expect: 100-continue가 포함된 요청이 수신될 때마다 발생합니다. 이 이벤트를 수신 대기하지 않으면 서버는 적절히 100 Continue로 자동 응답합니다.

이 이벤트를 처리하려면 클라이언트가 요청 본문을 계속 전송해야 하는 경우 response.writeContinue()를 호출하거나, 클라이언트가 요청 본문을 전송하지 않아야 하는 경우 적절한 HTTP 응답(예: 400 잘못된 요청)을 생성해야 합니다.

이 이벤트가 발생하고 처리되면 'request' 이벤트는 발생하지 않습니다.

이벤트: `'checkExpectation'`

추가됨: v5.5.0

request <http.IncomingMessage>
response <http.ServerResponse>

값이 100-continue가 아닌 HTTP Expect 헤더가 포함된 요청이 수신될 때마다 발생합니다. 이 이벤트를 수신 대기하지 않으면 서버는 적절히 417 Expectation Failed로 자동 응답합니다.

이 이벤트가 발생하고 처리되면 'request' 이벤트는 발생하지 않습니다.

이벤트: `'clientError'`

[히스토리]

버전	변경 사항
v12.0.0	HPE_HEADER_OVERFLOW 오류가 발생하면 기본 동작은 431 Request Header Fields Too Large를 반환합니다.
v9.4.0	`rawPacket`은 방금 파싱된 현재 버퍼입니다. `'clientError'` 이벤트의 오류 객체에 이 버퍼를 추가하면 개발자가 손상된 패킷을 로깅할 수 있습니다.
v6.0.0	`'clientError'`에 대한 리스너가 연결되어 있으면 `socket`에 대해 `.destroy()`를 호출하는 기본 동작이 더 이상 수행되지 않습니다.
v0.1.94	추가됨: v0.1.94

exception <Error>
socket <stream.Duplex>

클라이언트 연결이 'error' 이벤트를 발생시키면 여기로 전달됩니다. 이 이벤트의 리스너는 기본 소켓을 닫거나 파괴할 책임이 있습니다. 예를 들어, 연결을 갑자기 끊는 대신 사용자 지정 HTTP 응답으로 소켓을 더 우아하게 닫을 수 있습니다. 리스너가 끝나기 전에 소켓을 반드시 닫거나 파괴해야 합니다.

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 이벤트에는 <net.Socket> 클래스의 하위 클래스인 <stream.Duplex>의 인스턴스가 전달됩니다.

기본 동작은 HTTP '400 잘못된 요청' 또는 HPE_HEADER_OVERFLOW 오류의 경우 HTTP '431 Request Header Fields Too Large'로 소켓을 닫으려고 시도하는 것입니다. 소켓을 쓸 수 없거나 현재 연결된 http.ServerResponse의 헤더가 전송된 경우 즉시 파괴됩니다.

socket은 오류의 원인이 된 net.Socket 객체입니다.

ESMCJS

import http from 'node:http'

const server = http.createServer((req, res) => {
  res.end()
})
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})
server.listen(8000)

const http = require('node:http')

const server = http.createServer((req, res) => {
  res.end()
})
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})
server.listen(8000)

'clientError' 이벤트가 발생하면 request 또는 response 객체가 없으므로 응답 헤더와 페이로드를 포함한 전송되는 HTTP 응답은 반드시 socket 객체에 직접 작성해야 합니다. 응답이 올바르게 형식이 지정된 HTTP 응답 메시지인지 확인해야 합니다.

err은 두 개의 추가 열이 있는 Error의 인스턴스입니다.

bytesParsed: Node.js가 올바르게 파싱했을 수 있는 요청 패킷의 바이트 수;
rawPacket: 현재 요청의 원시 패킷.

경우에 따라 ECONNRESET 오류와 같이 클라이언트가 이미 응답을 받았거나 소켓이 이미 파괴되었을 수 있습니다. 소켓에 데이터를 보내려고 하기 전에 소켓을 계속 쓸 수 있는지 확인하는 것이 좋습니다.

server.on('clientError', (err, socket) => {
  if (err.code === 'ECONNRESET' || !socket.writable) {
    return
  }

  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})

이벤트: `'close'`

추가됨: v0.1.4

서버가 닫힐 때 발생합니다.

이벤트: `'connect'`

추가됨: v0.7.0

request <http.IncomingMessage> 'request' 이벤트에서와 같이 HTTP 요청에 대한 인수
socket <stream.Duplex> 서버와 클라이언트 간의 네트워크 소켓
head <Buffer> 터널링 스트림의 첫 번째 패킷(비어 있을 수 있음)

클라이언트가 HTTP CONNECT 메서드를 요청할 때마다 발생합니다. 이 이벤트를 수신 대기하지 않으면 CONNECT 메서드를 요청하는 클라이언트의 연결이 닫힙니다.

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 이벤트에는 <net.Socket> 클래스의 인스턴스인 <stream.Duplex>의 하위 클래스가 전달됩니다.

이 이벤트가 발생한 후에는 요청의 소켓에 'data' 이벤트 리스너가 없으므로 해당 소켓에서 서버로 보낸 데이터를 처리하려면 바인딩해야 합니다.

이벤트: `'connection'`

추가됨: v0.1.0

socket <stream.Duplex>

새 TCP 스트림이 설정될 때 발생합니다. socket은 일반적으로 net.Socket 유형의 객체입니다. 일반적으로 사용자는 이 이벤트에 액세스할 필요가 없습니다. 특히, 프로토콜 파서가 소켓에 연결되는 방식 때문에 소켓은 'readable' 이벤트를 발생시키지 않습니다. socket은 request.socket에서도 액세스할 수 있습니다.

이 이벤트는 사용자가 HTTP 서버에 연결을 삽입하기 위해 명시적으로 발생시킬 수도 있습니다. 이 경우 모든 Duplex 스트림을 전달할 수 있습니다.

socket.setTimeout()이 여기서 호출되면 소켓이 요청을 처리한 후( server.keepAliveTimeout이 0이 아닌 경우) 타임아웃이 server.keepAliveTimeout으로 대체됩니다.

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 이벤트에는 <net.Socket> 클래스의 인스턴스인 <stream.Duplex>의 하위 클래스가 전달됩니다.

이벤트: `'dropRequest'`

추가됨: v18.7.0, v16.17.0

request <http.IncomingMessage> 'request' 이벤트에서와 같이 HTTP 요청에 대한 인수
socket <stream.Duplex> 서버와 클라이언트 간의 네트워크 소켓

소켓의 요청 수가 server.maxRequestsPerSocket 임계값에 도달하면 서버는 새 요청을 삭제하고 대신 'dropRequest' 이벤트를 방출한 다음 클라이언트에 503을 전송합니다.

이벤트: `'request'`

추가됨: v0.1.0

request <http.IncomingMessage>
response <http.ServerResponse>

요청이 있을 때마다 방출됩니다. HTTP Keep-Alive 연결의 경우 연결당 여러 개의 요청이 있을 수 있습니다.

이벤트: `'upgrade'`

[히스토리]

버전	변경 사항
v10.0.0	이 이벤트를 수신하지 않는다고 해서 클라이언트가 업그레이드 헤더를 보내는 경우 소켓이 더 이상 파괴되지 않습니다.
v0.1.94	추가됨: v0.1.94

request <http.IncomingMessage> 'request' 이벤트에서와 같이 HTTP 요청에 대한 인수
socket <stream.Duplex> 서버와 클라이언트 간의 네트워크 소켓
head <Buffer> 업그레이드된 스트림의 첫 번째 패킷(비어 있을 수 있음)

클라이언트가 HTTP 업그레이드를 요청할 때마다 방출됩니다. 이 이벤트를 수신하는 것은 선택 사항이며 클라이언트는 프로토콜 변경을 고집할 수 없습니다.

이 이벤트가 방출된 후에는 요청의 소켓에 'data' 이벤트 리스너가 없으므로 해당 소켓에서 서버로 전송된 데이터를 처리하려면 바인딩해야 합니다.

사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한, 이 이벤트에는 <net.Socket> 클래스의 인스턴스인 <stream.Duplex>의 하위 클래스가 전달됩니다.

`server.close([callback])`

[히스토리]

버전	변경 사항
v19.0.0	메서드는 반환하기 전에 유휴 연결을 닫습니다.
v0.1.90	추가됨: v0.1.90

callback <함수>

서버가 새 연결을 수락하지 못하도록 중지하고, 요청을 보내거나 응답을 기다리고 있지 않은 이 서버에 연결된 모든 연결을 닫습니다. net.Server.close()를 참조하십시오.

const http = require('node:http')

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)
// 10초 후 서버 닫기
setTimeout(() => {
  server.close(() => {
    console.log('8000 포트의 서버가 성공적으로 닫혔습니다')
  })
}, 10000)

`server.closeAllConnections()`

추가됨: v18.2.0

요청을 보내거나 응답을 기다리고 있는 활성 연결을 포함하여 이 서버에 연결된 모든 설정된 HTTP(S) 연결을 닫습니다. 이것은 WebSocket 또는 HTTP/2와 같은 다른 프로토콜로 업그레이드된 소켓을 파괴하지 않습니다.

const http = require('node:http')

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)
// 10초 후 서버 닫기
setTimeout(() => {
  server.close(() => {
    console.log('8000 포트의 서버가 성공적으로 닫혔습니다')
  })
  // 모든 연결을 닫아 서버가 성공적으로 닫히도록 합니다.
  server.closeAllConnections()
}, 10000)

`server.closeIdleConnections()`

추가됨: v18.2.0

요청을 보내거나 응답을 기다리고 있지 않은 이 서버에 연결된 모든 연결을 닫습니다.

const http = require('node:http')

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)
// 10초 후 서버 닫기
setTimeout(() => {
  server.close(() => {
    console.log('8000 포트의 서버가 성공적으로 닫혔습니다')
  })
  // keep-alive 연결과 같은 유휴 연결을 닫습니다. 나머지 활성 연결이 종료되면 서버가 닫힙니다.
  server.closeIdleConnections()
}, 10000)

`server.headersTimeout`

[히스토리]

버전	변경 사항
v19.4.0, v18.14.0	기본값이 이제 60000(60초) 또는 `requestTimeout` 중 더 작은 값으로 설정됩니다.
v11.3.0, v10.14.0	추가됨: v11.3.0, v10.14.0

<숫자> 기본값: server.requestTimeout 또는 60000 중 더 작은 값.

파서가 완전한 HTTP 헤더를 수신할 때까지 기다리는 시간 제한을 설정합니다.

시간 초과가 만료되면 서버는 요청을 요청 리스너에 전달하지 않고 408 상태로 응답한 다음 연결을 닫습니다.

서버가 리버스 프록시 없이 배포된 경우 잠재적인 서비스 거부 공격으로부터 보호하기 위해 0이 아닌 값(예: 120초)으로 설정해야 합니다.

`server.listen()`

연결을 수신 대기하는 HTTP 서버를 시작합니다. 이 메서드는 net.Server의 server.listen()과 동일합니다.

`server.listening`

추가됨: v5.7.0

<불리언> 서버가 연결을 수신 대기 중인지 여부를 나타냅니다.

`server.maxHeadersCount`

추가됨: v0.7.0

<숫자> 기본값: 2000

최대 수신 헤더 수를 제한합니다. 0으로 설정하면 제한이 적용되지 않습니다.

`server.requestTimeout`

[히스토리]

버전	변경 사항
v18.0.0	기본 요청 시간 초과가 시간 초과 없음에서 300초(5분)로 변경되었습니다.
v14.11.0	추가됨: v14.11.0

<숫자> 기본값: 300000

클라이언트로부터 전체 요청을 수신하는 데 대한 시간 초과 값을 밀리초 단위로 설정합니다.

시간 초과가 만료되면 서버는 요청을 요청 리스너에 전달하지 않고 408 상태로 응답한 다음 연결을 닫습니다.

서버가 리버스 프록시 없이 배포된 경우 잠재적인 서비스 거부 공격으로부터 보호하기 위해 0이 아닌 값(예: 120초)으로 설정해야 합니다.

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

[히스토리]

버전	변경 사항
v13.0.0	기본 제한 시간이 120초에서 0(제한 시간 없음)으로 변경되었습니다.
v0.9.12	추가됨: v0.9.12

msecs <숫자> 기본값: 0 (제한 시간 없음)
callback <함수>
반환값: <http.Server>

소켓에 대한 제한 시간 값을 설정하고, 제한 시간이 발생하면 Server 객체에서 'timeout' 이벤트를 방출하여 소켓을 인수로 전달합니다.

Server 객체에 'timeout' 이벤트 리스너가 있는 경우, 제한 시간이 초과된 소켓을 인수로 하여 호출됩니다.

기본적으로 Server는 소켓의 제한 시간을 설정하지 않습니다. 그러나 Server의 'timeout' 이벤트에 콜백이 할당되면 제한 시간을 명시적으로 처리해야 합니다.

`server.maxRequestsPerSocket`

추가됨: v16.10.0

<숫자> 소켓당 요청 수. 기본값: 0 (제한 없음)

keep-alive 연결을 닫기 전에 소켓이 처리할 수 있는 최대 요청 수입니다.

0 값은 제한을 비활성화합니다.

제한에 도달하면 Connection 헤더 값을 close로 설정하지만, 실제로 연결을 닫지는 않습니다. 제한에 도달한 후 전송된 후속 요청은 503 Service Unavailable 응답을 받습니다.

`server.timeout`

[히스토리]

버전	변경 사항
v13.0.0	기본 제한 시간이 120초에서 0(제한 시간 없음)으로 변경되었습니다.
v0.9.12	추가됨: v0.9.12

<숫자> 밀리초 단위의 제한 시간. 기본값: 0 (제한 시간 없음)

소켓이 제한 시간이 초과된 것으로 간주되기 전의 비활성 시간(밀리초).

0 값은 들어오는 연결에 대한 제한 시간 동작을 비활성화합니다.

소켓 제한 시간 로직은 연결 시 설정되므로, 이 값을 변경해도 서버에 대한 기존 연결에는 영향을 미치지 않고 새로운 연결에만 영향을 미칩니다.

`server.keepAliveTimeout`

추가됨: v8.0.0

<number> 밀리초 단위의 제한 시간. 기본값: 5000 (5초).

마지막 응답 쓰기를 완료한 후 서버가 추가로 들어오는 데이터를 기다리는 비활동 시간(밀리초)입니다. 소켓이 파괴되기 전입니다. keep-alive 제한 시간이 발생하기 전에 서버가 새 데이터를 수신하면 일반 비활동 시간(즉, server.timeout)이 재설정됩니다.

0 값은 들어오는 연결에 대한 keep-alive 제한 시간 동작을 비활성화합니다. 0 값은 keep-alive 제한 시간이 없던 8.0.0 이전 버전의 Node.js와 유사하게 http 서버가 동작하게 합니다.

소켓 제한 시간 로직은 연결 시 설정되므로 이 값을 변경해도 서버에 대한 새 연결에만 영향을 미치고 기존 연결에는 영향을 미치지 않습니다.

`server[Symbol.asyncDispose]()`

추가됨: v20.4.0

[Stable: 1 - Experimental]

Stable: 1 Stability: 1 - Experimental

server.close()를 호출하고 서버가 닫히면 완료되는 Promise를 반환합니다.

클래스: `http.ServerResponse`

추가됨: v0.1.17

상속: <http.OutgoingMessage>

이 객체는 사용자가 아니라 HTTP 서버 내부에서 생성됩니다. 'request' 이벤트의 두 번째 매개변수로 전달됩니다.

이벤트: `'close'`

추가됨: v0.6.7

응답이 완료되었거나 기본 연결이 응답 완료 전에 조기에 종료되었음을 나타냅니다.

이벤트: `'finish'`

추가됨: v0.3.6

응답이 전송되었을 때 발생합니다. 더 구체적으로, 이 이벤트는 응답 헤더와 본문의 마지막 세그먼트가 네트워크를 통한 전송을 위해 운영 체제에 전달되었을 때 발생합니다. 클라이언트가 아직 아무것도 수신하지 않았음을 의미하지는 않습니다.

`response.addTrailers(headers)`

추가됨: v0.3.0

headers <Object>

이 메서드는 응답에 HTTP 후행 헤더(메시지 끝에 있는 헤더)를 추가합니다.

후행 헤더는 응답에 청크 인코딩이 사용된 경우에 만 방출됩니다. 그렇지 않은 경우(예: 요청이 HTTP/1.0인 경우)는 자동으로 삭제됩니다.

HTTP는 후행 헤더를 방출하려면 Trailer 헤더를 보내야 하며, 값에는 헤더 필드 목록이 포함되어야 합니다. 예:

response.writeHead(200, { 'Content-Type': 'text/plain', Trailer: 'Content-MD5' })
response.write(fileData)
response.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' })
response.end()

잘못된 문자가 포함된 헤더 필드 이름이나 값을 설정하려고 하면 TypeError가 발생합니다.

`response.connection`

추가됨: v0.3.0

더 이상 사용되지 않음: v13.0.0

[Stable: 0 - 더 이상 사용되지 않음]

Stable: 0 Stability: 0 - 더 이상 사용되지 않음. response.socket을 사용하십시오.

<stream.Duplex>

response.socket을 참조하십시오.

`response.cork()`

추가됨: v13.2.0, v12.16.0

writable.cork()을 참조하십시오.

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

[히스토리]

버전	변경 사항
v15.0.0	`data` 매개변수는 이제 `Uint8Array`가 될 수 있습니다.
v10.0.0	이 메서드는 이제 `ServerResponse`에 대한 참조를 반환합니다.
v0.1.90	추가됨: v0.1.90

data <string> | <Buffer> | <Uint8Array>
encoding <string>
callback <Function>
반환값: <this>

이 메서드는 서버에 응답 헤더와 본문이 모두 전송되었음을 알리고 서버는 이 메시지를 완료된 것으로 간주해야 합니다. response.end() 메서드는 각 응답에서 호출해야 합니다.

data가 지정되면 response.write(data, encoding)을 호출한 다음 response.end(callback)을 호출하는 것과 비슷한 효과를 냅니다.

callback이 지정되면 응답 스트림이 완료될 때 호출됩니다.

`response.finished`

추가됨: v0.0.2

더 이상 사용되지 않음: v13.4.0, v12.16.0

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 0 안정성: 0 - 더 이상 사용되지 않음. response.writableEnded를 사용하십시오.

<boolean>

response.finished 속성은 response.end()가 호출된 경우 true가 됩니다.

`response.flushHeaders()`

추가됨: v1.6.0

응답 헤더를 플러시합니다. request.flushHeaders()도 참조하십시오.

`response.getHeader(name)`

추가됨: v0.4.0

name <string>
반환값: <any>

클라이언트에게 아직 전송되지 않은, 이미 큐에 추가된 헤더를 읽어옵니다. 이름은 대소문자를 구분하지 않습니다. 반환 값의 형식은 response.setHeader()에 제공된 인수에 따라 달라집니다.

response.setHeader('Content-Type', 'text/html')
response.setHeader('Content-Length', Buffer.byteLength(body))
response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript'])
const contentType = response.getHeader('content-type')
// contentType은 'text/html'입니다.
const contentLength = response.getHeader('Content-Length')
// contentLength는 숫자형입니다.
const setCookie = response.getHeader('set-cookie')
// setCookie는 string[] 형식입니다.

`response.getHeaderNames()`

추가됨: v7.7.0

반환값: <string[]>

현재 나가는 헤더의 고유한 이름을 포함하는 배열을 반환합니다. 모든 헤더 이름은 소문자입니다.

response.setHeader('Foo', 'bar')
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headerNames = response.getHeaderNames()
// headerNames === ['foo', 'set-cookie']

`response.getHeaders()`

추가됨: v7.7.0

반환값: <Object>

현재 발신 헤더의 얕은 복사본을 반환합니다. 얕은 복사본이 사용되므로, 다양한 헤더 관련 http 모듈 메서드를 추가로 호출하지 않고도 배열 값을 변경할 수 있습니다. 반환된 객체의 키는 헤더 이름이고, 값은 해당 헤더 값입니다. 모든 헤더 이름은 소문자입니다.

response.getHeaders() 메서드가 반환하는 객체는 JavaScript Object에서 프로토타입으로 상속되지 않습니다. 즉, obj.toString(), obj.hasOwnProperty() 등의 일반적인 Object 메서드는 정의되지 않으며 작동하지 않습니다.

response.setHeader('Foo', 'bar')
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headers = response.getHeaders()
// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }

`response.hasHeader(name)`

추가됨: v7.7.0

name <string>
반환값: <boolean>

name으로 식별되는 헤더가 현재 발신 헤더에 설정되어 있는 경우 true를 반환합니다. 헤더 이름 일치는 대소문자를 구분하지 않습니다.

const hasContentType = response.hasHeader('content-type')

`response.headersSent`

추가됨: v0.9.3

<boolean>

불리언(읽기 전용). 헤더가 전송된 경우 true, 그렇지 않으면 false입니다.

`response.removeHeader(name)`

추가됨: v0.4.0

name <string>

암시적 전송을 위해 대기 중인 헤더를 제거합니다.

response.removeHeader('Content-Encoding')

`response.req`

추가됨: v15.7.0

<http.IncomingMessage>

원래 HTTP request 객체에 대한 참조입니다.

`response.sendDate`

추가됨: v0.7.5

<boolean>

true이면 Date 헤더가 응답에 아직 없을 경우 자동으로 생성되어 전송됩니다. 기본값은 true입니다.

테스트를 위해서만 비활성화해야 합니다. HTTP는 응답에서 Date 헤더를 요구합니다.

`response.setHeader(name, value)`

추가됨: v0.4.0

name <string>
value <any>
반환값: <http.ServerResponse>

응답 객체를 반환합니다.

암시적 헤더에 대한 단일 헤더 값을 설정합니다. 이 헤더가 이미 전송될 헤더에 존재하는 경우, 해당 값은 대체됩니다. 같은 이름의 여러 헤더를 보내려면 문자열 배열을 사용하십시오. 문자열이 아닌 값은 수정 없이 저장됩니다. 따라서 response.getHeader()는 문자열이 아닌 값을 반환할 수 있습니다. 그러나 문자열이 아닌 값은 네트워크 전송을 위해 문자열로 변환됩니다. 호출 체이닝을 사용할 수 있도록 동일한 응답 객체가 호출자에게 반환됩니다.

response.setHeader('Content-Type', 'text/html')

또는

response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript'])

잘못된 문자가 포함된 헤더 필드 이름이나 값을 설정하려고 하면 TypeError가 발생합니다.

헤더가 response.setHeader()를 사용하여 설정된 경우, response.writeHead()에 전달된 헤더와 병합되며, response.writeHead()에 전달된 헤더가 우선적으로 적용됩니다.

// content-type = text/plain을 반환합니다.
const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html')
  res.setHeader('X-Foo', 'bar')
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('ok')
})

response.writeHead() 메서드가 호출되고 이 메서드가 호출되지 않은 경우, 제공된 헤더 값을 내부적으로 캐싱하지 않고 네트워크 채널에 직접 기록하며, 헤더의 response.getHeader()는 예상 결과를 생성하지 않습니다. 향후 검색 및 수정 가능성이 있는 헤더의 점진적 채우기를 원하는 경우 response.writeHead() 대신 response.setHeader()를 사용하십시오.

`response.setTimeout(msecs[, callback])`

추가됨: v0.9.12

msecs <number>
callback <Function>
반환값: <http.ServerResponse>

Socket의 제한 시간 값을 msecs로 설정합니다. 콜백이 제공되면 응답 객체의 'timeout' 이벤트에 리스너로 추가됩니다.

요청, 응답 또는 서버에 'timeout' 리스너가 추가되지 않으면 소켓이 제한 시간이 초과되면 삭제됩니다. 요청, 응답 또는 서버의 'timeout' 이벤트에 핸들러가 할당되면 제한 시간이 초과된 소켓을 명시적으로 처리해야 합니다.

`response.socket`

추가됨: v0.3.0

<stream.Duplex>

기본 소켓에 대한 참조입니다. 일반적으로 사용자는 이 속성에 액세스할 필요가 없습니다. 특히, 프로토콜 파서가 소켓에 연결되는 방식 때문에 소켓은 'readable' 이벤트를 방출하지 않습니다. response.end() 후에는 속성이 null이 됩니다.

ESMCJS

import http from 'node:http'
const server = http
  .createServer((req, res) => {
    const ip = res.socket.remoteAddress
    const port = res.socket.remotePort
    res.end(`Your IP address is ${ip} and your source port is ${port}.`)
  })
  .listen(3000)

const http = require('node:http')
const server = http
  .createServer((req, res) => {
    const ip = res.socket.remoteAddress
    const port = res.socket.remotePort
    res.end(`Your IP address is ${ip} and your source port is ${port}.`)
  })
  .listen(3000)

이 속성은 사용자가 <net.Socket> 이외의 소켓 유형을 지정하지 않는 한 <net.Socket> 클래스의 인스턴스인 <stream.Duplex>의 하위 클래스임이 보장됩니다.

`response.statusCode`

추가됨: v0.4.0

<number> 기본값: 200

암시적 헤더를 사용하는 경우(response.writeHead()를 명시적으로 호출하지 않음), 이 속성은 헤더가 플러시될 때 클라이언트로 전송될 상태 코드를 제어합니다.

response.statusCode = 404

응답 헤더가 클라이언트로 전송된 후 이 속성은 전송된 상태 코드를 나타냅니다.

`response.statusMessage`

추가됨: v0.11.8

<string>

암시적 헤더를 사용할 때(명시적으로 response.writeHead()를 호출하지 않을 때), 이 속성은 헤더가 플러시될 때 클라이언트로 전송될 상태 메시지를 제어합니다. 이 값을 undefined로 두면 상태 코드의 표준 메시지가 사용됩니다.

response.statusMessage = 'Not found'

응답 헤더가 클라이언트로 전송된 후, 이 속성은 전송된 상태 메시지를 나타냅니다.

`response.strictContentLength`

추가됨: v18.10.0, v16.18.0

<boolean> 기본값: false

true로 설정하면 Node.js는 Content-Length 헤더 값과 바이트 단위 본문 크기가 같은지 확인합니다. Content-Length 헤더 값이 일치하지 않으면 code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'로 식별되는 Error가 발생합니다.

`response.uncork()`

추가됨: v13.2.0, v12.16.0

writable.uncork() 참조.

`response.writableEnded`

추가됨: v12.9.0

<boolean>

response.end()가 호출된 후 true입니다. 이 속성은 데이터가 플러시되었는지 여부를 나타내지 않습니다. 이를 위해 response.writableFinished를 사용하십시오.

`response.writableFinished`

추가됨: v12.7.0

<boolean>

'finish' 이벤트가 발생하기 직전에 모든 데이터가 기본 시스템으로 플러시된 경우 true입니다.

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

[이력]

버전	변경 사항
v15.0.0	`chunk` 매개변수는 이제 `Uint8Array`가 될 수 있습니다.
v0.1.29	추가됨: v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> 기본값: 'utf8'
callback <Function>
반환값: <boolean>

이 메서드가 호출되고 response.writeHead()가 호출되지 않은 경우 암시적 헤더 모드로 전환하고 암시적 헤더를 플러시합니다.

응답 본문의 청크를 전송합니다. 본문의 연속적인 부분을 제공하기 위해 이 메서드를 여러 번 호출할 수 있습니다.

createServer에서 rejectNonStandardBodyWrites가 true로 설정된 경우 요청 메서드 또는 응답 상태가 콘텐츠를 지원하지 않으면 본문에 쓰는 것이 허용되지 않습니다. HEAD 요청에 대한 본문에 쓰려고 하거나 204 또는 304 응답의 일부로 쓰려고 하면 ERR_HTTP_BODY_NOT_ALLOWED 코드가 있는 동기 Error가 발생합니다.

chunk는 문자열 또는 버퍼일 수 있습니다. chunk가 문자열이면 두 번째 매개변수는 바이트 스트림으로 인코딩하는 방법을 지정합니다. callback은 이 데이터 청크가 플러시될 때 호출됩니다.

이는 원시 HTTP 본문이며 사용될 수 있는 상위 수준의 다중 부분 본문 인코딩과는 아무런 관련이 없습니다.

response.write()가 처음 호출될 때 버퍼링된 헤더 정보와 본문의 첫 번째 청크를 클라이언트로 전송합니다. response.write()가 두 번째로 호출될 때 Node.js는 데이터가 스트리밍될 것으로 가정하고 새 데이터를 별도로 전송합니다. 즉, 응답은 본문의 첫 번째 청크까지 버퍼링됩니다.

전체 데이터가 커널 버퍼에 성공적으로 플러시된 경우 true를 반환합니다. 데이터의 전부 또는 일부가 사용자 메모리에 큐에 추가된 경우 false를 반환합니다. 버퍼가 다시 사용 가능해지면 'drain'이 방출됩니다.

`response.writeContinue()`

추가됨: v0.3.0

클라이언트에게 HTTP/1.1 100 Continue 메시지를 보내 요청 본문을 보낼 수 있음을 나타냅니다. Server의 'checkContinue' 이벤트를 참조하십시오.

`response.writeEarlyHints(hints[, callback])`

[히스토리]

버전	변경 사항
v18.11.0	hints를 객체로 전달할 수 있도록 허용
v18.11.0	추가됨: v18.11.0

hints <Object>
callback <Function>

Link 헤더와 함께 HTTP/1.1 103 Early Hints 메시지를 클라이언트에게 보내 사용자 에이전트가 연결된 리소스를 미리 로드/미리 연결할 수 있음을 나타냅니다. hints는 초기 힌트 메시지와 함께 전송할 헤더 값을 포함하는 객체입니다. 선택적 callback 인수는 응답 메시지가 작성되었을 때 호출됩니다.

예시

const earlyHintsLink = '</styles.css>; rel=preload; as=style'
response.writeEarlyHints({
  link: earlyHintsLink,
})

const earlyHintsLinks = ['</styles.css>; rel=preload; as=style', '</scripts.js>; rel=preload; as=script']
response.writeEarlyHints({
  link: earlyHintsLinks,
  'x-trace-id': 'id for diagnostics',
})

const earlyHintsCallback = () => console.log('early hints message sent')
response.writeEarlyHints(
  {
    link: earlyHintsLinks,
  },
  earlyHintsCallback
)

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

[히스토리]

버전	변경 사항
v14.14.0	헤더를 배열로 전달할 수 있도록 허용
v11.10.0, v10.17.0	`end()`와의 체이닝을 허용하도록 `writeHead()`에서 `this` 반환
v5.11.0, v4.4.5	`statusCode`가 `[100, 999]` 범위의 숫자가 아니면 `RangeError`가 발생
v0.1.30	추가됨: v0.1.30

statusCode <number>
statusMessage <string>
headers <Object> | <Array>
반환값: <http.ServerResponse>

요청에 응답 헤더를 보냅니다. 상태 코드는 404와 같은 3자리 HTTP 상태 코드입니다. 마지막 인수인 headers는 응답 헤더입니다. 선택적으로 두 번째 인수로 사람이 읽을 수 있는 statusMessage를 제공할 수 있습니다.

headers는 키와 값이 같은 목록에 있는 Array일 수 있습니다. 튜플 목록이 아닙니다. 따라서 짝수 오프셋은 키 값이고 홀수 오프셋은 연결된 값입니다. 배열은 request.rawHeaders와 같은 형식입니다.

ServerResponse에 대한 참조를 반환하므로 호출을 연결할 수 있습니다.

const body = 'hello world'
response
  .writeHead(200, {
    'Content-Length': Buffer.byteLength(body),
    'Content-Type': 'text/plain',
  })
  .end(body)

이 메서드는 메시지에서 한 번만 호출해야 하며 response.end()가 호출되기 전에 호출해야 합니다.

response.write() 또는 response.end()가 이 메서드를 호출하기 전에 호출되면 암시적/변경 가능한 헤더가 계산되고 이 함수를 호출합니다.

response.setHeader()를 사용하여 헤더가 설정된 경우 response.writeHead()에 전달된 헤더와 병합되며, response.writeHead()에 전달된 헤더가 우선합니다.

이 메서드가 호출되고 response.setHeader()가 호출되지 않은 경우 내부적으로 캐싱하지 않고 제공된 헤더 값을 네트워크 채널에 직접 작성하며, 헤더의 response.getHeader()는 예상 결과를 생성하지 않습니다. 향후 검색 및 수정 가능성이 있는 헤더의 점진적 채우기를 원하는 경우 대신 response.setHeader()를 사용하십시오.

// Returns content-type = text/plain
const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html')
  res.setHeader('X-Foo', 'bar')
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('ok')
})

Content-Length는 문자가 아닌 바이트 단위로 읽습니다. 본문의 길이를 바이트 단위로 확인하려면 Buffer.byteLength()를 사용하십시오. Node.js는 Content-Length와 전송된 본문의 길이가 같은지 확인합니다.

잘못된 문자가 포함된 헤더 필드 이름이나 값을 설정하려고 하면 [Error][]가 발생합니다.

`response.writeProcessing()`

추가됨: v10.0.0

클라이언트에게 HTTP/1.1 102 Processing 메시지를 보내 요청 본문을 보낼 수 있음을 알립니다.

클래스: `http.IncomingMessage`

[히스토리]

버전	변경 사항
v15.5.0	수신 데이터가 소비된 후 `destroyed` 값이 `true`를 반환합니다.
v13.1.0, v12.16.0	`readableHighWaterMark` 값이 소켓의 값을 반영합니다.
v0.1.17	추가됨: v0.1.17

상속: <stream.Readable>

IncomingMessage 객체는 http.Server 또는 http.ClientRequest에 의해 생성되고 'request' 및 'response' 이벤트에 대한 첫 번째 인수로 전달됩니다. 응답 상태, 헤더 및 데이터에 액세스하는 데 사용할 수 있습니다.

<stream.Duplex>의 하위 클래스인 socket 값과 달리, IncomingMessage 자체는 <stream.Readable>을 상속하며, 기본 소켓은 keep-alive의 경우 여러 번 재사용될 수 있으므로 수신 HTTP 헤더와 페이로드를 구문 분석하고 방출하기 위해 별도로 생성됩니다.

이벤트: `'aborted'`

추가됨: v0.3.8

더 이상 사용되지 않음: v17.0.0, v16.12.0

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 0 안정성: 0 - 더 이상 사용되지 않습니다. 대신 'close' 이벤트를 수신하십시오.

요청이 중단되었을 때 발생합니다.

이벤트: `'close'`

[히스토리]

버전	변경 사항
v16.0.0	close 이벤트는 이제 기본 소켓이 닫힐 때가 아니라 요청이 완료되었을 때 발생합니다.
v0.4.2	추가됨: v0.4.2

요청이 완료되었을 때 발생합니다.

`message.aborted`

추가됨: v10.1.0

더 이상 사용되지 않음: v17.0.0, v16.12.0

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 0 안정성: 0 - 더 이상 사용되지 않습니다. <stream.Readable>에서 message.destroyed를 확인하십시오.

<boolean>

message.aborted 속성은 요청이 중단된 경우 true가 됩니다.

`message.complete`

추가됨: v0.3.0

<boolean>

message.complete 속성은 완전한 HTTP 메시지가 수신되어 성공적으로 파싱된 경우 true가 됩니다.

이 속성은 클라이언트 또는 서버가 연결이 종료되기 전에 메시지를 완전히 전송했는지 여부를 확인하는 데 특히 유용합니다.

const req = http.request(
  {
    host: '127.0.0.1',
    port: 8080,
    method: 'POST',
  },
  res => {
    res.resume()
    res.on('end', () => {
      if (!res.complete) console.error('메시지가 전송되는 동안 연결이 종료되었습니다.')
    })
  }
)

`message.connection`

추가됨: v0.1.90

더 이상 사용되지 않음: v16.0.0

[Stable: 0 - 더 이상 사용되지 않음]

Stable: 0 Stability: 0 - 더 이상 사용되지 않음. message.socket을 사용하십시오.

message.socket의 별칭입니다.

`message.destroy([error])`

[히스토리]

버전	변경 사항
v14.5.0, v12.19.0	다른 Readable 스트림과의 일관성을 위해 함수가 `this`를 반환합니다.
v0.3.0	추가됨: v0.3.0

error <Error>
반환값: <this>

IncomingMessage를 수신한 소켓에서 destroy()를 호출합니다. error가 제공되면 소켓에서 'error' 이벤트가 방출되고 이벤트에 대한 모든 리스너에 error가 인수로 전달됩니다.

`message.headers`

[히스토리]

버전	변경 사항
v19.5.0, v18.14.0	`http.request()` 및 `http.createServer()` 함수의 `joinDuplicateHeaders` 옵션은 RFC 9110 섹션 5.3에 따라 중복 헤더가 삭제되지 않고 쉼표로 구분하여 결합되도록 합니다.
v15.1.0	`message.headers`는 이제 프로토타입의 접근자 속성을 사용하여 지연 계산되며 더 이상 열거 가능하지 않습니다.
v0.1.5	추가됨: v0.1.5

<Object>

요청/응답 헤더 객체입니다.

헤더 이름과 값의 키-값 쌍입니다. 헤더 이름은 소문자로 표시됩니다.

// 다음과 같이 출력됩니다.
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers)

원시 헤더의 중복은 헤더 이름에 따라 다음과 같은 방식으로 처리됩니다.

age, authorization, content-length, content-type, etag, expires, from, host, if-modified-since, if-unmodified-since, last-modified, location, max-forwards, proxy-authorization, referer, retry-after, server, 또는 user-agent의 중복은 삭제됩니다. 위에 나열된 헤더의 중복 값을 결합하려면 http.request() 및 http.createServer()에서 joinDuplicateHeaders 옵션을 사용하십시오. 자세한 내용은 RFC 9110 섹션 5.3을 참조하십시오.
set-cookie는 항상 배열입니다. 중복은 배열에 추가됩니다.
중복된 cookie 헤더의 경우 값은 ; 로 연결됩니다.
다른 모든 헤더의 경우 값은 , 로 연결됩니다.

`message.headersDistinct`

추가됨: v18.3.0, v16.17.0

<Object>

message.headers와 유사하지만, 결합 로직이 없으며 값은 한 번만 수신된 헤더라도 항상 문자열 배열입니다.

// 다음과 같이 출력됩니다.
//
// { 'user-agent': ['curl/7.22.0'],
//   host: ['127.0.0.1:8000'],
//   accept: ['*/*'] }
console.log(request.headersDistinct)

`message.httpVersion`

추가됨: v0.1.1

<string>

서버 요청의 경우 클라이언트가 보낸 HTTP 버전입니다. 클라이언트 응답의 경우 연결된 서버의 HTTP 버전입니다. 아마도 '1.1' 또는 '1.0'일 것입니다.

또한 message.httpVersionMajor는 첫 번째 정수이고 message.httpVersionMinor는 두 번째 정수입니다.

`message.method`

추가됨: v0.1.1

<string>

http.Server에서 가져온 요청에 대해서만 유효합니다.

문자열로 된 요청 메서드입니다. 읽기 전용입니다. 예: 'GET', 'DELETE'.

`message.rawHeaders`

추가됨: v0.11.6

<string[]>

수신된 그대로의 원시 요청/응답 헤더 목록입니다.

키와 값은 같은 목록에 있습니다. 튜플 목록이 아닙니다. 따라서 짝수 오프셋은 키 값이고 홀수 오프셋은 연결된 값입니다.

헤더 이름은 소문자로 변환되지 않으며 중복 항목은 병합되지 않습니다.

// 다음과 같이 출력됩니다.
//
// [ 'user-agent',
//   'this is invalid because there can be only one',
//   'User-Agent',
//   'curl/7.22.0',
//   'Host',
//   '127.0.0.1:8000',
//   'ACCEPT',
//   '*/*' ]
console.log(request.rawHeaders)

`message.rawTrailers`

추가됨: v0.11.6

<string[]>

수신된 그대로의 원시 요청/응답 트레일러 키와 값입니다. 'end' 이벤트에서만 채워집니다.

`message.setTimeout(msecs[, callback])`

추가됨: v0.5.9

msecs <number>
callback <Function>
반환값: <http.IncomingMessage>

message.socket.setTimeout(msecs, callback)를 호출합니다.

`message.socket`

추가됨: v0.3.0

<stream.Duplex>

연결과 관련된 net.Socket 객체입니다.

HTTPS 지원을 사용하는 경우, 클라이언트의 인증 세부 정보를 얻으려면 request.socket.getPeerCertificate()를 사용하십시오.

이 속성은 사용자가 <net.Socket> 이외의 소켓 유형을 지정하거나 내부적으로 null 값으로 설정하지 않는 한, <net.Socket> 클래스의 인스턴스이자 <stream.Duplex>의 하위 클래스임이 보장됩니다.

`message.statusCode`

추가됨: v0.1.1

<number>

http.ClientRequest에서 얻은 응답에 대해서만 유효합니다.

3자리 HTTP 응답 상태 코드입니다. 예: 404.

`message.statusMessage`

추가됨: v0.11.10

<string>

http.ClientRequest에서 얻은 응답에 대해서만 유효합니다.

HTTP 응답 상태 메시지(이유 구문)입니다. 예: OK 또는 Internal Server Error.

`message.trailers`

추가됨: v0.3.0

<Object>

요청/응답 트레일러 객체입니다. 'end' 이벤트에서만 채워집니다.

`message.trailersDistinct`

추가됨: v18.3.0, v16.17.0

<Object>

message.trailers와 유사하지만, 조인 로직이 없으며 값은 한 번만 수신된 헤더에도 항상 문자열 배열입니다. 'end' 이벤트에서만 채워집니다.

`message.url`

추가됨: v0.1.90

<string>

http.Server에서 가져온 요청에만 유효합니다.

요청 URL 문자열입니다. 실제 HTTP 요청에 있는 URL만 포함합니다. 다음 요청을 예로 들면:

GET /status?name=ryan HTTP/1.1 Accept: text/plain

URL을 부분으로 구문 분석하려면:

new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`)

request.url이 '/status?name=ryan'이고 process.env.HOST가 정의되지 않은 경우:

bash

$ node
> new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`);
URL {
  href: 'http://localhost/status?name=ryan',
  origin: 'http://localhost',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'localhost',
  hostname: 'localhost',
  port: '',
  pathname: '/status',
  search: '?name=ryan',
  searchParams: URLSearchParams { 'name' => 'ryan' },
  hash: ''
}

process.env.HOST를 서버의 호스트 이름으로 설정하거나 이 부분을 완전히 바꾸는 것을 고려하십시오. req.headers.host를 사용하는 경우 클라이언트가 사용자 지정 Host 헤더를 지정할 수 있으므로 적절한 유효성 검사를 사용해야 합니다.

클래스: `http.OutgoingMessage`

추가됨: v0.1.17

상속: <Stream>

이 클래스는 http.ClientRequest 및 http.ServerResponse의 상위 클래스 역할을 합니다. HTTP 트랜잭션 참여자 관점에서 추상적인 발신 메시지입니다.

이벤트: `'drain'`

추가됨: v0.3.6

메시지의 버퍼가 다시 비어 있을 때 발생합니다.

이벤트: `'finish'`

추가됨: v0.1.17

전송이 성공적으로 완료될 때 발생합니다.

이벤트: `'prefinish'`

추가됨: v0.11.6

outgoingMessage.end()가 호출된 후 발생합니다. 이벤트가 발생하면 모든 데이터가 처리되었지만 반드시 완전히 플러시된 것은 아닙니다.

`outgoingMessage.addTrailers(headers)`

추가됨: v0.3.0

headers <Object>

메시지에 HTTP 트레일러(메시지 끝에 있는 헤더)를 추가합니다.

트레일러는 메시지가 청크 인코딩된 경우에 만 방출됩니다. 그렇지 않으면 트레일러는 자동으로 삭제됩니다.

HTTP는 값에 헤더 필드 이름 목록이 있는 Trailer 헤더를 전송하여 트레일러를 방출해야 합니다. 예:

message.writeHead(200, { 'Content-Type': 'text/plain', Trailer: 'Content-MD5' })
message.write(fileData)
message.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' })
message.end()

잘못된 문자가 포함된 헤더 필드 이름이나 값을 설정하려고 하면 TypeError가 발생합니다.

`outgoingMessage.appendHeader(name, value)`

추가됨: v18.3.0, v16.17.0

name <string> 헤더 이름
value <string> | <string[]> 헤더 값
반환값: <this>

헤더 객체에 단일 헤더 값을 추가합니다.

값이 배열이면 이 메서드를 여러 번 호출하는 것과 같습니다.

헤더에 이전 값이 없으면 outgoingMessage.setHeader(name, value)를 호출하는 것과 같습니다.

클라이언트 요청 또는 서버가 생성될 때 options.uniqueHeaders의 값에 따라 헤더가 여러 번 전송되거나 ; 를 사용하여 값이 결합된 단일 헤더로 전송됩니다.

`outgoingMessage.connection`

추가됨: v0.3.0

더 이상 사용되지 않음: v15.12.0, v14.17.1

[Stable: 0 - 더 이상 사용되지 않음]

Stable: 0 Stability: 0 - 더 이상 사용되지 않음: outgoingMessage.socket을 대신 사용하십시오.

outgoingMessage.socket의 별칭입니다.

`outgoingMessage.cork()`

추가됨: v13.2.0, v12.16.0

writable.cork() 참조.

`outgoingMessage.destroy([error])`

추가됨: v0.3.0

error <Error> 선택적, error 이벤트와 함께 방출할 에러
반환값: <this>

메시지를 파괴합니다. 소켓이 메시지와 연결되고 연결된 후에는 해당 소켓도 파괴됩니다.

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

[히스토리]

버전	변경 사항
v15.0.0	`chunk` 매개변수에 `Uint8Array`를 사용할 수 있습니다.
v0.11.6	`callback` 인수 추가
v0.1.90	추가됨: v0.1.90

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> 선택적, 기본값: utf8
callback <Function> 선택적
반환값: <this>

보내는 메시지를 완료합니다. 본문의 일부가 전송되지 않은 경우 기본 시스템에 플러시합니다. 메시지가 청크화된 경우 종료 청크 0\r\n\r\n을 보내고(있는 경우) 트레일러를 보냅니다.

chunk이 지정된 경우 outgoingMessage.write(chunk, encoding)을 호출한 다음 outgoingMessage.end(callback)을 호출하는 것과 같습니다.

callback이 제공되면 메시지가 완료될 때 호출됩니다('finish' 이벤트의 리스너와 동일).

`outgoingMessage.flushHeaders()`

추가됨: v1.6.0

메시지 헤더를 플러시합니다.

효율성을 위해 Node.js는 일반적으로 outgoingMessage.end()가 호출되거나 메시지 데이터의 첫 번째 청크가 작성될 때까지 메시지 헤더를 버퍼링합니다. 그런 다음 헤더와 데이터를 단일 TCP 패킷에 압축하려고 시도합니다.

일반적으로 바람직하지만(TCP 왕복을 절약함), 첫 번째 데이터가 훨씬 나중에 전송될 때까지는 그렇지 않습니다. outgoingMessage.flushHeaders()는 최적화를 무시하고 메시지를 시작합니다.

`outgoingMessage.getHeader(name)`

추가됨: v0.4.0

name <string> 헤더 이름
반환값: <string> | <undefined>

주어진 이름의 HTTP 헤더 값을 가져옵니다. 해당 헤더가 설정되지 않은 경우 undefined를 반환합니다.

`outgoingMessage.getHeaderNames()`

추가됨: v7.7.0

반환값: <string[]>

현재 발신 헤더의 고유 이름을 포함하는 배열을 반환합니다. 모든 이름은 소문자입니다.

`outgoingMessage.getHeaders()`

추가됨: v7.7.0

반환값: <Object>

현재 발신 헤더의 얕은 복사본을 반환합니다. 얕은 복사본이 사용되므로, 다양한 헤더 관련 HTTP 모듈 메서드를 추가로 호출하지 않고도 배열 값을 변경할 수 있습니다. 반환된 객체의 키는 헤더 이름이고 값은 해당 헤더 값입니다. 모든 헤더 이름은 소문자입니다.

outgoingMessage.getHeaders() 메서드가 반환하는 객체는 JavaScript Object에서 프로토타입으로 상속받지 않습니다. 즉, obj.toString(), obj.hasOwnProperty() 등의 일반적인 Object 메서드는 정의되지 않으며 작동하지 않습니다.

outgoingMessage.setHeader('Foo', 'bar')
outgoingMessage.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headers = outgoingMessage.getHeaders()
// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }

`outgoingMessage.hasHeader(name)`

추가됨: v7.7.0

name <string>
반환값: <boolean>

name으로 식별되는 헤더가 현재 발신 헤더에 설정되어 있는 경우 true를 반환합니다. 헤더 이름은 대소문자를 구분하지 않습니다.

const hasContentType = outgoingMessage.hasHeader('content-type')

`outgoingMessage.headersSent`

추가됨: v0.9.3

<boolean>

읽기 전용. 헤더가 전송된 경우 true, 그렇지 않으면 false입니다.

`outgoingMessage.pipe()`

추가됨: v9.0.0

http.OutgoingMessage의 상위 클래스인 레거시 Stream 클래스에서 상속받은 stream.pipe() 메서드를 재정의합니다.

이 메서드를 호출하면 outgoingMessage는 쓰기 전용 스트림이므로 Error가 발생합니다.

`outgoingMessage.removeHeader(name)`

추가됨: v0.4.0

name <string> 헤더 이름

암시적으로 전송될 예정인 헤더를 제거합니다.

outgoingMessage.removeHeader('Content-Encoding')

`outgoingMessage.setHeader(name, value)`

추가됨: v0.4.0

name <string> 헤더 이름
value <any> 헤더 값
반환값: <this>

단일 헤더 값을 설정합니다. 이미 전송될 헤더에 헤더가 존재하는 경우 해당 값이 대체됩니다. 같은 이름의 여러 헤더를 전송하려면 문자열 배열을 사용하십시오.

`outgoingMessage.setHeaders(headers)`

추가됨: v19.6.0, v18.15.0

headers <Headers> | <Map>
반환값: <this>

암시적 헤더에 대한 여러 헤더 값을 설정합니다. headers는 Headers 또는 Map의 인스턴스여야 하며, 이미 전송될 헤더에 헤더가 존재하는 경우 해당 값이 대체됩니다.

const headers = new Headers({ foo: 'bar' })
outgoingMessage.setHeaders(headers)

또는

const headers = new Map([['foo', 'bar']])
outgoingMessage.setHeaders(headers)

outgoingMessage.setHeaders()로 헤더가 설정된 경우 response.writeHead()에 전달된 헤더와 병합되며, response.writeHead()에 전달된 헤더가 우선 순위를 갖습니다.

// content-type = text/plain 반환
const server = http.createServer((req, res) => {
  const headers = new Headers({ 'Content-Type': 'text/html' })
  res.setHeaders(headers)
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('ok')
})

`outgoingMessage.setTimeout(msesc[, callback])`

추가됨: v0.9.12

msesc <number>
callback <Function> 타임아웃이 발생했을 때 호출되는 선택적 함수입니다. timeout 이벤트에 바인딩하는 것과 같습니다.
반환값: <this>

소켓이 메시지와 연결되고 연결되면 socket.setTimeout()이 첫 번째 매개변수로 msecs를 사용하여 호출됩니다.

`outgoingMessage.socket`

추가됨: v0.3.0

<stream.Duplex>

기본 소켓에 대한 참조입니다. 일반적으로 사용자는 이 속성에 액세스할 필요가 없습니다.

outgoingMessage.end()를 호출한 후 이 속성은 null이 됩니다.

`outgoingMessage.uncork()`

추가됨: v13.2.0, v12.16.0

writable.uncork() 참조

`outgoingMessage.writableCorked`

추가됨: v13.2.0, v12.16.0

<number>

outgoingMessage.cork()이 호출된 횟수입니다.

`outgoingMessage.writableEnded`

추가됨: v12.9.0

<boolean>

outgoingMessage.end()가 호출된 경우 true입니다. 이 속성은 데이터가 플러시되었는지 여부를 나타내지 않습니다. 이를 위해 message.writableFinished를 대신 사용하십시오.

`outgoingMessage.writableFinished`

추가됨: v12.7.0

<boolean>

모든 데이터가 기본 시스템에 플러시된 경우 true입니다.

`outgoingMessage.writableHighWaterMark`

추가됨: v12.9.0

<number>

할당된 경우 기본 소켓의 highWaterMark입니다. 그렇지 않으면 writable.write()이 false를 반환하기 시작할 때 기본 버퍼 레벨(16384)입니다.

`outgoingMessage.writableLength`

추가됨: v12.9.0

<number>

버퍼된 바이트 수입니다.

`outgoingMessage.writableObjectMode`

추가됨: v12.9.0

<boolean>

항상 false입니다.

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

[히스토리]

버전	변경 사항
v15.0.0	`chunk` 매개변수는 이제 `Uint8Array`가 될 수 있습니다.
v0.11.6	`callback` 인수가 추가되었습니다.
v0.1.29	추가됨: v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> 기본값: utf8
callback <Function>
반환값: <boolean>

본문의 청크를 전송합니다. 이 메서드는 여러 번 호출할 수 있습니다.

encoding 인수는 chunk가 문자열일 때만 관련이 있습니다. 기본값은 'utf8'입니다.

callback 인수는 선택 사항이며 이 데이터 청크가 플러시될 때 호출됩니다.

전체 데이터가 커널 버퍼에 성공적으로 플러시된 경우 true를 반환합니다. 데이터의 전부 또는 일부가 사용자 메모리에 큐에 추가된 경우 false를 반환합니다. 버퍼가 다시 사용 가능해지면 'drain' 이벤트가 방출됩니다.

`http.METHODS`

추가됨: v0.11.8

<string[]>

파서에서 지원하는 HTTP 메서드 목록입니다.

`http.STATUS_CODES`

추가됨: v0.1.22

<Object>

모든 표준 HTTP 응답 상태 코드와 각 코드의 간략한 설명을 포함하는 컬렉션입니다. 예를 들어, http.STATUS_CODES[404] === 'Not Found'입니다.

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

[히스토리]

버전	변경 사항
v20.1.0, v18.17.0	`highWaterMark` 옵션이 지원됩니다.
v18.0.0	`requestTimeout`, `headersTimeout`, `keepAliveTimeout`, 및 `connectionsCheckingInterval` 옵션이 지원됩니다.
v18.0.0	`noDelay` 옵션의 기본값이 `true`로 변경되었습니다.
v17.7.0, v16.15.0	`noDelay`, `keepAlive` 및 `keepAliveInitialDelay` 옵션이 지원됩니다.
v13.3.0	`maxHeaderSize` 옵션이 지원됩니다.
v13.8.0, v12.15.0, v10.19.0	`insecureHTTPParser` 옵션이 지원됩니다.
v9.6.0, v8.12.0	`options` 인수가 지원됩니다.
v0.1.13	추가됨: v0.1.13

options <Object>
- connectionsCheckingInterval: 미완료 요청에서 요청 및 헤더 시간 초과를 확인하기 위한 간격 값(밀리초)을 설정합니다. 기본값: 30000.
- headersTimeout: 클라이언트로부터 완전한 HTTP 헤더를 수신하기 위한 시간 초과 값(밀리초)을 설정합니다. 자세한 내용은 server.headersTimeout을 참조하십시오. 기본값: 60000.
- highWaterMark <number> 모든 socket의 readableHighWaterMark 및 writableHighWaterMark를 선택적으로 재정의합니다. IncomingMessage 및 ServerResponse 모두의 highWaterMark 속성에 영향을 미칩니다. 기본값: stream.getDefaultHighWaterMark() 참조.
- insecureHTTPParser <boolean> true로 설정하면 관용 플래그가 활성화된 HTTP 파서를 사용합니다. 안전하지 않은 파서의 사용은 피해야 합니다. 자세한 내용은 --insecure-http-parser를 참조하십시오. 기본값: false.
- IncomingMessage <http.IncomingMessage> 사용할 IncomingMessage 클래스를 지정합니다. 원래 IncomingMessage를 확장하는 데 유용합니다. 기본값: IncomingMessage.
- joinDuplicateHeaders <boolean> true로 설정하면 이 옵션을 통해 요청에서 여러 헤더의 필드 라인 값을 쉼표(, )로 연결하여 중복을 삭제하는 대신 사용할 수 있습니다. 자세한 내용은 message.headers를 참조하십시오. 기본값: false.
- keepAlive <boolean> true로 설정하면 새로운 수신 연결이 수신된 직후 소켓에서 킵얼라이브 기능을 활성화합니다. [socket.setKeepAlive([enable][, initialDelay])][socket.setKeepAlive(enable, initialDelay)]에서 수행되는 작업과 유사합니다. 기본값: false.
- keepAliveInitialDelay <number> 양수로 설정하면 유휴 소켓에 첫 번째 킵얼라이브 프로브를 보내기 전의 초기 지연 시간을 설정합니다. 기본값: 0.
- keepAliveTimeout: 서버가 마지막 응답 쓰기를 완료한 후 추가 수신 데이터를 기다려야 하는 비활동 시간(밀리초)으로, 이 시간이 지나면 소켓이 파괴됩니다. 자세한 내용은 server.keepAliveTimeout을 참조하십시오. 기본값: 5000.
- maxHeaderSize <number> 이 서버에서 수신한 요청에 대해 --max-http-header-size의 값을 선택적으로 재정의합니다. 즉, 바이트 단위의 요청 헤더 최대 길이입니다. 기본값: 16384 (16 KiB).
- noDelay <boolean> true로 설정하면 새로운 수신 연결이 수신된 직후 Nagle 알고리즘의 사용을 비활성화합니다. 기본값: true.
- requestTimeout: 클라이언트로부터 전체 요청을 수신하기 위한 시간 초과 값(밀리초)을 설정합니다. 자세한 내용은 server.requestTimeout을 참조하십시오. 기본값: 300000.
- requireHostHeader <boolean> true로 설정하면 호스트 헤더가 없는 모든 HTTP/1.1 요청 메시지에 대해 서버가 400(잘못된 요청) 상태 코드로 응답하도록 합니다(사양에서 요구됨). 기본값: true.
- ServerResponse <http.ServerResponse> 사용할 ServerResponse 클래스를 지정합니다. 원래 ServerResponse를 확장하는 데 유용합니다. 기본값: ServerResponse.
- uniqueHeaders <Array> 한 번만 전송해야 하는 응답 헤더 목록입니다. 헤더의 값이 배열이면 항목은 ; 를 사용하여 연결됩니다.
- rejectNonStandardBodyWrites <boolean> true로 설정하면 본문이 없는 HTTP 응답에 쓰기를 시도할 때 오류가 발생합니다. 기본값: false.
requestListener <Function>
반환값: <http.Server>

http.Server의 새 인스턴스를 반환합니다.

requestListener는 'request' 이벤트에 자동으로 추가되는 함수입니다.

ESMCJS

import http from 'node:http'

// 데이터를 수신할 로컬 서버 생성
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

const http = require('node:http')

// 데이터를 수신할 로컬 서버 생성
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

ESMCJS

import http from 'node:http'

// 데이터를 수신할 로컬 서버 생성
const server = http.createServer()

// request 이벤트 수신
server.on('request', (request, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

const http = require('node:http')

// 데이터를 수신할 로컬 서버 생성
const server = http.createServer()

// request 이벤트 수신
server.on('request', (request, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

`http.get(options[, callback])`

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

[히스토리]

버전	변경 사항
v10.9.0	`url` 매개변수를 별도의 `options` 객체와 함께 전달할 수 있습니다.
v7.5.0	`options` 매개변수가 WHATWG `URL` 객체일 수 있습니다.
v0.3.6	추가됨: v0.3.6

url <문자열> | <URL>
options <객체> http.request()와 동일한 options를 허용하며, 메서드는 기본적으로 GET으로 설정됩니다.
callback <함수>
반환값: <http.ClientRequest>

대부분의 요청은 본문이 없는 GET 요청이므로 Node.js는 이 편의 메서드를 제공합니다. 이 메서드와 http.request()의 유일한 차이점은 메서드가 기본적으로 GET으로 설정되고 req.end()가 자동으로 호출된다는 것입니다. http.ClientRequest 섹션에 명시된 이유로 콜백은 응답 데이터를 소비해야 합니다.

callback은 http.IncomingMessage의 인스턴스인 단일 인수로 호출됩니다.

JSON 가져오기 예제:

http
  .get('http://localhost:8000/', res => {
    const { statusCode } = res
    const contentType = res.headers['content-type']

    let error
    // 2xx 상태 코드는 성공적인 응답을 나타내지만
    // 여기서는 200만 확인합니다.
    if (statusCode !== 200) {
      error = new Error('요청 실패.\n' + `상태 코드: ${statusCode}`)
    } else if (!/^application\/json/.test(contentType)) {
      error = new Error('잘못된 컨텐츠 유형입니다.\n' + `application/json을 예상했지만 ${contentType}을 받았습니다.`)
    }
    if (error) {
      console.error(error.message)
      // 메모리를 확보하기 위해 응답 데이터를 소비합니다.
      res.resume()
      return
    }

    res.setEncoding('utf8')
    let rawData = ''
    res.on('data', chunk => {
      rawData += chunk
    })
    res.on('end', () => {
      try {
        const parsedData = JSON.parse(rawData)
        console.log(parsedData)
      } catch (e) {
        console.error(e.message)
      }
    })
  })
  .on('error', e => {
    console.error(`오류 발생: ${e.message}`)
  })

// 데이터를 수신할 로컬 서버를 만듭니다.
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

`http.globalAgent`

[이력]

버전	변경 사항
v19.0.0	에이전트는 이제 기본적으로 HTTP Keep-Alive 및 5초 시간 제한을 사용합니다.
v0.5.9	추가됨: v0.5.9

<http.Agent>

모든 HTTP 클라이언트 요청에 대한 기본값으로 사용되는 Agent의 전역 인스턴스입니다. keepAlive를 활성화하고 timeout을 5초로 설정하여 기본 Agent 구성과 다릅니다.

`http.maxHeaderSize`

추가됨: v11.6.0, v10.15.0

<number>

바이트 단위로 HTTP 헤더의 허용 최대 크기를 지정하는 읽기 전용 속성입니다. 기본값은 16KiB입니다. --max-http-header-size CLI 옵션을 사용하여 구성할 수 있습니다.

maxHeaderSize 옵션을 전달하여 서버 및 클라이언트 요청에 대해 이를 재정의할 수 있습니다.

`http.request(options[, callback])`

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

[이력]

버전	변경 사항
v16.7.0, v14.18.0	`URL` 객체를 사용할 때 구문 분석된 사용자 이름과 암호가 이제 제대로 URI 디코딩됩니다.
v15.3.0, v14.17.0	`AbortSignal`을 사용하여 요청을 중단할 수 있습니다.
v13.3.0	이제 `maxHeaderSize` 옵션을 지원합니다.
v13.8.0, v12.15.0, v10.19.0	이제 `insecureHTTPParser` 옵션을 지원합니다.
v10.9.0	이제 별도의 `options` 객체와 함께 `url` 매개변수를 전달할 수 있습니다.
v7.5.0	`options` 매개변수가 WHATWG `URL` 객체일 수 있습니다.
v0.3.6	추가됨: v0.3.6

url <string> | <URL>
options <Object>
- agent <http.Agent> | <boolean> Agent 동작을 제어합니다. 가능한 값:
- undefined (기본값): 이 호스트와 포트에 대해 http.globalAgent를 사용합니다.
- Agent 객체: 전달된 Agent를 명시적으로 사용합니다.
- false: 기본값을 가진 새 Agent를 사용하도록 합니다.
- auth <string> 기본 인증('user:password')으로 권한 부여 헤더를 계산합니다.
- createConnection <Function> agent 옵션을 사용하지 않을 때 요청에 사용할 소켓/스트림을 생성하는 함수입니다. 이는 기본 createConnection 함수를 재정의하기 위해 사용자 지정 Agent 클래스를 만드는 것을 피하기 위해 사용할 수 있습니다. 자세한 내용은 agent.createConnection()을 참조하십시오. 모든 Duplex 스트림은 유효한 반환 값입니다.
- defaultPort <number> 프로토콜의 기본 포트입니다. 기본값: Agent가 사용되는 경우 agent.defaultPort, 그렇지 않으면 undefined.
- family <number> host 또는 hostname을 확인할 때 사용할 IP 주소 계열입니다. 유효한 값은 4 또는 6입니다. 지정하지 않으면 IP v4와 v6이 모두 사용됩니다.
- headers <Object> 요청 헤더가 포함된 객체입니다.
- hints <number> 선택적 dns.lookup() 힌트.
- host <string> 요청을 보낼 서버의 도메인 이름 또는 IP 주소입니다. 기본값: 'localhost'.
- hostname <string> host의 별칭입니다. url.parse()를 지원하기 위해 host와 hostname이 모두 지정된 경우 hostname이 사용됩니다.
- insecureHTTPParser <boolean> true로 설정하면 관용 플래그가 활성화된 HTTP 파서를 사용합니다. 안전하지 않은 파서를 사용하는 것은 피해야 합니다. 자세한 내용은 --insecure-http-parser를 참조하십시오. 기본값: false
- joinDuplicateHeaders <boolean> 중복 항목을 삭제하는 대신 요청에서 여러 헤더의 필드 줄 값을 , 로 연결합니다. 자세한 내용은 message.headers를 참조하십시오. 기본값: false.
- localAddress <string> 네트워크 연결에 바인딩할 로컬 인터페이스입니다.
- localPort <number> 연결할 로컬 포트입니다.
- lookup <Function> 사용자 지정 조회 함수입니다. 기본값: dns.lookup().
- maxHeaderSize <number> 서버에서 수신한 응답에 대한 (바이트 단위의 응답 헤더 최대 길이) --max-http-header-size의 값을 선택적으로 재정의합니다. 기본값: 16384 (16KiB).
- method <string> HTTP 요청 메서드를 지정하는 문자열입니다. 기본값: 'GET'.
- path <string> 요청 경로입니다. 필요한 경우 쿼리 문자열을 포함해야 합니다. 예: '/index.html?page=12'. 요청 경로에 잘못된 문자가 포함된 경우 예외가 발생합니다. 현재 공백만 거부되지만 향후 변경될 수 있습니다. 기본값: '/'.
- port <number> 원격 서버의 포트입니다. 기본값: defaultPort가 설정된 경우 defaultPort, 그렇지 않으면 80.
- protocol <string> 사용할 프로토콜입니다. 기본값: 'http:'.
- setDefaultHeaders <boolean>: Connection, Content-Length, Transfer-Encoding, Host와 같은 기본 헤더를 자동으로 추가할지 여부를 지정합니다. false로 설정하면 모든 필요한 헤더를 수동으로 추가해야 합니다. 기본값은 true입니다.
- setHost <boolean>: Host 헤더를 자동으로 추가할지 여부를 지정합니다. 제공된 경우 이는 setDefaultHeaders를 재정의합니다. 기본값은 true입니다.
- signal <AbortSignal>: 진행 중인 요청을 중단하는 데 사용할 수 있는 AbortSignal입니다.
- socketPath <string> Unix 도메인 소켓입니다. TCP 소켓을 지정하는 host 또는 port 중 하나가 지정된 경우 사용할 수 없습니다.
- timeout <number>: 밀리초 단위로 소켓 시간 제한을 지정하는 숫자입니다. 이는 소켓이 연결되기 전에 시간 제한을 설정합니다.
- uniqueHeaders <Array> 한 번만 전송해야 하는 요청 헤더 목록입니다. 헤더 값이 배열인 경우 항목은 ; 를 사용하여 연결됩니다.
callback <Function>
반환값: <http.ClientRequest>

socket.connect()의 options도 지원됩니다.

Node.js는 HTTP 요청을 하기 위해 서버당 여러 개의 연결을 유지합니다. 이 함수를 사용하면 요청을 투명하게 발행할 수 있습니다.

url은 문자열 또는 URL 객체일 수 있습니다. url이 문자열이면 new URL()을 사용하여 자동으로 구문 분석됩니다. URL 객체이면 일반 options 객체로 자동 변환됩니다.

url과 options가 모두 지정된 경우 객체가 병합되고 options 속성이 우선합니다.

선택적 callback 매개변수는 'response' 이벤트에 대한 일회성 리스너로 추가됩니다.

http.request()는 http.ClientRequest 클래스의 인스턴스를 반환합니다. ClientRequest 인스턴스는 쓰기 가능한 스트림입니다. POST 요청으로 파일을 업로드해야 하는 경우 ClientRequest 객체에 씁니다.

ESMCJS

import http from 'node:http'
import { Buffer } from 'node:buffer'

const postData = JSON.stringify({
  msg: 'Hello World!',
})

const options = {
  hostname: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData),
  },
}

const req = http.request(options, res => {
  console.log(`STATUS: ${res.statusCode}`)
  console.log(`HEADERS: ${JSON.stringify(res.headers)}`)
  res.setEncoding('utf8')
  res.on('data', chunk => {
    console.log(`BODY: ${chunk}`)
  })
  res.on('end', () => {
    console.log('No more data in response.')
  })
})

req.on('error', e => {
  console.error(`problem with request: ${e.message}`)
})

// Write data to request body
req.write(postData)
req.end()

const http = require('node:http')

const postData = JSON.stringify({
  msg: 'Hello World!',
})

const options = {
  hostname: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData),
  },
}

const req = http.request(options, res => {
  console.log(`STATUS: ${res.statusCode}`)
  console.log(`HEADERS: ${JSON.stringify(res.headers)}`)
  res.setEncoding('utf8')
  res.on('data', chunk => {
    console.log(`BODY: ${chunk}`)
  })
  res.on('end', () => {
    console.log('No more data in response.')
  })
})

req.on('error', e => {
  console.error(`problem with request: ${e.message}`)
})

// Write data to request body
req.write(postData)
req.end()

예제에서 req.end()가 호출되었습니다. http.request()를 사용하면 요청 본체에 쓰여지는 데이터가 없더라도 요청의 끝을 나타내기 위해 항상 req.end()를 호출해야 합니다.

요청 중에 DNS 확인, TCP 수준 오류 또는 실제 HTTP 구문 분석 오류와 같은 오류가 발생하면 반환된 요청 객체에서 'error' 이벤트가 발생합니다. 모든 'error' 이벤트와 마찬가지로 리스너가 등록되지 않으면 오류가 throw됩니다.

몇 가지 주목해야 할 특수 헤더가 있습니다.

'Connection: keep-alive'를 보내면 다음 요청까지 서버와의 연결을 유지해야 함을 Node.js에 알립니다.
'Content-Length' 헤더를 보내면 기본 청크 인코딩이 비활성화됩니다.
'Expect' 헤더를 보내면 요청 헤더가 즉시 전송됩니다. 일반적으로 'Expect: 100-continue'를 보낼 때는 시간 제한과 'continue' 이벤트에 대한 리스너를 모두 설정해야 합니다. 자세한 내용은 RFC 2616 섹션 8.2.3을 참조하십시오.
권한 부여 헤더를 보내면 기본 인증을 계산하는 데 auth 옵션을 사용하는 것이 재정의됩니다.

URL을 options로 사용하는 예:

const options = new URL('http://abc:')

const req = http.request(options, res => {
  // ...
})

성공적인 요청의 경우 다음 이벤트가 다음 순서로 발생합니다.

'socket'
'response'
- 'data' 여러 번, res 객체에서('data'는 응답 본체가 비어 있는 경우, 예를 들어 대부분의 리디렉션에서 전혀 발생하지 않습니다.)
- 'end' res 객체에서
'close'

연결 오류의 경우 다음 이벤트가 발생합니다.

'socket'
'error'
'close'

응답을 수신하기 전에 연결이 조기에 닫히는 경우 다음 이벤트가 다음 순서대로 발생합니다.

'socket'
메시지가 'Error: socket hang up'이고 코드가 'ECONNRESET'인 오류가 포함된 'error'
'close'

응답을 수신한 후 연결이 조기에 닫히는 경우 다음 이벤트가 다음 순서대로 발생합니다.

'socket'
'response'
- 'data' 여러 번, res 객체에서
(여기서 연결 닫힘)
res 객체의 'aborted'
'close'
메시지가 'Error: aborted'이고 코드가 'ECONNRESET'인 오류가 포함된 res 객체의 'error'
res 객체의 'close'

소켓이 할당되기 전에 req.destroy()가 호출되면 다음 이벤트가 다음 순서대로 발생합니다.

(req.destroy()가 여기서 호출됨)
메시지가 'Error: socket hang up'이고 코드가 'ECONNRESET'인 오류, 또는 req.destroy()가 호출된 오류가 포함된 'error'
'close'

연결이 성공하기 전에 req.destroy()가 호출되면 다음 이벤트가 다음 순서대로 발생합니다.

'socket'
(req.destroy()가 여기서 호출됨)
메시지가 'Error: socket hang up'이고 코드가 'ECONNRESET'인 오류, 또는 req.destroy()가 호출된 오류가 포함된 'error'
'close'

응답을 수신한 후 req.destroy()가 호출되면 다음 이벤트가 다음 순서대로 발생합니다.

'socket'
'response'
- 'data' 여러 번, res 객체에서
(req.destroy()가 여기서 호출됨)
res 객체의 'aborted'
'close'
메시지가 'Error: aborted'이고 코드가 'ECONNRESET'인 오류, 또는 req.destroy()가 호출된 오류가 포함된 res 객체의 'error'
res 객체의 'close'

소켓이 할당되기 전에 req.abort()가 호출되면 다음 이벤트가 다음 순서대로 발생합니다.

(req.abort()가 여기서 호출됨)
'abort'
'close'

연결이 성공하기 전에 req.abort()가 호출되면 다음 이벤트가 다음 순서대로 발생합니다.

'socket'
(req.abort()가 여기서 호출됨)
'abort'
메시지가 'Error: socket hang up'이고 코드가 'ECONNRESET'인 오류가 포함된 'error'
'close'

응답을 수신한 후 req.abort()가 호출되면 다음 이벤트가 다음 순서대로 발생합니다.

'socket'
'response'
- 'data' 여러 번, res 객체에서
(req.abort()가 여기서 호출됨)
'abort'
res 객체의 'aborted'
메시지가 'Error: aborted'이고 코드가 'ECONNRESET'인 오류가 포함된 res 객체의 'error'.
'close'
res 객체의 'close'

timeout 옵션을 설정하거나 setTimeout() 함수를 사용해도 요청이 중단되거나 'timeout' 이벤트가 추가되는 것 외에는 아무런 작업도 수행되지 않습니다.

AbortSignal을 전달한 다음 해당 AbortController에서 abort()를 호출하면 요청에서 .destroy()를 호출하는 것과 동일하게 동작합니다. 구체적으로 'error' 이벤트는 메시지가 'AbortError: The operation was aborted', 코드가 'ABORT_ERR'이고 cause(있는 경우)가 포함된 오류와 함께 발생합니다.

`http.validateHeaderName(name[, label])`

[히스토리]

버전	변경 사항
v19.5.0, v18.14.0	`label` 매개변수 추가
v14.3.0	추가됨: v14.3.0

name <string>
label <string> 오류 메시지에 대한 레이블. 기본값: 'Header name'.

res.setHeader(name, value)가 호출될 때 수행되는 제공된 name에 대한 하위 수준 유효성 검사를 수행합니다.

name으로 불법적인 값을 전달하면 code: 'ERR_INVALID_HTTP_TOKEN'으로 식별되는 TypeError가 발생합니다.

HTTP 요청이나 응답에 헤더를 전달하기 전에 이 메서드를 사용할 필요는 없습니다. HTTP 모듈은 이러한 헤더를 자동으로 유효성 검사합니다.

예시:

ESMCJS

import { validateHeaderName } from 'node:http'

try {
  validateHeaderName('')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code) // --> 'ERR_INVALID_HTTP_TOKEN'
  console.error(err.message) // --> 'Header name must be a valid HTTP token [""]'
}

const { validateHeaderName } = require('node:http')

try {
  validateHeaderName('')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code) // --> 'ERR_INVALID_HTTP_TOKEN'
  console.error(err.message) // --> 'Header name must be a valid HTTP token [""]'
}

`http.validateHeaderValue(name, value)`

추가됨: v14.3.0

name <string>
value <any>

res.setHeader(name, value)가 호출될 때 수행되는 제공된 value에 대한 하위 수준 유효성 검사를 수행합니다.

value로 불법적인 값을 전달하면 TypeError가 발생합니다.

정의되지 않은 값 오류는 code: 'ERR_HTTP_INVALID_HEADER_VALUE'로 식별됩니다.
잘못된 값 문자 오류는 code: 'ERR_INVALID_CHAR'로 식별됩니다.

HTTP 요청이나 응답에 헤더를 전달하기 전에 이 메서드를 사용할 필요는 없습니다. HTTP 모듈은 이러한 헤더를 자동으로 유효성 검사합니다.

예시:

ESMCJS

import { validateHeaderValue } from 'node:http'

try {
  validateHeaderValue('x-my-header', undefined)
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_HTTP_INVALID_HEADER_VALUE') // --> true
  console.error(err.message) // --> 'Invalid value "undefined" for header "x-my-header"'
}

try {
  validateHeaderValue('x-my-header', 'oʊmɪɡə')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_INVALID_CHAR') // --> true
  console.error(err.message) // --> 'Invalid character in header content ["x-my-header"]'
}

const { validateHeaderValue } = require('node:http')

try {
  validateHeaderValue('x-my-header', undefined)
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_HTTP_INVALID_HEADER_VALUE') // --> true
  console.error(err.message) // --> 'Invalid value "undefined" for header "x-my-header"'
}

try {
  validateHeaderValue('x-my-header', 'oʊmɪɡə')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_INVALID_CHAR') // --> true
  console.error(err.message) // --> 'Invalid character in header content ["x-my-header"]'
}

`http.setMaxIdleHTTPParsers(max)`

추가됨: v18.8.0, v16.18.0

max <숫자> 기본값: 1000.

유휴 HTTP 파서의 최대 수를 설정합니다.

`WebSocket`

추가됨: v22.5.0

WebSocket의 브라우저 호환 구현.

HTTP ​

클래스: http.Agent ​

new Agent([options]) ​

agent.createConnection(options[, callback]) ​

agent.keepSocketAlive(socket) ​

agent.reuseSocket(socket, request) ​

agent.destroy() ​

agent.freeSockets ​

agent.getName([options]) ​

agent.maxFreeSockets ​

agent.maxSockets ​

agent.maxTotalSockets ​

agent.requests ​

agent.sockets ​

클래스: http.ClientRequest ​

이벤트: 'abort' ​

이벤트: 'close' ​

이벤트: 'connect' ​

이벤트: 'continue' ​

이벤트: 'finish' ​

이벤트: 'information' ​

이벤트: 'response' ​

이벤트: 'socket' ​

이벤트: 'timeout' ​

이벤트: 'upgrade' ​

request.abort() ​

request.aborted ​

request.connection ​

request.cork() ​

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

request.destroy([error]) ​

request.destroyed ​

request.finished ​

request.flushHeaders() ​

request.getHeader(name) ​

request.getHeaderNames() ​

request.getHeaders() ​

request.getRawHeaderNames() ​

request.hasHeader(name) ​

request.maxHeadersCount ​

request.path ​

request.method ​

request.host ​

request.protocol ​

request.removeHeader(name) ​

request.reusedSocket ​

request.setHeader(name, value) ​

request.setNoDelay([noDelay]) ​

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

request.setTimeout(timeout[, callback]) ​

request.socket ​

request.uncork() ​

request.writableEnded ​

request.writableFinished ​

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

클래스: http.Server ​

이벤트: 'checkContinue' ​

이벤트: 'checkExpectation' ​

이벤트: 'clientError' ​

이벤트: 'close' ​

이벤트: 'connect' ​

이벤트: 'connection' ​

이벤트: 'dropRequest' ​

이벤트: 'request' ​

이벤트: 'upgrade' ​

server.close([callback]) ​

server.closeAllConnections() ​

server.closeIdleConnections() ​

server.headersTimeout ​

server.listen() ​

server.listening ​

server.maxHeadersCount ​

server.requestTimeout ​

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

server.maxRequestsPerSocket ​

server.timeout ​

server.keepAliveTimeout ​

server[Symbol.asyncDispose]() ​

클래스: http.ServerResponse ​

이벤트: 'close' ​

HTTP

클래스: `http.Agent`

`new Agent([options])`

`agent.createConnection(options[, callback])`

`agent.keepSocketAlive(socket)`

`agent.reuseSocket(socket, request)`

`agent.destroy()`

`agent.freeSockets`

`agent.getName([options])`

`agent.maxFreeSockets`

`agent.maxSockets`

`agent.maxTotalSockets`

`agent.requests`

`agent.sockets`

클래스: `http.ClientRequest`

이벤트: `'abort'`

이벤트: `'close'`

이벤트: `'connect'`

이벤트: `'continue'`

이벤트: `'finish'`

이벤트: `'information'`

이벤트: `'response'`

이벤트: `'socket'`

이벤트: `'timeout'`

이벤트: `'upgrade'`

`request.abort()`

`request.aborted`

`request.connection`

`request.cork()`

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

`request.destroy([error])`

`request.destroyed`

`request.finished`

`request.flushHeaders()`

`request.getHeader(name)`

`request.getHeaderNames()`

`request.getHeaders()`

`request.getRawHeaderNames()`

`request.hasHeader(name)`

`request.maxHeadersCount`

`request.path`

`request.method`

`request.host`

`request.protocol`

`request.removeHeader(name)`

`request.reusedSocket`

`request.setHeader(name, value)`

`request.setNoDelay([noDelay])`

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

`request.setTimeout(timeout[, callback])`

`request.socket`

`request.uncork()`

`request.writableEnded`

`request.writableFinished`

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

클래스: `http.Server`

이벤트: `'checkContinue'`

이벤트: `'checkExpectation'`

이벤트: `'clientError'`

이벤트: `'close'`

이벤트: `'connect'`

이벤트: `'connection'`

이벤트: `'dropRequest'`

이벤트: `'request'`

이벤트: `'upgrade'`

`server.close([callback])`

`server.closeAllConnections()`

`server.closeIdleConnections()`

`server.headersTimeout`

`server.listen()`

`server.listening`

`server.maxHeadersCount`

`server.requestTimeout`

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

`server.maxRequestsPerSocket`

`server.timeout`

`server.keepAliveTimeout`

`server[Symbol.asyncDispose]()`

클래스: `http.ServerResponse`

이벤트: `'close'`