HTTP

[Stable : 2 - Stable]

Code source : lib/http.js

Ce module, contenant à la fois un client et un serveur, peut être importé via require('node:http') (CommonJS) ou import * as http from 'node:http' (module ES).

Les interfaces HTTP dans Node.js sont conçues pour prendre en charge de nombreuses fonctionnalités du protocole qui ont traditionnellement été difficiles à utiliser. En particulier, les messages volumineux, éventuellement encodés par blocs. L'interface est conçue pour ne jamais mettre en mémoire tampon l'intégralité des requêtes ou des réponses, afin que l'utilisateur puisse diffuser des données en continu.

Les en-têtes des messages HTTP sont représentés par un objet comme celui-ci :

json

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

Les clés sont en minuscules. Les valeurs ne sont pas modifiées.

Afin de prendre en charge toute la gamme des applications HTTP possibles, l'API HTTP de Node.js est très bas niveau. Elle gère uniquement le traitement des flux et l'analyse des messages. Elle analyse un message en en-têtes et corps, mais elle n'analyse pas les en-têtes ou le corps eux-mêmes.

Voir message.headers pour plus de détails sur la gestion des en-têtes dupliqués.

Les en-têtes bruts tels qu'ils ont été reçus sont conservés dans la propriété rawHeaders, qui est un tableau de [clé, valeur, clé2, valeur2, ...]. Par exemple, l'objet d'en-tête de message précédent pourrait avoir une liste rawHeaders comme celle-ci :

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

Classe : `http.Agent`

Ajouté dans : v0.3.4

Un Agent est responsable de la gestion de la persistance et de la réutilisation des connexions pour les clients HTTP. Il gère une file d'attente des requêtes en attente pour un hôte et un port donnés, réutilisant une seule connexion socket pour chacun jusqu'à ce que la file d'attente soit vide, auquel cas la socket est soit détruite, soit placée dans un pool où elle est conservée pour être utilisée à nouveau pour les requêtes vers le même hôte et le même port. Sa destruction ou son placement dans un pool dépend de l'option keepAlive option.

Les connexions mises en pool ont le TCP Keep-Alive activé, mais les serveurs peuvent toujours fermer les connexions inactives, auquel cas elles seront supprimées du pool et une nouvelle connexion sera établie lorsqu'une nouvelle requête HTTP sera effectuée pour cet hôte et ce port. Les serveurs peuvent également refuser d'autoriser plusieurs requêtes sur la même connexion, auquel cas la connexion devra être rétablie pour chaque requête et ne pourra pas être mise en pool. L'Agent effectuera toujours les requêtes vers ce serveur, mais chacune d'elles se produira sur une nouvelle connexion.

Lorsqu'une connexion est fermée par le client ou le serveur, elle est supprimée du pool. Toutes les sockets inutilisées dans le pool seront désaffectées afin de ne pas maintenir le processus Node.js en fonctionnement lorsqu'il n'y a pas de requêtes en attente. (voir socket.unref()).

Il est conseillé de destroy() une instance Agent lorsqu'elle n'est plus utilisée, car les sockets inutilisées consomment des ressources du système d'exploitation.

Les sockets sont supprimées d'un agent lorsque la socket émet un événement 'close' ou un événement 'agentRemove'. Lorsque l'on souhaite garder une requête HTTP ouverte pendant longtemps sans la conserver dans l'agent, on peut faire quelque chose comme ceci :

http
  .get(options, res => {
    // Faire quelque chose
  })
  .on('socket', socket => {
    socket.emit('agentRemove')
  })

Un agent peut également être utilisé pour une requête individuelle. En fournissant {agent: false} comme option aux fonctions http.get() ou http.request(), un Agent à usage unique avec les options par défaut sera utilisé pour la connexion client.

agent:false:

http.get(
  {
    hostname: 'localhost',
    port: 80,
    path: '/',
    agent: false, // Créer un nouvel agent uniquement pour cette requête
  },
  res => {
    // Faire quelque chose avec la réponse
  }
)

`new Agent([options])`

[Historique]

Version	Modifications
v15.6.0, v14.17.0	Modification de la planification par défaut de 'fifo' à 'lifo'.
v14.5.0, v12.20.0	Ajout de l'option `scheduling` pour spécifier la stratégie de planification des sockets libres.
v14.5.0, v12.19.0	Ajout de l'option `maxTotalSockets` au constructeur de l'agent.
v0.3.4	Ajouté dans : v0.3.4

options <Objet> Ensemble d'options configurables à définir sur l'agent. Peut avoir les champs suivants :
- keepAlive <booléen> Conserve les sockets même lorsqu'il n'y a pas de requêtes en suspens, afin qu'elles puissent être utilisées pour les requêtes futures sans avoir à rétablir une connexion TCP. À ne pas confondre avec la valeur keep-alive de l'en-tête Connection. L'en-tête Connection: keep-alive est toujours envoyé lors de l'utilisation d'un agent, sauf lorsque l'en-tête Connection est spécifié explicitement ou lorsque les options keepAlive et maxSockets sont respectivement définies sur false et Infinity, auquel cas Connection: close sera utilisé. Défaut : false.
- keepAliveMsecs <nombre> Lors de l'utilisation de l'option keepAlive, spécifie le délai initial pour les paquets TCP Keep-Alive. Ignoré lorsque l'option keepAlive est false ou undefined. Défaut : 1000.
- maxSockets <nombre> Nombre maximal de sockets autorisés par hôte. Si le même hôte ouvre plusieurs connexions concurrentes, chaque requête utilisera une nouvelle socket jusqu'à ce que la valeur maxSockets soit atteinte. Si l'hôte tente d'ouvrir plus de connexions que maxSockets, les requêtes supplémentaires entreront dans une file d'attente de requêtes en attente et passeront à l'état de connexion active lorsqu'une connexion existante se termine. Cela garantit qu'il y a au plus maxSockets connexions actives à tout moment, depuis un hôte donné. Défaut : Infinity.
- maxTotalSockets <nombre> Nombre maximal de sockets autorisés pour tous les hôtes au total. Chaque requête utilisera une nouvelle socket jusqu'à ce que le maximum soit atteint. Défaut : Infinity.
- maxFreeSockets <nombre> Nombre maximal de sockets par hôte à laisser ouverts en état libre. Uniquement pertinent si keepAlive est défini sur true. Défaut : 256.
- scheduling <chaîne de caractères> Stratégie de planification à appliquer lors du choix du prochain socket libre à utiliser. Cela peut être 'fifo' ou 'lifo'. La principale différence entre les deux stratégies de planification est que 'lifo' sélectionne le socket le plus récemment utilisé, tandis que 'fifo' sélectionne le socket le moins récemment utilisé. En cas de faible taux de requêtes par seconde, la planification 'lifo' réduira le risque de choisir un socket qui pourrait avoir été fermé par le serveur en raison de l'inactivité. En cas de taux de requêtes par seconde élevé, la planification 'fifo' maximisera le nombre de sockets ouverts, tandis que la planification 'lifo' le maintiendra aussi bas que possible. Défaut : 'lifo'.
- timeout <nombre> Délai d'expiration du socket en millisecondes. Cela définira le délai d'expiration lors de la création du socket.

options dans socket.connect() sont également prises en charge.

Pour configurer l'une d'elles, une instance http.Agent personnalisée doit être créée.

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

Ajouté dans : v0.11.4

options <Object> Options contenant les détails de connexion. Consultez net.createConnection() pour le format des options
callback <Function> Fonction de rappel qui reçoit le socket créé
Retourne : <stream.Duplex>

Produit un socket/flux à utiliser pour les requêtes HTTP.

Par défaut, cette fonction est identique à net.createConnection(). Cependant, les agents personnalisés peuvent outrepasser cette méthode si une plus grande flexibilité est souhaitée.

Un socket/flux peut être fourni de deux manières : en retournant le socket/flux depuis cette fonction, ou en passant le socket/flux à callback.

Cette méthode garantit le retour d’une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l’utilisateur spécifie un type de socket autre que <net.Socket>.

callback a une signature de (err, stream).

`agent.keepSocketAlive(socket)`

Ajouté dans : v8.1.0

socket <stream.Duplex>

Appelé lorsque socket est détaché d’une requête et pourrait être conservé par l’Agent. Le comportement par défaut est :

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

Cette méthode peut être outrepassée par une sous-classe Agent particulière. Si cette méthode retourne une valeur fausse, le socket sera détruit au lieu d’être conservé pour utilisation avec la requête suivante.

L’argument socket peut être une instance de <net.Socket>, une sous-classe de <stream.Duplex>.

`agent.reuseSocket(socket, request)`

Ajouté dans : v8.1.0

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

Appelé lorsque socket est attaché à request après avoir été conservé en raison des options keep-alive. Le comportement par défaut est :

socket.ref()

Cette méthode peut être outrepassée par une sous-classe Agent particulière.

L’argument socket peut être une instance de <net.Socket>, une sous-classe de <stream.Duplex>.

`agent.destroy()`

Ajouté dans : v0.11.4

Détruit tous les sockets actuellement utilisés par l'agent.

Ce n'est généralement pas nécessaire. Cependant, si vous utilisez un agent avec keepAlive activé, il est préférable d'arrêter explicitement l'agent lorsqu'il n'est plus nécessaire. Sinon, les sockets peuvent rester ouverts assez longtemps avant que le serveur ne les termine.

`agent.freeSockets`

[Historique]

Version	Modifications
v16.0.0	La propriété a maintenant un prototype `null`.
v0.11.4	Ajouté dans : v0.11.4

<Objet>

Un objet qui contient des tableaux de sockets actuellement en attente d'utilisation par l'agent lorsque keepAlive est activé. Ne pas modifier.

Les sockets de la liste freeSockets seront automatiquement détruits et supprimés du tableau sur 'timeout'.

`agent.getName([options])`

[Historique]

Version	Modifications
v17.7.0, v16.15.0	Le paramètre `options` est maintenant facultatif.
v0.11.4	Ajouté dans : v0.11.4

options <Objet> Un ensemble d'options fournissant des informations pour la génération de noms
- host <chaîne de caractères> Un nom de domaine ou une adresse IP du serveur auquel envoyer la requête
- port <nombre> Port du serveur distant
- localAddress <chaîne de caractères> Interface locale à lier pour les connexions réseau lors de l'émission de la requête
- family <entier> Doit être 4 ou 6 si cela n'est pas égal à undefined.
Retourne : <chaîne de caractères>

Obtenir un nom unique pour un ensemble d'options de requête, afin de déterminer si une connexion peut être réutilisée. Pour un agent HTTP, cela renvoie host:port:localAddress ou host:port:localAddress:family. Pour un agent HTTPS, le nom inclut l'autorité de certification, le certificat, les chiffrements et d'autres options spécifiques à HTTPS/TLS qui déterminent la réutilisabilité des sockets.

`agent.maxFreeSockets`

Ajouté dans : v0.11.7

<nombre>

Par défaut, défini sur 256. Pour les agents avec keepAlive activé, cela définit le nombre maximal de sockets qui resteront ouverts à l’état libre.

`agent.maxSockets`

Ajouté dans : v0.3.6

<nombre>

Par défaut, défini sur Infinity. Détermine combien de sockets simultanés l’agent peut avoir ouverts par origine. L’origine est la valeur retournée par agent.getName().

`agent.maxTotalSockets`

Ajouté dans : v14.5.0, v12.19.0

<nombre>

Par défaut, défini sur Infinity. Détermine combien de sockets simultanés l’agent peut avoir ouverts. Contrairement à maxSockets, ce paramètre s’applique à toutes les origines.

`agent.requests`

[Historique]

Version	Modifications
v16.0.0	La propriété a maintenant un prototype `null`.
v0.5.9	Ajouté dans : v0.5.9

<Objet>

Un objet qui contient des files d’attente de requêtes qui n’ont pas encore été assignées à des sockets. Ne pas modifier.

`agent.sockets`

[Historique]

Version	Modifications
v16.0.0	La propriété a maintenant un prototype `null`.
v0.3.6	Ajouté dans : v0.3.6

<Objet>

Un objet qui contient des tableaux de sockets actuellement utilisés par l’agent. Ne pas modifier.

Classe : `http.ClientRequest`

Ajouté dans : v0.1.17

Étend : <http.OutgoingMessage>

Cet objet est créé en interne et retourné par http.request(). Il représente une requête en cours dont l’en-tête a déjà été mis en file d’attente. L’en-tête est toujours modifiable à l’aide de l’API setHeader(name, value), getHeader(name), removeHeader(name). L’en-tête réel sera envoyé avec le premier bloc de données ou lors de l’appel de request.end().

Pour obtenir la réponse, ajoutez un écouteur pour 'response' à l’objet requête. 'response' sera émis par l’objet requête lorsque les en-têtes de la réponse auront été reçus. L’événement 'response' est exécuté avec un argument qui est une instance de http.IncomingMessage.

Pendant l’événement 'response', on peut ajouter des écouteurs à l’objet réponse ; notamment pour écouter l’événement 'data'.

Si aucun gestionnaire 'response' n’est ajouté, la réponse sera entièrement ignorée. Cependant, si un gestionnaire d’événement 'response' est ajouté, les données de l’objet réponse doivent être consommées, soit en appelant response.read() chaque fois qu’il y a un événement 'readable', soit en ajoutant un gestionnaire 'data', soit en appelant la méthode .resume(). Tant que les données ne sont pas consommées, l’événement 'end' ne se déclenchera pas. De plus, tant que les données ne sont pas lues, elles consommeront de la mémoire, ce qui peut éventuellement entraîner une erreur de « processus hors mémoire ».

Pour des raisons de compatibilité descendante, res n’émettra 'error' que s’il y a un écouteur 'error' enregistré.

Définissez l’en-tête Content-Length pour limiter la taille du corps de la réponse. Si response.strictContentLength est défini sur true, une non-correspondance de la valeur de l’en-tête Content-Length entraînera le lancement d’une erreur, identifiée par le code : 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'.

La valeur Content-Length doit être en octets, pas en caractères. Utilisez Buffer.byteLength() pour déterminer la longueur du corps en octets.

Événement : `'abort'`

Ajouté dans : v1.4.1

Déprécié depuis : v17.0.0, v16.12.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Écoutez plutôt l'événement 'close'.

Émis lorsque la requête a été interrompue par le client. Cet événement n'est émis que lors du premier appel à abort().

Événement : `'close'`

Ajouté dans : v0.5.4

Indique que la requête est terminée ou que sa connexion sous-jacente a été interrompue prématurément (avant la fin de la réponse).

Événement : `'connect'`

Ajouté dans : v0.7.0

Émis chaque fois qu'un serveur répond à une requête avec une méthode CONNECT. Si cet événement n'est pas écouté, les connexions des clients recevant une méthode CONNECT seront fermées.

Il est garanti que cet événement recevra une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur spécifie un type de socket autre que <net.Socket>.

Une paire client-serveur illustrant comment écouter l'événement 'connect' :

ESMCJS

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

// Créer un proxy de tunnel HTTP
const proxy = createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
proxy.on('connect', (req, clientSocket, head) => {
  // Se connecter à un serveur d'origine
  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)
  })
})

// Maintenant que le proxy est en cours d'exécution
proxy.listen(1337, '127.0.0.1', () => {
  // Faire une requête à un proxy de tunnel
  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!')

    // Faire une requête via un tunnel 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')

// Créer un proxy de tunnel HTTP
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
proxy.on('connect', (req, clientSocket, head) => {
  // Se connecter à un serveur d'origine
  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)
  })
})

// Maintenant que le proxy est en cours d'exécution
proxy.listen(1337, '127.0.0.1', () => {
  // Faire une requête à un proxy de tunnel
  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!')

    // Faire une requête via un tunnel 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()
    })
  })
})

Événement : `'continue'`

Ajouté dans : v0.3.2

Émis lorsque le serveur envoie une réponse HTTP « 100 Continue », généralement parce que la requête contenait « Expect : 100-continue ». Il s’agit d’une instruction indiquant que le client doit envoyer le corps de la requête.

Événement : `'finish'`

Ajouté dans : v0.3.6

Émis lorsque la requête a été envoyée. Plus précisément, cet événement est émis lorsque le dernier segment des en-têtes et du corps de la réponse a été transmis au système d’exploitation pour transmission sur le réseau. Cela n’implique pas que le serveur ait encore reçu quoi que ce soit.

Événement : `'information'`

Ajouté dans : v10.0.0

info <Objet>
- httpVersion <chaîne de caractères>
- httpVersionMajor <entier>
- httpVersionMinor <entier>
- statusCode <entier>
- statusMessage <chaîne de caractères>
- headers <Objet>
- rawHeaders <tableau de chaînes de caractères>

Émis lorsque le serveur envoie une réponse intermédiaire 1xx (à l’exclusion de 101 Upgrade). Les écouteurs de cet événement recevront un objet contenant la version HTTP, le code de statut, le message de statut, l’objet en-têtes clé-valeur et le tableau avec les noms d’en-têtes bruts suivis de leurs valeurs respectives.

ESMCJS

import { request } from 'node:http'

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

// Faire une requête
const req = request(options)
req.end()

req.on('information', info => {
  console.log(`Informations reçues avant la réponse principale : ${info.statusCode}`)
})

const http = require('node:http')

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

// Faire une requête
const req = http.request(options)
req.end()

req.on('information', info => {
  console.log(`Informations reçues avant la réponse principale : ${info.statusCode}`)
})

Les statuts 101 Upgrade ne déclenchent pas cet événement en raison de leur rupture avec la chaîne de requête/réponse HTTP traditionnelle, comme les websockets, les mises à niveau TLS sur place ou HTTP 2.0. Pour être informé des avis 101 Upgrade, écoutez plutôt l’événement 'upgrade'.

Événement : `'response'`

Ajouté dans : v0.1.0

response <http.IncomingMessage>

Émis lorsqu'une réponse est reçue pour cette requête. Cet événement n'est émis qu'une seule fois.

Événement : `'socket'`

Ajouté dans : v0.5.3

socket <stream.Duplex>

Il est garanti que cet événement recevra une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur spécifie un type de socket autre que <net.Socket>.

Événement : `'timeout'`

Ajouté dans : v0.7.8

Émis lorsque le socket sous-jacent dépasse le délai d'inactivité. Cela ne fait que signaler que le socket a été inactif. La requête doit être détruite manuellement.

Voir aussi : request.setTimeout().

Événement : `'upgrade'`

Ajouté dans : v0.1.94

Émis chaque fois qu'un serveur répond à une requête avec une mise à niveau. Si cet événement n'est pas écouté et que le code de statut de la réponse est 101 Switching Protocols, les clients recevant un en-tête de mise à niveau verront leurs connexions fermées.

Il est garanti que cet événement recevra une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur spécifie un type de socket autre que <net.Socket>.

Une paire client-serveur illustrant comment écouter l'événement 'upgrade'.

ESMCJS

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

// Créer un serveur 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) // faire un écho
})

// Maintenant que le serveur est en marche
server.listen(1337, '127.0.0.1', () => {
  // faire une requête
  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('mise à niveau effectuée !')
    socket.end()
    process.exit(0)
  })
})

const http = require('node:http')

// Créer un serveur 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) // faire un écho
})

// Maintenant que le serveur est en marche
server.listen(1337, '127.0.0.1', () => {
  // faire une requête
  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('mise à niveau effectuée !')
    socket.end()
    process.exit(0)
  })
})

`request.abort()`

Ajouté dans : v0.3.8

Déprécié depuis : v14.1.0, v13.14.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié : Utilisez request.destroy() à la place.

Marque la requête comme étant interrompue. Cet appel entraînera la suppression des données restantes dans la réponse et la destruction du socket.

`request.aborted`

[Historique]

Version	Modifications
v17.0.0, v16.12.0	Déprécié depuis : v17.0.0, v16.12.0
v11.0.0	La propriété `aborted` n'est plus un nombre horodatage.
v0.11.14	Ajouté dans : v0.11.14

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Vérifiez request.destroyed à la place.

<booléen>

La propriété request.aborted sera true si la requête a été interrompue.

`request.connection`

Ajouté dans : v0.3.0

Déprécié depuis : v13.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Utilisez request.socket.

<stream.Duplex>

Voir request.socket.

`request.cork()`

Ajouté dans : v13.2.0, v12.16.0

Voir writable.cork().

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

[Historique]

Version	Modifications
v15.0.0	Le paramètre `data` peut maintenant être un `Uint8Array`.
v10.0.0	Cette méthode renvoie maintenant une référence à `ClientRequest`.
v0.1.90	Ajouté dans : v0.1.90

data <chaîne de caractères> | <Buffer> | <Uint8Array>
encoding <chaîne de caractères>
callback <Fonction>
Retourne : <this>

Termine l'envoi de la requête. Si des parties du corps ne sont pas envoyées, elles seront vidées dans le flux. Si la requête est segmentée, cela enverra le '0\r\n\r\n' de terminaison.

Si data est spécifié, cela équivaut à appeler request.write(data, encoding) suivi de request.end(callback).

Si callback est spécifié, il sera appelé lorsque le flux de requête est terminé.

`request.destroy([error])`

[Historique]

Version	Modifications
v14.5.0	La fonction retourne `this` pour assurer la cohérence avec les autres flux lisibles.
v0.3.0	Ajoutée dans la version : v0.3.0

error <Error> Facultatif, une erreur à émettre avec l'événement 'error'.
Retourne : <this>

Détruit la requête. Émet éventuellement un événement 'error' et un événement 'close'. L'appel de cette fonction entraîne la suppression des données restantes dans la réponse et la destruction du socket.

Voir writable.destroy() pour plus de détails.

`request.destroyed`

Ajouté dans : v14.1.0, v13.14.0

<boolean>

Est true après l'appel de request.destroy().

Voir writable.destroyed pour plus de détails.

`request.finished`

Ajouté dans : v0.0.1

Déprécié depuis : v13.4.0, v12.16.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Utilisez request.writableEnded.

<boolean>

La propriété request.finished sera true si request.end() a été appelée. request.end() sera automatiquement appelée si la requête a été initiée via http.get().

`request.flushHeaders()`

Ajouté dans : v1.6.0

Vide les en-têtes de la requête.

Pour des raisons d'efficacité, Node.js met généralement en mémoire tampon les en-têtes de la requête jusqu'à ce que request.end() soit appelé ou que le premier bloc de données de la requête soit écrit. Il essaie ensuite d'empaqueter les en-têtes et les données de la requête dans un seul paquet TCP.

Ceci est généralement souhaitable (cela permet d'économiser un aller-retour TCP), mais pas lorsque les premières données ne sont pas envoyées avant beaucoup plus tard. request.flushHeaders() contourne l'optimisation et lance la requête.

`request.getHeader(name)`

Ajouté dans : v1.6.0

name <string>
Retourne : <any>

Lit un en-tête de la requête. Le nom est insensible à la casse. Le type de la valeur retournée dépend des arguments fournis à 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' est 'text/html'
const contentLength = request.getHeader('Content-Length')
// 'contentLength' est de type number
const cookie = request.getHeader('Cookie')
// 'cookie' est de type string[]

`request.getHeaderNames()`

Ajouté dans : v7.7.0

Retourne : <string[]>

Retourne un tableau contenant les noms uniques des en-têtes sortants actuels. Tous les noms d'en-têtes sont en minuscules.

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

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

`request.getHeaders()`

Ajouté dans : v7.7.0

Retourne : <Object>

Retourne une copie superficielle des en-têtes sortants actuels. Comme une copie superficielle est utilisée, les valeurs de tableau peuvent être mutées sans appels supplémentaires aux diverses méthodes du module http liées aux en-têtes. Les clés de l'objet retourné sont les noms des en-têtes et les valeurs sont les valeurs des en-têtes respectives. Tous les noms d'en-têtes sont en minuscules.

L'objet retourné par la méthode request.getHeaders() n'hérite pas prototypiquement de l'objet JavaScript Object. Cela signifie que les méthodes Object typiques telles que obj.toString(), obj.hasOwnProperty(), et d'autres ne sont pas définies et ne fonctionneront pas.

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()`

Ajouté dans : v15.13.0, v14.17.0

Retourne : <string[]>

Retourne un tableau contenant les noms uniques des en-têtes brutes sortantes actuelles. Les noms d'en-têtes sont retournés avec leur casse exacte.

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

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

`request.hasHeader(name)`

Ajouté dans : v7.7.0

name <string>
Retourne : <boolean>

Retourne true si l'en-tête identifié par name est actuellement défini dans les en-têtes sortantes. La correspondance des noms d'en-têtes ne respecte pas la casse.

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

`request.maxHeadersCount`

<number> Défaut : 2000

Limite le nombre maximum d'en-têtes de réponse. Si défini à 0, aucune limite ne sera appliquée.

`request.path`

Ajouté dans : v0.4.0

<string> Le chemin de la requête.

`request.method`

Ajouté dans : v0.1.97

<string> La méthode de la requête.

`request.host`

Ajouté dans : v14.5.0, v12.19.0

<string> L'hôte de la requête.

`request.protocol`

Ajouté dans : v14.5.0, v12.19.0

<string> Le protocole de la requête.

`request.removeHeader(name)`

Ajouté dans : v1.6.0

name <string>

Supprime une en-tête déjà définie dans l'objet des en-têtes.

request.removeHeader('Content-Type')

`request.reusedSocket`

Ajouté dans : v13.0.0, v12.16.0

<booléen> Indique si la requête est envoyée via un socket réutilisé.

Lors de l'envoi d'une requête via un agent avec keep-alive activé, le socket sous-jacent peut être réutilisé. Mais si le serveur ferme la connexion à un moment inopportun, le client peut rencontrer une erreur 'ECONNRESET'.

ESMCJS

import http from 'node:http'

// Le serveur a un délai d'attente keep-alive de 5 secondes par défaut
http
  .createServer((req, res) => {
    res.write('hello\n')
    res.end()
  })
  .listen(3000)

setInterval(() => {
  // Adaptation d'un agent keep-alive
  http.get('http://localhost:3000', { agent }, res => {
    res.on('data', data => {
      // Ne rien faire
    })
  })
}, 5000) // Envoi de la requête toutes les 5 secondes pour faciliter l'atteinte du délai d'inactivité

const http = require('node:http')

// Le serveur a un délai d'attente keep-alive de 5 secondes par défaut
http
  .createServer((req, res) => {
    res.write('hello\n')
    res.end()
  })
  .listen(3000)

setInterval(() => {
  // Adaptation d'un agent keep-alive
  http.get('http://localhost:3000', { agent }, res => {
    res.on('data', data => {
      // Ne rien faire
    })
  })
}, 5000) // Envoi de la requête toutes les 5 secondes pour faciliter l'atteinte du délai d'inactivité

En indiquant si une requête a réutilisé un socket ou non, nous pouvons effectuer une nouvelle tentative d'erreur automatique en fonction de cela.

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 => {
      // Vérifier si une nouvelle tentative est nécessaire
      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 => {
      // Vérifier si une nouvelle tentative est nécessaire
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest()
      }
    })
}

retriableRequest()

`request.setHeader(name, value)`

Ajouté dans : v1.6.0

name <string>
value <any>

Définit une seule valeur d'en-tête pour l'objet d'en-têtes. Si cet en-tête existe déjà dans les en-têtes à envoyer, sa valeur sera remplacée. Utilisez un tableau de chaînes de caractères ici pour envoyer plusieurs en-têtes avec le même nom. Les valeurs non-chaînes seront stockées sans modification. Par conséquent, request.getHeader() peut renvoyer des valeurs non-chaînes. Cependant, les valeurs non-chaînes seront converties en chaînes de caractères pour la transmission réseau.

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

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

Lorsque la valeur est une chaîne de caractères, une exception sera levée si elle contient des caractères en dehors de l'encodage latin1.

Si vous devez passer des caractères UTF-8 dans la valeur, veuillez encoder la valeur en utilisant la norme RFC 8187.

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

`request.setNoDelay([noDelay])`

Ajouté dans : v0.5.9

noDelay <boolean>

Une fois qu'une socket est assignée à cette requête et qu'elle est connectée, socket.setNoDelay() sera appelé.

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

Ajouté dans : v0.5.9

enable <boolean>
initialDelay <number>

Une fois qu'une socket est assignée à cette requête et qu'elle est connectée, socket.setKeepAlive() sera appelé.

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

[Historique]

Version	Modifications
v9.0.0	Définit le délai d'expiration du socket de manière cohérente uniquement lorsque le socket se connecte.
v0.5.9	Ajouté dans : v0.5.9

timeout <number> Millisecondes avant l'expiration d'une requête.
callback <Function> Fonction optionnelle à appeler lorsqu'un délai d'expiration se produit. Identique à la liaison à l'événement 'timeout'.
Retourne : <http.ClientRequest>

Une fois qu'un socket est attribué à cette requête et qu'il est connecté, socket.setTimeout() sera appelé.

`request.socket`

Ajouté dans : v0.3.0

<stream.Duplex>

Référence au socket sous-jacent. Généralement, les utilisateurs ne voudront pas accéder à cette propriété. En particulier, le socket n'émettra pas d'événements 'readable' en raison de la manière dont l'analyseur de protocole est attaché au socket.

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(`Votre adresse IP est ${ip} et votre port source est ${port}.`)
  // Consommer l'objet de réponse
})

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(`Votre adresse IP est ${ip} et votre port source est ${port}.`)
  // Consommer l'objet de réponse
})

Cette propriété est garantie d'être une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur a spécifié un type de socket autre que <net.Socket>.

`request.uncork()`

Ajouté dans : v13.2.0, v12.16.0

Voir writable.uncork().

`request.writableEnded`

Ajouté dans : v12.9.0

<boolean>

Est true après l’appel de request.end(). Cette propriété n’indique pas si les données ont été vidées, utilisez request.writableFinished à la place.

`request.writableFinished`

Ajouté dans : v12.7.0

<boolean>

Est true si toutes les données ont été vidées vers le système sous-jacent, immédiatement avant l’émission de l’événement 'finish'.

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

[Historique]

Version	Modifications
v15.0.0	Le paramètre `chunk` peut maintenant être un `Uint8Array`.
v0.1.29	Ajouté dans : v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string>
callback <Function>
Retourne : <boolean>

Envoie un fragment du corps. Cette méthode peut être appelée plusieurs fois. Si aucune longueur de contenu n’est définie, les données seront automatiquement encodées en codage de transfert HTTP par fragments, afin que le serveur sache quand les données se terminent. L’en-tête Transfer-Encoding: chunked est ajouté. L’appel de request.end() est nécessaire pour terminer l’envoi de la requête.

L’argument encoding est facultatif et s’applique uniquement lorsque chunk est une chaîne de caractères. La valeur par défaut est 'utf8'.

L’argument callback est facultatif et sera appelé lorsque ce fragment de données est vidé, mais seulement si le fragment n’est pas vide.

Retourne true si toutes les données ont été vidées avec succès dans la mémoire tampon du noyau. Retourne false si toutes les données ou une partie des données ont été mises en file d’attente dans la mémoire utilisateur. 'drain' sera émis lorsque la mémoire tampon sera à nouveau libre.

Lorsque la fonction write est appelée avec une chaîne ou une mémoire tampon vide, elle ne fait rien et attend plus d’entrée.

Classe : `http.Server`

Ajouté dans : v0.1.17

Étend : <net.Server>

Événement : `'checkContinue'`

Ajouté dans : v0.3.0

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

Émis chaque fois qu'une requête avec un en-tête HTTP Expect: 100-continue est reçue. Si cet événement n'est pas écouté, le serveur répondra automatiquement avec un 100 Continue le cas échéant.

La gestion de cet événement implique d'appeler response.writeContinue() si le client doit continuer à envoyer le corps de la requête, ou de générer une réponse HTTP appropriée (par exemple, 400 Bad Request) si le client ne doit pas continuer à envoyer le corps de la requête.

Lorsque cet événement est émis et géré, l'événement 'request' ne sera pas émis.

Événement : `'checkExpectation'`

Ajouté dans : v5.5.0

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

Émis chaque fois qu'une requête avec un en-tête HTTP Expect est reçue, où la valeur n'est pas 100-continue. Si cet événement n'est pas écouté, le serveur répondra automatiquement avec un 417 Expectation Failed le cas échéant.

Lorsque cet événement est émis et géré, l'événement 'request' ne sera pas émis.

Événement : `'clientError'`

[Historique]

Version	Modifications
v12.0.0	Le comportement par défaut renverra un 431 Request Header Fields Too Large si une erreur HPE_HEADER_OVERFLOW se produit.
v9.4.0	Le `rawPacket` est le tampon actuel qui vient d'être analysé. L'ajout de ce tampon à l'objet d'erreur de l'événement `'clientError'` permet aux développeurs de consigner le paquet corrompu.
v6.0.0	L'action par défaut d'appeler `.destroy()` sur le `socket` n'aura plus lieu si des écouteurs sont attachés à `'clientError'`.
v0.1.94	Ajouté dans : v0.1.94

exception <Error>
socket <stream.Duplex>

Si une connexion client émet un événement 'error', elle sera transmise ici. L'écouteur de cet événement est responsable de la fermeture/destruction du socket sous-jacent. Par exemple, on peut souhaiter fermer plus gracieusement le socket avec une réponse HTTP personnalisée au lieu de couper brutalement la connexion. Le socket doit être fermé ou détruit avant la fin de l'écouteur.

Il est garanti que cet événement recevra une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur spécifie un type de socket autre que <net.Socket>.

Le comportement par défaut consiste à essayer de fermer le socket avec un '400 Bad Request' HTTP, ou un '431 Request Header Fields Too Large' HTTP dans le cas d'une erreur HPE_HEADER_OVERFLOW. Si le socket n'est pas inscriptible ou si les en-têtes du http.ServerResponse attaché actuel ont été envoyés, il est immédiatement détruit.

socket est l'objet net.Socket à l'origine de l'erreur.

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)

Lorsque l'événement 'clientError' se produit, il n'y a pas d'objet request ou response, donc toute réponse HTTP envoyée, y compris les en-têtes et la charge utile de la réponse, doit être écrite directement sur l'objet socket. Il faut veiller à ce que la réponse soit un message de réponse HTTP correctement formaté.

err est une instance de Error avec deux colonnes supplémentaires :

bytesParsed : le nombre d'octets du paquet de requête que Node.js a peut-être analysés correctement ;
rawPacket : le paquet brut de la requête actuelle.

Dans certains cas, le client a déjà reçu la réponse et/ou le socket a déjà été détruit, comme dans le cas des erreurs ECONNRESET. Avant d'essayer d'envoyer des données au socket, il est préférable de vérifier qu'il est toujours inscriptible.

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

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

Événement : `'close'`

Ajouté dans : v0.1.4

Émis lorsque le serveur se ferme.

Événement : `'connect'`

Ajouté dans : v0.7.0

request <http.IncomingMessage> Arguments pour la requête HTTP, tels qu'ils apparaissent dans l'événement 'request'
socket <stream.Duplex> Socket réseau entre le serveur et le client
head <Buffer> Le premier paquet du flux de tunneling (peut être vide)

Émis chaque fois qu'un client demande une méthode HTTP CONNECT. Si cet événement n'est pas écouté, les connexions des clients demandant une méthode CONNECT seront fermées.

Il est garanti que cet événement recevra une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur spécifie un type de socket autre que <net.Socket>.

Après l'émission de cet événement, la socket de la requête n'aura pas de listener d'événement 'data', ce qui signifie qu'elle devra être liée afin de gérer les données envoyées au serveur sur cette socket.

Événement : `'connection'`

Ajouté dans : v0.1.0

socket <stream.Duplex>

Cet événement est émis lorsqu'un nouveau flux TCP est établi. socket est généralement un objet de type net.Socket. Généralement, les utilisateurs ne voudront pas accéder à cet événement. En particulier, la socket n'émettra pas d'événements 'readable' en raison de la façon dont l'analyseur de protocole est attaché à la socket. La socket est également accessible à request.socket.

Cet événement peut également être émis explicitement par les utilisateurs pour injecter des connexions dans le serveur HTTP. Dans ce cas, tout flux Duplex peut être passé.

Si socket.setTimeout() est appelé ici, le délai d'expiration sera remplacé par server.keepAliveTimeout lorsque la socket a traité une requête (si server.keepAliveTimeout est non nul).

Il est garanti que cet événement recevra une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur spécifie un type de socket autre que <net.Socket>.

Événement : `'dropRequest'`

Ajouté dans : v18.7.0, v16.17.0

request <http.IncomingMessage> Arguments de la requête HTTP, tels qu'ils apparaissent dans l'événement 'request'
socket <stream.Duplex> Socket réseau entre le serveur et le client

Lorsque le nombre de requêtes sur une socket atteint le seuil de server.maxRequestsPerSocket, le serveur supprime les nouvelles requêtes et émet l'événement 'dropRequest' à la place, puis envoie un 503 au client.

Événement : `'request'`

Ajouté dans : v0.1.0

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

Émis à chaque requête. Il peut y avoir plusieurs requêtes par connexion (dans le cas des connexions HTTP Keep-Alive).

Événement : `'upgrade'`

[Historique]

Version	Modifications
v10.0.0	Ne plus écouter cet événement n'entraîne plus la destruction de la socket si un client envoie un en-tête Upgrade.
v0.1.94	Ajouté dans : v0.1.94

request <http.IncomingMessage> Arguments de la requête HTTP, tels qu'ils apparaissent dans l'événement 'request'
socket <stream.Duplex> Socket réseau entre le serveur et le client
head <Buffer> Le premier paquet du flux mis à niveau (peut être vide)

Émis chaque fois qu'un client demande une mise à niveau HTTP. L'écoute de cet événement est facultative et les clients ne peuvent pas insister sur un changement de protocole.

Après l'émission de cet événement, la socket de la requête n'aura pas d'écouteur d'événement 'data', ce qui signifie qu'il devra être lié afin de gérer les données envoyées au serveur sur cette socket.

Cet événement reçoit obligatoirement une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur spécifie un type de socket autre que <net.Socket>.

`server.close([callback])`

[Historique]

Version	Modifications
v19.0.0	La méthode ferme les connexions inactives avant de renvoyer la valeur.
v0.1.90	Ajouté dans : v0.1.90

callback <Function>

Empêche le serveur d'accepter de nouvelles connexions et ferme toutes les connexions connectées à ce serveur qui n'envoient pas de requête ou n'attendent pas de réponse. Voir 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)
// Fermer le serveur après 10 secondes
setTimeout(() => {
  server.close(() => {
    console.log('serveur sur le port 8000 fermé avec succès')
  })
}, 10000)

`server.closeAllConnections()`

Ajouté dans : v18.2.0

Ferme toutes les connexions HTTP(S) établies connectées à ce serveur, y compris les connexions actives connectées à ce serveur qui envoient une requête ou attendent une réponse. Cela ne détruit pas les sockets mises à niveau vers un protocole différent, tel que WebSocket ou 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)
// Fermer le serveur après 10 secondes
setTimeout(() => {
  server.close(() => {
    console.log('serveur sur le port 8000 fermé avec succès')
  })
  // Ferme toutes les connexions, garantissant la fermeture réussie du serveur
  server.closeAllConnections()
}, 10000)

`server.closeIdleConnections()`

Ajouté dans : v18.2.0

Ferme toutes les connexions connectées à ce serveur qui n'envoient pas de requête ou n'attendent pas de réponse.

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)
// Fermer le serveur après 10 secondes
setTimeout(() => {
  server.close(() => {
    console.log('serveur sur le port 8000 fermé avec succès')
  })
  // Ferme les connexions inactives, telles que les connexions keep-alive. Le serveur se fermera
  // une fois que les connexions actives restantes seront terminées
  server.closeIdleConnections()
}, 10000)

`server.headersTimeout`

[Historique]

Version	Modifications
v19.4.0, v18.14.0	La valeur par défaut est maintenant le minimum entre 60000 (60 secondes) ou `requestTimeout`.
v11.3.0, v10.14.0	Ajouté dans : v11.3.0, v10.14.0

<nombre> Défaut : Le minimum entre server.requestTimeout ou 60000.

Limite le temps d'attente du parseur pour recevoir les en-têtes HTTP complètes.

Si le délai d'attente expire, le serveur répond avec le statut 408 sans transférer la requête à l'écouteur de requête, puis ferme la connexion.

Il doit être défini sur une valeur non nulle (par exemple, 120 secondes) pour se protéger contre les attaques par déni de service potentielles si le serveur est déployé sans proxy inverse.

`server.listen()`

Démarre le serveur HTTP à l'écoute des connexions. Cette méthode est identique à server.listen() de net.Server.

`server.listening`

Ajouté dans : v5.7.0

<booléen> Indique si le serveur écoute les connexions ou non.

`server.maxHeadersCount`

Ajouté dans : v0.7.0

<nombre> Défaut : 2000

Limite le nombre maximal d'en-têtes entrantes. Si défini sur 0, aucune limite ne sera appliquée.

`server.requestTimeout`

[Historique]

Version	Modifications
v18.0.0	Le délai d'attente de requête par défaut est passé de pas de délai d'attente à 300 s (5 minutes).
v14.11.0	Ajouté dans : v14.11.0

<nombre> Défaut : 300000

Définit la valeur du délai d'attente en millisecondes pour la réception de la requête entière du client.

Si le délai d'attente expire, le serveur répond avec le statut 408 sans transférer la requête à l'écouteur de requête, puis ferme la connexion.

Il doit être défini sur une valeur non nulle (par exemple, 120 secondes) pour se protéger contre les attaques par déni de service potentielles si le serveur est déployé sans proxy inverse.

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

[Historique]

Version	Modifications
v13.0.0	Le délai d'expiration par défaut est passé de 120 s à 0 (pas de délai d'expiration).
v0.9.12	Ajouté dans : v0.9.12

msecs <number> Défaut : 0 (pas de délai d'expiration)
callback <Function>
Retourne : <http.Server>

Définit la valeur de délai d'expiration pour les sockets et émet un événement 'timeout' sur l'objet Server, en passant le socket comme argument, si un délai d'expiration se produit.

S'il existe un écouteur d'événements 'timeout' sur l'objet Server, il sera appelé avec le socket ayant dépassé le délai d'expiration comme argument.

Par défaut, le serveur ne définit pas de délai d'expiration pour les sockets. Cependant, si une fonction de rappel est affectée à l'événement 'timeout' du serveur, les délais d'expiration doivent être gérés explicitement.

`server.maxRequestsPerSocket`

Ajouté dans : v16.10.0

<number> Requêtes par socket. Défaut : 0 (pas de limite)

Le nombre maximal de requêtes qu'un socket peut gérer avant de fermer la connexion keep-alive.

Une valeur de 0 désactivera la limite.

Lorsque la limite est atteinte, la valeur de l'en-tête Connection sera définie sur close, mais la connexion ne sera pas réellement fermée. Les requêtes suivantes envoyées après que la limite a été atteinte recevront une réponse 503 Service Unavailable.

`server.timeout`

[Historique]

Version	Modifications
v13.0.0	Le délai d'expiration par défaut est passé de 120 s à 0 (pas de délai d'expiration).
v0.9.12	Ajouté dans : v0.9.12

<number> Délai d'expiration en millisecondes. Défaut : 0 (pas de délai d'expiration)

Le nombre de millisecondes d'inactivité avant qu'un socket ne soit considéré comme ayant dépassé le délai d'expiration.

Une valeur de 0 désactivera le comportement de délai d'expiration sur les connexions entrantes.

La logique de délai d'expiration du socket est configurée lors de la connexion. Ainsi, la modification de cette valeur n'affecte que les nouvelles connexions au serveur, et non les connexions existantes.

`server.keepAliveTimeout`

Ajouté dans : v8.0.0

<nombre> Délai en millisecondes. Défaut : 5000 (5 secondes).

Le nombre de millisecondes d'inactivité qu'un serveur doit attendre des données entrantes supplémentaires, après avoir terminé l'écriture de la dernière réponse, avant qu'un socket ne soit détruit. Si le serveur reçoit de nouvelles données avant l'expiration du délai d'attente keep-alive, il réinitialisera le délai d'inactivité régulier, c'est-à-dire server.timeout.

Une valeur de 0 désactivera le comportement de délai d'attente keep-alive sur les connexions entrantes. Une valeur de 0 fait que le serveur http se comporte de manière similaire aux versions de Node.js antérieures à 8.0.0, qui n'avaient pas de délai d'attente keep-alive.

La logique de délai d'attente du socket est configurée lors de la connexion. Par conséquent, la modification de cette valeur n'affecte que les nouvelles connexions au serveur, et non les connexions existantes.

`server[Symbol.asyncDispose]()`

Ajouté dans : v20.4.0

[Stable : 1 - Expérimental]

Stable : 1 Stabilité : 1 - Expérimental

Appelle server.close() et renvoie une promesse qui se réalise lorsque le serveur est fermé.

Classe : `http.ServerResponse`

Ajouté dans : v0.1.17

Étend : <http.OutgoingMessage>

Cet objet est créé en interne par un serveur HTTP, et non par l'utilisateur. Il est passé en second paramètre à l'événement 'request'.

Événement : `'close'`

Ajouté dans : v0.6.7

Indique que la réponse est terminée ou que sa connexion sous-jacente a été terminée prématurément (avant la fin de la réponse).

Événement : `'finish'`

Ajouté dans : v0.3.6

Émis lorsque la réponse a été envoyée. Plus précisément, cet événement est émis lorsque le dernier segment des en-têtes et du corps de la réponse a été transmis au système d'exploitation pour transmission sur le réseau. Cela n'implique pas que le client ait encore reçu quoi que ce soit.

`response.addTrailers(headers)`

Ajouté dans : v0.3.0

headers <Objet>

Cette méthode ajoute des en-têtes HTTP de fin (une en-tête, mais à la fin du message) à la réponse.

Les en-têtes de fin ne seront émises que si l'encodage par blocs est utilisé pour la réponse ; sinon (par exemple, si la requête était HTTP/1.0), elles seront silencieusement ignorées.

HTTP exige que l'en-tête Trailer soit envoyé afin d'émettre les en-têtes de fin, avec une liste des champs d'en-tête dans sa valeur. Par exemple :

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

Tenter de définir un nom de champ d'en-tête ou une valeur contenant des caractères invalides entraînera le lancement d'une erreur TypeError.

`response.connection`

Ajouté dans : v0.3.0

Déprécié depuis : v13.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Utilisez response.socket.

<stream.Duplex>

Voir response.socket.

`response.cork()`

Ajouté dans : v13.2.0, v12.16.0

Voir writable.cork().

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

[Historique]

Version	Modifications
v15.0.0	Le paramètre `data` peut maintenant être un `Uint8Array`.
v10.0.0	Cette méthode renvoie maintenant une référence à `ServerResponse`.
v0.1.90	Ajouté dans : v0.1.90

data <chaîne de caractères> | <Buffer> | <Uint8Array>
encoding <chaîne de caractères>
callback <Fonction>
Retourne : <this>

Cette méthode signale au serveur que toutes les en-têtes et le corps de la réponse ont été envoyés ; que le serveur doit considérer ce message comme complet. La méthode response.end() DOIT être appelée sur chaque réponse.

Si data est spécifié, cela a un effet similaire à l'appel de response.write(data, encoding) suivi de response.end(callback).

Si callback est spécifié, il sera appelé lorsque le flux de réponse est terminé.

`response.finished`

Ajouté dans : v0.0.2

Déprécié depuis : v13.4.0, v12.16.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Utilisez response.writableEnded.

<booléen>

La propriété response.finished aura la valeur true si response.end() a été appelée.

`response.flushHeaders()`

Ajouté dans : v1.6.0

Vide les en-têtes de réponse. Voir aussi : request.flushHeaders().

`response.getHeader(name)`

Ajouté dans : v0.4.0

name <chaîne de caractères>
Retourne : <any>

Lit une en-tête déjà mise en file d’attente mais non envoyée au client. Le nom ne respecte pas la casse. Le type de la valeur retournée dépend des arguments fournis à 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 est 'text/html'
const contentLength = response.getHeader('Content-Length')
// contentLength est de type number
const setCookie = response.getHeader('set-cookie')
// setCookie est de type string[]

`response.getHeaderNames()`

Ajouté dans : v7.7.0

Retourne : <tableau de chaînes de caractères>

Retourne un tableau contenant les noms uniques des en-têtes sortantes actuelles. Tous les noms d’en-têtes sont en minuscules.

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

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

`response.getHeaders()`

Ajouté dans : v7.7.0

Retourne : <Object>

Retourne une copie superficielle des en-têtes sortantes actuelles. Comme une copie superficielle est utilisée, les valeurs de tableau peuvent être mutées sans appels supplémentaires aux diverses méthodes du module http liées aux en-têtes. Les clés de l'objet retourné sont les noms des en-têtes et les valeurs sont les valeurs des en-têtes respectives. Tous les noms d'en-têtes sont en minuscules.

L'objet retourné par la méthode response.getHeaders() n'hérite pas prototypiquement de l'objet JavaScript Object. Cela signifie que les méthodes Object typiques telles que obj.toString(), obj.hasOwnProperty(), et d'autres ne sont pas définies et ne fonctionneront pas.

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)`

Ajouté dans : v7.7.0

name <string>
Retourne : <boolean>

Retourne true si l'en-tête identifié par name est actuellement défini dans les en-têtes sortantes. La correspondance du nom de l'en-tête ne respecte pas la casse.

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

`response.headersSent`

Ajouté dans : v0.9.3

<boolean>

Booléen (lecture seule). Vrai si les en-têtes ont été envoyées, faux sinon.

`response.removeHeader(name)`

Ajouté dans : v0.4.0

name <string>

Supprime une en-tête mise en file d'attente pour une envoi implicite.

response.removeHeader('Content-Encoding')

`response.req`

Ajouté dans : v15.7.0

<http.IncomingMessage>

Une référence à l'objet request HTTP original.

`response.sendDate`

Ajouté dans : v0.7.5

<booléen>

Si la valeur est vraie, l'en-tête Date sera automatiquement généré et envoyé dans la réponse s'il n'est pas déjà présent dans les en-têtes. La valeur par défaut est vraie.

Cela ne devrait être désactivé que pour les tests ; HTTP nécessite l'en-tête Date dans les réponses.

`response.setHeader(name, value)`

Ajouté dans : v0.4.0

Retourne l'objet de réponse.

Définit une seule valeur d'en-tête pour les en-têtes implicites. Si cet en-tête existe déjà dans les en-têtes à envoyer, sa valeur sera remplacée. Utilisez un tableau de chaînes de caractères ici pour envoyer plusieurs en-têtes avec le même nom. Les valeurs non-chaînes de caractères seront stockées sans modification. Par conséquent, response.getHeader() peut retourner des valeurs non-chaînes de caractères. Cependant, les valeurs non-chaînes de caractères seront converties en chaînes de caractères pour la transmission réseau. Le même objet de réponse est retourné à l'appelant, pour permettre l'enchaînement des appels.

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

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

Toute tentative de définir un nom ou une valeur de champ d'en-tête contenant des caractères invalides entraînera le déclenchement d'une erreur TypeError.

Lorsque les en-têtes ont été définis avec response.setHeader(), ils seront fusionnés avec tous les en-têtes passés à response.writeHead(), les en-têtes passés à response.writeHead() ayant la priorité.

// Retourne 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')
})

Si la méthode response.writeHead() est appelée et que cette méthode n'a pas été appelée, elle écrira directement les valeurs d'en-tête fournies sur le canal réseau sans mise en cache interne, et response.getHeader() sur l'en-tête ne donnera pas le résultat attendu. Si une population progressive des en-têtes est souhaitée avec une récupération et une modification futures potentielles, utilisez response.setHeader() au lieu de response.writeHead().

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

Ajouté dans : v0.9.12

msecs <number>
callback <Function>
Retourne : <http.ServerResponse>

Définit la valeur de délai d’attente du Socket à msecs. Si un rappel est fourni, il est ajouté comme écouteur à l’événement 'timeout' sur l’objet de réponse.

Si aucun écouteur 'timeout' n’est ajouté à la requête, à la réponse ou au serveur, les sockets sont détruits lorsqu’ils atteignent le délai d’attente. Si un gestionnaire est affecté aux événements 'timeout' de la requête, de la réponse ou du serveur, les sockets ayant atteint le délai d’attente doivent être gérés explicitement.

`response.socket`

Ajouté dans : v0.3.0

<stream.Duplex>

Référence au socket sous-jacent. Généralement, les utilisateurs ne voudront pas accéder à cette propriété. En particulier, le socket n’émettra pas d’événements 'readable' en raison de la façon dont l’analyseur de protocole est attaché au socket. Après response.end(), la propriété est annulée.

ESMCJS

import http from 'node:http'
const server = http
  .createServer((req, res) => {
    const ip = res.socket.remoteAddress
    const port = res.socket.remotePort
    res.end(`Votre adresse IP est ${ip} et votre port source est ${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(`Votre adresse IP est ${ip} et votre port source est ${port}.`)
  })
  .listen(3000)

Il est garanti que cette propriété est une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l’utilisateur a spécifié un type de socket autre que <net.Socket>.

`response.statusCode`

Ajouté dans : v0.4.0

<number> Défaut : 200

Lors de l’utilisation d’en-têtes implicites (sans appeler explicitement response.writeHead()), cette propriété contrôle le code d’état qui sera envoyé au client lorsque les en-têtes sont vidés.

response.statusCode = 404

Une fois que l’en-tête de réponse a été envoyé au client, cette propriété indique le code d’état qui a été envoyé.

`response.statusMessage`

Ajouté dans : v0.11.8

<string>

Lorsque des en-têtes implicites sont utilisées (sans appeler explicitement response.writeHead()), cette propriété contrôle le message d'état qui sera envoyé au client lorsque les en-têtes seront vidées. Si elle est laissée à undefined, le message standard pour le code d'état sera utilisé.

response.statusMessage = 'Not found'

Après que l'en-tête de réponse a été envoyé au client, cette propriété indique le message d'état qui a été envoyé.

`response.strictContentLength`

Ajouté dans : v18.10.0, v16.18.0

<boolean> Défaut : false

Si défini sur true, Node.js vérifiera si la valeur de l'en-tête Content-Length et la taille du corps, en octets, sont égales. Une non-correspondance de la valeur de l'en-tête Content-Length entraînera le lancement d'une erreur, identifiée par code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'.

`response.uncork()`

Ajouté dans : v13.2.0, v12.16.0

Voir writable.uncork().

`response.writableEnded`

Ajouté dans : v12.9.0

<boolean>

Est true après l'appel de response.end(). Cette propriété n'indique pas si les données ont été vidées ; utilisez response.writableFinished à la place.

`response.writableFinished`

Ajouté dans : v12.7.0

<boolean>

Est true si toutes les données ont été vidées vers le système sous-jacent, immédiatement avant l'émission de l'événement 'finish'.

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

[Historique]

Version	Modifications
v15.0.0	Le paramètre `chunk` peut maintenant être un `Uint8Array`.
v0.1.29	Ajouté dans : v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> Défaut : 'utf8'
callback <Function>
Retourne : <boolean>

Si cette méthode est appelée et que response.writeHead() n'a pas été appelée, elle passera en mode d'en-tête implicite et videra les en-têtes implicites.

Ceci envoie un fragment du corps de la réponse. Cette méthode peut être appelée plusieurs fois pour fournir des parties successives du corps.

Si rejectNonStandardBodyWrites est défini sur true dans createServer, l'écriture dans le corps n'est pas autorisée lorsque la méthode de requête ou le statut de réponse ne prennent pas en charge le contenu. Si une tentative est faite d'écrire dans le corps pour une requête HEAD ou dans le cadre d'une réponse 204 ou 304, une erreur synchrone avec le code ERR_HTTP_BODY_NOT_ALLOWED est levée.

chunk peut être une chaîne ou une mémoire tampon. Si chunk est une chaîne, le second paramètre spécifie comment l'encoder en un flux d'octets. callback sera appelé lorsque ce fragment de données sera vidé.

Il s'agit du corps HTTP brut et n'a rien à voir avec les encodages de corps multi-parties de niveau supérieur qui peuvent être utilisés.

La première fois que response.write() est appelée, elle enverra les informations d'en-tête mises en mémoire tampon et le premier fragment du corps au client. La deuxième fois que response.write() est appelée, Node.js suppose que les données seront transmises en continu et envoie les nouvelles données séparément. C'est-à-dire que la réponse est mise en mémoire tampon jusqu'au premier fragment du corps.

Retourne true si toutes les données ont été vidées avec succès dans la mémoire tampon du noyau. Retourne false si toutes les données ou une partie des données ont été mises en file d'attente dans la mémoire utilisateur. 'drain' sera émis lorsque la mémoire tampon sera à nouveau libre.

`response.writeContinue()`

Ajouté dans : v0.3.0

Envoie un message HTTP/1.1 100 Continue au client, indiquant que le corps de la requête doit être envoyé. Voir l'événement 'checkContinue' sur Server.

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

[Historique]

Version	Modifications
v18.11.0	Autorise le passage des indices sous forme d'objet.
v18.11.0	Ajouté dans : v18.11.0

hints <Objet>
callback <Fonction>

Envoie un message HTTP/1.1 103 Early Hints au client avec un en-tête Link, indiquant que l'agent utilisateur peut précharger/préconnecter les ressources liées. hints est un objet contenant les valeurs des en-têtes à envoyer avec le message Early Hints. L'argument callback optionnel sera appelé une fois le message de réponse écrit.

Exemple

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 pour les diagnostics',
})

const earlyHintsCallback = () => console.log('message Early Hints envoyé')
response.writeEarlyHints(
  {
    link: earlyHintsLinks,
  },
  earlyHintsCallback
)

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

[Historique]

Version	Modifications
v14.14.0	Autorise le passage des en-têtes sous forme de tableau.
v11.10.0, v10.17.0	Retourne `this` depuis `writeHead()` pour permettre l'enchaînement avec `end()`.
v5.11.0, v4.4.5	Une `RangeError` est levée si `statusCode` n'est pas un nombre compris dans la plage `[100, 999]`.
v0.1.30	Ajouté dans : v0.1.30

statusCode <nombre>
statusMessage <chaîne de caractères>
headers <Objet> | <Tableau>
Retourne : <http.ServerResponse>

Envoie un en-tête de réponse à la requête. Le code de statut est un code de statut HTTP à 3 chiffres, comme 404. Le dernier argument, headers, correspond aux en-têtes de réponse. On peut éventuellement fournir un statusMessage lisible par l'homme comme deuxième argument.

headers peut être un Tableau où les clés et les valeurs figurent dans la même liste. Ce n'est pas une liste de tuples. Ainsi, les décalages pairs sont des valeurs clés, et les décalages impairs sont les valeurs associées. Le tableau est au même format que request.rawHeaders.

Retourne une référence à ServerResponse, afin que les appels puissent être enchaînés.

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

Cette méthode ne doit être appelée qu'une seule fois sur un message et elle doit être appelée avant l'appel de response.end().

Si response.write() ou response.end() sont appelés avant cet appel, les en-têtes implicites/mutables seront calculés et cette fonction sera appelée.

Si cette méthode est appelée et que response.setHeader() n'a pas été appelée, elle écrira directement les valeurs d'en-tête fournies sur le canal réseau sans mise en cache interne, et response.getHeader() sur l'en-tête ne donnera pas le résultat attendu. Si une population progressive des en-têtes est souhaitée avec une récupération et une modification futures potentielles, utilisez plutôt response.setHeader().

// Retourne 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 est lu en octets, pas en caractères. Utilisez Buffer.byteLength() pour déterminer la longueur du corps en octets. Node.js vérifiera si Content-Length et la longueur du corps qui a été transmis sont égaux ou non.

Toute tentative de définir un nom ou une valeur de champ d'en-tête contenant des caractères invalides entraînera le lancement d'une exception [Error][].

`response.writeProcessing()`

Ajouté dans : v10.0.0

Envoie un message HTTP/1.1 102 Processing au client, indiquant que le corps de la requête doit être envoyé.

Classe : `http.IncomingMessage`

[Historique]

Version	Modifications
v15.5.0	La valeur `destroyed` renvoie `true` après la consommation des données entrantes.
v13.1.0, v12.16.0	La valeur `readableHighWaterMark` reflète celle du socket.
v0.1.17	Ajouté dans : v0.1.17

Extend : <stream.Readable>

Un objet IncomingMessage est créé par http.Server ou http.ClientRequest et passé comme premier argument à l'événement 'request' et 'response' respectivement. Il peut être utilisé pour accéder au statut, aux en-têtes et aux données de la réponse.

Contrairement à sa valeur socket qui est une sous-classe de <stream.Duplex>, IncomingMessage lui-même étend <stream.Readable> et est créé séparément pour analyser et émettre les en-têtes et la charge utile HTTP entrantes, car le socket sous-jacent peut être réutilisé plusieurs fois en cas de keep-alive.

Événement : `'aborted'`

Ajouté dans : v0.3.8

Déprécié depuis : v17.0.0, v16.12.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Écouter l'événement 'close' à la place.

Émis lorsque la requête a été interrompue.

Événement : `'close'`

[Historique]

Version	Modifications
v16.0.0	L'événement close est maintenant émis lorsque la requête est terminée et non lorsque le socket sous-jacent est fermé.
v0.4.2	Ajouté dans : v0.4.2

Émis lorsque la requête est terminée.

`message.aborted`

Ajouté dans : v10.1.0

Déprécié depuis : v17.0.0, v16.12.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Vérifier message.destroyed depuis <stream.Readable>.

<boolean>

La propriété message.aborted sera true si la requête a été interrompue.

`message.complete`

Ajouté dans : v0.3.0

<booléen>

La propriété message.complete aura la valeur true si un message HTTP complet a été reçu et analysé avec succès.

Cette propriété est particulièrement utile pour déterminer si un client ou un serveur a entièrement transmis un message avant la fermeture d'une connexion :

const req = http.request(
  {
    host: '127.0.0.1',
    port: 8080,
    method: 'POST',
  },
  res => {
    res.resume()
    res.on('end', () => {
      if (!res.complete)
        console.error("La connexion a été interrompue alors que le message était encore en cours d'envoi")
    })
  }
)

`message.connection`

Ajouté dans : v0.1.90

Déprécié depuis : v16.0.0

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié. Utilisez message.socket.

Alias de message.socket.

`message.destroy([error])`

[Historique]

Version	Modifications
v14.5.0, v12.19.0	La fonction renvoie `this` pour plus de cohérence avec les autres flux lisibles.
v0.3.0	Ajouté dans : v0.3.0

error <Erreur>
Retourne : <this>

Appelle destroy() sur le socket qui a reçu le IncomingMessage. Si error est fourni, un événement 'error' est émis sur le socket et error est passé comme argument à tous les écouteurs de l'événement.

`message.headers`

[Historique]

Version	Modifications
v19.5.0, v18.14.0	L'option `joinDuplicateHeaders` dans les fonctions `http.request()` et `http.createServer()` garantit que les en-têtes en double ne sont pas supprimés, mais plutôt combinés à l'aide d'une virgule comme séparateur, conformément à la section 5.3 de la RFC 9110.
v15.1.0	`message.headers` est désormais calculé de manière paresseuse à l'aide d'une propriété d'accès sur le prototype et n'est plus énumérable.
v0.1.5	Ajouté dans : v0.1.5

<Objet>

L'objet des en-têtes de requête/réponse.

Paires clé-valeur des noms et des valeurs des en-têtes. Les noms des en-têtes sont en minuscules.

// Affiche quelque chose comme :
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers)

Les doublons dans les en-têtes brutes sont gérés des manières suivantes, selon le nom de l'en-tête :

Les doublons de 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, ou user-agent sont supprimés. Pour autoriser la jointure de valeurs dupliquées des en-têtes énumérés ci-dessus, utilisez l'option joinDuplicateHeaders dans http.request() et http.createServer(). Consultez la section 5.3 de la RFC 9110 pour plus d'informations.
set-cookie est toujours un tableau. Les doublons sont ajoutés au tableau.
Pour les en-têtes cookie en double, les valeurs sont jointes avec ; .
Pour tous les autres en-têtes, les valeurs sont jointes avec , .

`message.headersDistinct`

Ajouté dans : v18.3.0, v16.17.0

<Object>

Similaire à message.headers, mais il n'y a pas de logique de jointure et les valeurs sont toujours des tableaux de chaînes de caractères, même pour les en-têtes reçus une seule fois.

// Affiche quelque chose comme :
//
// { 'user-agent': ['curl/7.22.0'],
//   host: ['127.0.0.1:8000'],
//   accept: ['*/*'] }
console.log(request.headersDistinct)

`message.httpVersion`

Ajouté dans : v0.1.1

<string>

Dans le cas d'une requête serveur, la version HTTP envoyée par le client. Dans le cas d'une réponse client, la version HTTP du serveur connecté. Probablement soit '1.1' soit '1.0'.

Aussi message.httpVersionMajor est le premier entier et message.httpVersionMinor est le second.

`message.method`

Ajouté dans : v0.1.1

<string>

Valide uniquement pour les requêtes obtenues depuis http.Server.

La méthode de requête sous forme de chaîne de caractères. Lecture seule. Exemples : 'GET', 'DELETE'.

`message.rawHeaders`

Ajouté dans : v0.11.6

<string[]>

La liste brute des en-têtes de requête/réponse exactement telle qu'elle a été reçue.

Les clés et les valeurs sont dans la même liste. Ce n'est pas une liste de tuples. Ainsi, les décalages pairs sont des valeurs clés, et les décalages impairs sont les valeurs associées.

Les noms d'en-tête ne sont pas mis en minuscules, et les doublons ne sont pas fusionnés.

// Affiche quelque chose comme :
//
// [ '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`

Ajouté dans : v0.11.6

<string[]>

Les clés et valeurs brutes des en-têtes de requête/réponse exactement telles qu'elles ont été reçues. Rempli uniquement lors de l'événement 'end'.

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

Ajouté dans : v0.5.9

msecs <number>
callback <Function>
Retourne : <http.IncomingMessage>

Appelez message.socket.setTimeout(msecs, callback).

`message.socket`

Ajouté dans : v0.3.0

<stream.Duplex>

L'objet net.Socket associé à la connexion.

Avec la prise en charge HTTPS, utilisez request.socket.getPeerCertificate() pour obtenir les détails d'authentification du client.

Cette propriété est garantie comme étant une instance de la classe <net.Socket>, une sous-classe de <stream.Duplex>, sauf si l'utilisateur a spécifié un type de socket autre que <net.Socket> ou annulé en interne.

`message.statusCode`

Ajouté dans : v0.1.1

<number>

Valide uniquement pour la réponse obtenue à partir de http.ClientRequest.

Le code de statut de réponse HTTP à 3 chiffres. Par exemple : 404.

`message.statusMessage`

Ajouté dans : v0.11.10

<string>

Valide uniquement pour la réponse obtenue à partir de http.ClientRequest.

Le message de statut de réponse HTTP (phrase de raison). Par exemple : OK ou Internal Server Error.

`message.trailers`

Ajouté dans : v0.3.0

<Object>

L'objet des en-têtes de fin de requête/réponse. Rempli uniquement lors de l'événement 'end'.

`message.trailersDistinct`

Ajouté dans : v18.3.0, v16.17.0

<Object>

Similaire à message.trailers, mais il n'y a pas de logique de jointure et les valeurs sont toujours des tableaux de chaînes, même pour les en-têtes reçus une seule fois. Rempli uniquement lors de l'événement 'end'.

`message.url`

Ajouté dans : v0.1.90

<string>

Valide uniquement pour les requêtes obtenues depuis http.Server.

Chaîne d'URL de la requête. Cela contient uniquement l'URL présente dans la requête HTTP réelle. Prenons la requête suivante :

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

Pour analyser l'URL en ses parties :

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

Lorsque request.url est '/status?name=ryan' et que process.env.HOST est indéfini :

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: ''
}

Assurez-vous de définir process.env.HOST sur le nom d'hôte du serveur, ou envisagez de remplacer complètement cette partie. Si vous utilisez req.headers.host, assurez-vous qu'une validation appropriée est utilisée, car les clients peuvent spécifier un en-tête Host personnalisé.

Classe : `http.OutgoingMessage`

Ajouté dans : v0.1.17

Étend : <Stream>

Cette classe sert de classe parente à http.ClientRequest et http.ServerResponse. Il s'agit d'un message sortant abstrait du point de vue des participants d'une transaction HTTP.

Événement : `'drain'`

Ajouté dans : v0.3.6

Émis lorsque la mémoire tampon du message est à nouveau libre.

Événement : `'finish'`

Ajouté dans : v0.1.17

Émis lorsque la transmission est terminée avec succès.

Événement : `'prefinish'`

Ajouté dans : v0.11.6

Émis après l'appel de outgoingMessage.end(). Lorsque l'événement est émis, toutes les données ont été traitées mais pas forcément complètement vidées.

`outgoingMessage.addTrailers(headers)`

Ajouté dans : v0.3.0

headers <Objet>

Ajoute des en-têtes de fin de message (en-têtes, mais à la fin du message) au message.

Les en-têtes de fin de message ne seront émis que si le message est encodé par blocs. Sinon, les en-têtes de fin de message seront silencieusement ignorés.

HTTP exige que l'en-tête Trailer soit envoyé pour émettre les en-têtes de fin de message, avec une liste de noms de champs d'en-tête dans sa valeur, par exemple :

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

Toute tentative de définir un nom de champ d'en-tête ou une valeur contenant des caractères invalides entraînera le lancement d'une erreur TypeError.

`outgoingMessage.appendHeader(name, value)`

Ajouté dans : v18.3.0, v16.17.0

name <chaîne de caractères> Nom de l'en-tête
value <chaîne de caractères> | <tableau de chaînes de caractères> Valeur de l'en-tête
Retourne : <this>

Ajoute une seule valeur d'en-tête à l'objet d'en-tête.

Si la valeur est un tableau, cela équivaut à appeler cette méthode plusieurs fois.

S'il n'y avait pas de valeurs précédentes pour l'en-tête, cela équivaut à appeler outgoingMessage.setHeader(name, value).

En fonction de la valeur de options.uniqueHeaders lors de la création de la requête client ou du serveur, cela se traduira par l'envoi de l'en-tête plusieurs fois ou une seule fois avec des valeurs jointes à l'aide de ; .

`outgoingMessage.connection`

Ajouté dans : v0.3.0

Déprécié depuis : v15.12.0, v14.17.1

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié : Utilisez outgoingMessage.socket à la place.

Alias de outgoingMessage.socket.

`outgoingMessage.cork()`

Ajouté dans : v13.2.0, v12.16.0

Voir writable.cork().

`outgoingMessage.destroy([error])`

Ajouté dans : v0.3.0

error <Error> Optionnel, une erreur à émettre avec l'événement error
Retourne : <this>

Détruit le message. Une fois qu'un socket est associé au message et connecté, ce socket sera également détruit.

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

[Historique]

Version	Modifications
v15.0.0	Le paramètre `chunk` peut maintenant être un `Uint8Array`.
v0.11.6	Ajout de l'argument `callback`.
v0.1.90	Ajouté dans : v0.1.90

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> Optionnel, Par défaut : utf8
callback <Function> Optionnel
Retourne : <this>

Termine le message sortant. Si des parties du corps ne sont pas envoyées, il les videra vers le système sous-jacent. Si le message est fragmenté, il enverra le fragment de terminaison 0\r\n\r\n, et enverra les en-têtes (le cas échéant).

Si chunk est spécifié, cela équivaut à appeler outgoingMessage.write(chunk, encoding), suivi de outgoingMessage.end(callback).

Si callback est fourni, il sera appelé lorsque le message sera terminé (équivalent à un écouteur de l'événement 'finish').

`outgoingMessage.flushHeaders()`

Ajouté dans : v1.6.0

Vide les en-têtes du message.

Pour des raisons d'efficacité, Node.js met généralement en mémoire tampon les en-têtes du message jusqu'à ce que outgoingMessage.end() soit appelé ou que le premier fragment de données du message soit écrit. Il essaie ensuite d'empaqueter les en-têtes et les données dans un seul paquet TCP.

C'est généralement souhaité (cela économise un aller-retour TCP), mais pas lorsque les premières données ne sont pas envoyées avant beaucoup plus tard. outgoingMessage.flushHeaders() contourne l'optimisation et lance le message.

`outgoingMessage.getHeader(name)`

Ajouté dans : v0.4.0

name <string> Nom de l'en-tête
Retourne : <string> | <undefined>

Récupère la valeur de l'en-tête HTTP avec le nom donné. Si cet en-tête n'est pas défini, la valeur retournée sera undefined.

`outgoingMessage.getHeaderNames()`

Ajouté dans : v7.7.0

Retourne : <string[]>

Retourne un tableau contenant les noms uniques des en-têtes sortants actuels. Tous les noms sont en minuscules.

`outgoingMessage.getHeaders()`

Ajouté dans : v7.7.0

Retourne : <Object>

Retourne une copie superficielle des en-têtes sortants actuels. Comme une copie superficielle est utilisée, les valeurs de tableau peuvent être mutées sans appels supplémentaires aux diverses méthodes du module HTTP liées aux en-têtes. Les clés de l'objet retourné sont les noms des en-têtes et les valeurs sont les valeurs des en-têtes respectives. Tous les noms d'en-têtes sont en minuscules.

L'objet retourné par la méthode outgoingMessage.getHeaders() n'hérite pas prototypiquement de l'objet JavaScript Object. Cela signifie que les méthodes Object typiques telles que obj.toString(), obj.hasOwnProperty(), et d'autres ne sont pas définies et ne fonctionneront pas.

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)`

Ajouté dans : v7.7.0

name <string>
Retourne : <boolean>

Retourne true si l'en-tête identifié par name est actuellement défini dans les en-têtes sortants. Le nom de l'en-tête ne respecte pas la casse.

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

`outgoingMessage.headersSent`

Ajouté dans : v0.9.3

<boolean>

Lecture seule. true si les en-têtes ont été envoyés, sinon false.

`outgoingMessage.pipe()`

Ajouté dans : v9.0.0

Surcharge la méthode stream.pipe() héritée de la classe Stream héritée, qui est la classe parente de http.OutgoingMessage.

L'appel de cette méthode lèvera une erreur Error car outgoingMessage est un flux en écriture seule.

`outgoingMessage.removeHeader(name)`

Ajouté dans : v0.4.0

name <string> Nom de l'en-tête

Supprime un en-tête mis en file d'attente pour une envoi implicite.

outgoingMessage.removeHeader('Content-Encoding')

`outgoingMessage.setHeader(name, value)`

Ajouté dans : v0.4.0

name <string> Nom de l'en-tête
value <any> Valeur de l'en-tête
Retourne : <this>

Définit une seule valeur d'en-tête. Si l'en-tête existe déjà dans les en-têtes à envoyer, sa valeur sera remplacée. Utilisez un tableau de chaînes pour envoyer plusieurs en-têtes avec le même nom.

`outgoingMessage.setHeaders(headers)`

Ajouté dans : v19.6.0, v18.15.0

headers <Headers> | <Map>
Retourne : <this>

Définit plusieurs valeurs d'en-tête pour les en-têtes implicites. headers doit être une instance de Headers ou Map, si un en-tête existe déjà dans les en-têtes à envoyer, sa valeur sera remplacée.

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

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

Lorsque les en-têtes ont été définis avec outgoingMessage.setHeaders(), ils seront fusionnés avec tous les en-têtes passés à response.writeHead(), les en-têtes passés à response.writeHead() ayant la priorité.

// Retourne 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])`

Ajouté dans : v0.9.12

msesc <number>
callback <Function> Fonction optionnelle appelée en cas de dépassement de délai. Identique à la liaison à l'événement timeout.
Retourne : <this>

Une fois qu'un socket est associé au message et connecté, socket.setTimeout() sera appelé avec msecs comme premier paramètre.

`outgoingMessage.socket`

Ajouté dans : v0.3.0

<stream.Duplex>

Référence au socket sous-jacent. Généralement, les utilisateurs ne voudront pas accéder à cette propriété.

Après avoir appelé outgoingMessage.end(), cette propriété sera annulée.

`outgoingMessage.uncork()`

Ajouté dans : v13.2.0, v12.16.0

Voir writable.uncork()

`outgoingMessage.writableCorked`

Ajouté dans : v13.2.0, v12.16.0

<number>

Le nombre de fois où outgoingMessage.cork() a été appelé.

`outgoingMessage.writableEnded`

Ajouté dans : v12.9.0

<boolean>

Est true si outgoingMessage.end() a été appelé. Cette propriété n'indique pas si les données ont été vidées. À cette fin, utilisez plutôt message.writableFinished.

`outgoingMessage.writableFinished`

Ajouté dans : v12.7.0

<boolean>

Est true si toutes les données ont été vidées vers le système sous-jacent.

`outgoingMessage.writableHighWaterMark`

Ajouté dans : v12.9.0

<number>

Le highWaterMark du socket sous-jacent s'il est affecté. Sinon, le niveau de tampon par défaut lorsque writable.write() commence à retourner false (16384).

`outgoingMessage.writableLength`

Ajouté dans : v12.9.0

<nombre>

Le nombre d'octets en tampon.

`outgoingMessage.writableObjectMode`

Ajouté dans : v12.9.0

<booléen>

Toujours false.

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

[Historique]

Version	Modifications
v15.0.0	Le paramètre `chunk` peut maintenant être un `Uint8Array`.
v0.11.6	L'argument `callback` a été ajouté.
v0.1.29	Ajouté dans : v0.1.29

chunk <chaîne de caractères> | <Buffer> | <Uint8Array>
encoding <chaîne de caractères> Défaut : utf8
callback <Fonction>
Retourne : <booléen>

Envoie un fragment du corps. Cette méthode peut être appelée plusieurs fois.

L'argument encoding n'est pertinent que lorsque chunk est une chaîne de caractères. La valeur par défaut est 'utf8'.

L'argument callback est facultatif et sera appelé lorsque ce fragment de données sera vidé.

Retourne true si toutes les données ont été vidées avec succès dans le tampon du noyau. Retourne false si toutes les données ou une partie des données ont été mises en file d'attente dans la mémoire utilisateur. L'événement 'drain' sera émis lorsque le tampon sera de nouveau libre.

`http.METHODS`

Ajouté dans : v0.11.8

<tableau de chaînes de caractères>

Une liste des méthodes HTTP prises en charge par l'analyseur.

`http.STATUS_CODES`

Ajouté dans : v0.1.22

<Objet>

Une collection de tous les codes de statut de réponse HTTP standard, et la brève description de chacun. Par exemple, http.STATUS_CODES[404] === 'Not Found'.

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

[Historique]

Version	Modifications
v20.1.0, v18.17.0	L'option `highWaterMark` est désormais prise en charge.
v18.0.0	Les options `requestTimeout`, `headersTimeout`, `keepAliveTimeout` et `connectionsCheckingInterval` sont désormais prises en charge.
v18.0.0	L'option `noDelay` a désormais la valeur par défaut `true`.
v17.7.0, v16.15.0	Les options `noDelay`, `keepAlive` et `keepAliveInitialDelay` sont désormais prises en charge.
v13.3.0	L'option `maxHeaderSize` est désormais prise en charge.
v13.8.0, v12.15.0, v10.19.0	L'option `insecureHTTPParser` est désormais prise en charge.
v9.6.0, v8.12.0	L'argument `options` est désormais pris en charge.
v0.1.13	Ajouté dans : v0.1.13

options <Objet>
- connectionsCheckingInterval: Définit la valeur de l'intervalle en millisecondes pour vérifier le délai d'expiration des requêtes et des en-têtes dans les requêtes incomplètes. Valeur par défaut : 30000.
- headersTimeout: Définit la valeur du délai d'expiration en millisecondes pour la réception des en-têtes HTTP complètes du client. Consultez server.headersTimeout pour plus d'informations. Valeur par défaut : 60000.
- highWaterMark <nombre> Surcharge éventuellement readableHighWaterMark et writableHighWaterMark de tous les socket. Cela affecte la propriété highWaterMark de IncomingMessage et ServerResponse. Valeur par défaut : Consultez stream.getDefaultHighWaterMark().
- insecureHTTPParser <booléen> S'il est défini sur true, il utilisera un analyseur HTTP avec des indicateurs de tolérance activés. L'utilisation de l'analyseur non sécurisé doit être évitée. Consultez --insecure-http-parser pour plus d'informations. Valeur par défaut : false.
- IncomingMessage <http.IncomingMessage> Spécifie la classe IncomingMessage à utiliser. Utile pour étendre le IncomingMessage d'origine. Valeur par défaut : IncomingMessage.
- joinDuplicateHeaders <booléen> S'il est défini sur true, cette option permet de joindre les valeurs de ligne de champ de plusieurs en-têtes dans une requête avec une virgule (, ) au lieu de supprimer les doublons. Pour plus d'informations, reportez-vous à message.headers. Valeur par défaut : false.
- keepAlive <booléen> S'il est défini sur true, il active la fonctionnalité keep-alive sur le socket immédiatement après la réception d'une nouvelle connexion entrante, de manière similaire à ce qui est fait dans [socket.setKeepAlive([enable][, initialDelay])][socket.setKeepAlive(enable, initialDelay)]. Valeur par défaut : false.
- keepAliveInitialDelay <nombre> S'il est défini sur un nombre positif, il définit le délai initial avant l'envoi de la première sonde keepalive sur un socket inactif. Valeur par défaut : 0.
- keepAliveTimeout: Le nombre de millisecondes d'inactivité qu'un serveur doit attendre des données entrantes supplémentaires, après avoir terminé l'écriture de la dernière réponse, avant qu'un socket ne soit détruit. Consultez server.keepAliveTimeout pour plus d'informations. Valeur par défaut : 5000.
- maxHeaderSize <nombre> Surcharge éventuellement la valeur de --max-http-header-size pour les requêtes reçues par ce serveur, c'est-à-dire la longueur maximale des en-têtes de requête en octets. Valeur par défaut : 16384 (16 Ko).
- noDelay <booléen> S'il est défini sur true, il désactive l'utilisation de l'algorithme de Nagle immédiatement après la réception d'une nouvelle connexion entrante. Valeur par défaut : true.
- requestTimeout: Définit la valeur du délai d'expiration en millisecondes pour la réception de la requête entière du client. Consultez server.requestTimeout pour plus d'informations. Valeur par défaut : 300000.
- requireHostHeader <booléen> S'il est défini sur true, il force le serveur à répondre avec un code d'état 400 (Mauvaise requête) à tout message de requête HTTP/1.1 qui manque d'en-tête Host (comme le prescrit la spécification). Valeur par défaut : true.
- ServerResponse <http.ServerResponse> Spécifie la classe ServerResponse à utiliser. Utile pour étendre le ServerResponse d'origine. Valeur par défaut : ServerResponse.
- uniqueHeaders <Tableau> Une liste d'en-têtes de réponse qui ne doivent être envoyées qu'une seule fois. Si la valeur de l'en-tête est un tableau, les éléments seront joints à l'aide de ; .
- rejectNonStandardBodyWrites <booléen> S'il est défini sur true, une erreur est levée lors de l'écriture dans une réponse HTTP qui n'a pas de corps. Valeur par défaut : false.
requestListener <Fonction>
Retourne : <http.Server>

Retourne une nouvelle instance de http.Server.

Le requestListener est une fonction qui est automatiquement ajoutée à l'événement 'request'.

ESMCJS

import http from 'node:http'

// Créer un serveur local pour recevoir des données de
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')

// Créer un serveur local pour recevoir des données de
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'

// Créer un serveur local pour recevoir des données de
const server = http.createServer()

// Écouter l'événement 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')

// Créer un serveur local pour recevoir des données de
const server = http.createServer()

// Écouter l'événement 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])`

[Historique]

Version	Modifications
v10.9.0	Le paramètre `url` peut maintenant être passé avec un objet `options` séparé.
v7.5.0	Le paramètre `options` peut être un objet `URL` WHATWG.
v0.3.6	Ajouté dans : v0.3.6

url <string> | <URL>
options <Object> Accepte les mêmes options que http.request(), avec la méthode définie sur GET par défaut.
callback <Function>
Retourne : <http.ClientRequest>

La plupart des requêtes étant des requêtes GET sans corps, Node.js fournit cette méthode pratique. La seule différence entre cette méthode et http.request() est qu'elle définit la méthode sur GET par défaut et appelle automatiquement req.end(). Le callback doit veiller à consommer les données de la réponse pour les raisons indiquées dans la section http.ClientRequest.

Le callback est appelé avec un seul argument qui est une instance de http.IncomingMessage.

Exemple d'extraction JSON :

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

    let error
    // Tout code de statut 2xx signale une réponse réussie, mais
    // ici, nous ne vérifions que 200.
    if (statusCode !== 200) {
      error = new Error('Requête échouée.\n' + `Code de statut : ${statusCode}`)
    } else if (!/^application\/json/.test(contentType)) {
      error = new Error('Type de contenu invalide.\n' + `Attendu application/json mais reçu ${contentType}`)
    }
    if (error) {
      console.error(error.message)
      // Consommer les données de la réponse pour libérer de la mémoire
      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(`Erreur reçue : ${e.message}`)
  })

// Créer un serveur local pour recevoir les données de
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`

[Historique]

Version	Modifications
v19.0.0	L'agent utilise désormais HTTP Keep-Alive et un délai d'expiration de 5 secondes par défaut.
v0.5.9	Ajouté dans : v0.5.9

<http.Agent>

Instance globale de Agent utilisée par défaut pour toutes les requêtes client HTTP. Diffère d'une configuration Agent par défaut en ayant keepAlive activé et un timeout de 5 secondes.

`http.maxHeaderSize`

Ajouté dans : v11.6.0, v10.15.0

<nombre>

Propriété en lecture seule spécifiant la taille maximale autorisée des en-têtes HTTP en octets. La valeur par défaut est 16 Ko. Configurable à l'aide de l'option CLI --max-http-header-size.

Ceci peut être remplacé pour les serveurs et les requêtes client en passant l'option maxHeaderSize.

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

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

[Historique]

Version	Modifications
v16.7.0, v14.18.0	Lors de l'utilisation d'un objet `URL`, le nom d'utilisateur et le mot de passe analysés seront désormais correctement décodés en URI.
v15.3.0, v14.17.0	Il est possible d'avorter une requête avec un AbortSignal.
v13.3.0	L'option `maxHeaderSize` est désormais prise en charge.
v13.8.0, v12.15.0, v10.19.0	L'option `insecureHTTPParser` est désormais prise en charge.
v10.9.0	Le paramètre `url` peut désormais être passé avec un objet `options` séparé.
v7.5.0	Le paramètre `options` peut être un objet `URL` WHATWG.
v0.3.6	Ajouté dans : v0.3.6

url <chaîne de caractères> | <URL>
options <Objet>
- agent <http.Agent> | <booléen> Contrôle le comportement de Agent. Valeurs possibles :
- undefined (par défaut) : utiliser http.globalAgent pour cet hôte et ce port.
- Objet Agent : utiliser explicitement l'objet Agent passé.
- false : entraîne l'utilisation d'un nouvel objet Agent avec les valeurs par défaut.
- auth <chaîne de caractères> Authentification de base ('user:password') pour calculer un en-tête Authorization.
- createConnection <Fonction> Une fonction qui produit une socket/un flux à utiliser pour la requête lorsque l'option agent n'est pas utilisée. Cela peut être utilisé pour éviter de créer une classe Agent personnalisée juste pour remplacer la fonction createConnection par défaut. Voir agent.createConnection() pour plus de détails. Tout flux Duplex est une valeur de retour valide.
- defaultPort <nombre> Port par défaut pour le protocole. Par défaut : agent.defaultPort si un Agent est utilisé, sinon undefined.
- family <nombre> Famille d'adresses IP à utiliser lors de la résolution de host ou hostname. Les valeurs valides sont 4 ou 6. Si non spécifié, les versions IPv4 et IPv6 seront utilisées.
- headers <Objet> Un objet contenant les en-têtes de requête.
- hints <nombre> Indications dns.lookup() facultatives.
- host <chaîne de caractères> Nom de domaine ou adresse IP du serveur auquel envoyer la requête. Par défaut : 'localhost'.
- hostname <chaîne de caractères> Alias pour host. Pour prendre en charge url.parse(), hostname sera utilisé si host et hostname sont spécifiés.
- insecureHTTPParser <booléen> S'il est défini sur true, il utilisera un analyseur HTTP avec des indicateurs de tolérance activés. L'utilisation de l'analyseur non sécurisé doit être évitée. Voir --insecure-http-parser pour plus d'informations. Par défaut : false
- joinDuplicateHeaders <booléen> Il joint les valeurs de ligne de champ de plusieurs en-têtes dans une requête avec , au lieu de supprimer les doublons. Voir message.headers pour plus d'informations. Par défaut : false.
- localAddress <chaîne de caractères> Interface locale à lier pour les connexions réseau.
- localPort <nombre> Port local depuis lequel se connecter.
- lookup <Fonction> Fonction de recherche personnalisée. Par défaut : dns.lookup().
- maxHeaderSize <nombre> Remplace éventuellement la valeur de --max-http-header-size (longueur maximale des en-têtes de réponse en octets) pour les réponses reçues du serveur. Par défaut : 16384 (16 Ko).
- method <chaîne de caractères> Une chaîne spécifiant la méthode de requête HTTP. Par défaut : 'GET'.
- path <chaîne de caractères> Chemin de la requête. Doit inclure la chaîne de requête le cas échéant. Par exemple : '/index.html?page=12'. Une exception est levée lorsque le chemin de la requête contient des caractères illégaux. Actuellement, seuls les espaces sont refusés, mais cela peut changer à l'avenir. Par défaut : '/'.
- port <nombre> Port du serveur distant. Par défaut : defaultPort s'il est défini, sinon 80.
- protocol <chaîne de caractères> Protocole à utiliser. Par défaut : 'http:'.
- setDefaultHeaders <booléen>: Spécifie s'il faut ou non ajouter automatiquement les en-têtes par défaut tels que Connection, Content-Length, Transfer-Encoding et Host. Si défini sur false, tous les en-têtes nécessaires doivent être ajoutés manuellement. La valeur par défaut est true.
- setHost <booléen>: Spécifie s'il faut ou non ajouter automatiquement l'en-tête Host. Si fourni, cela remplace setDefaultHeaders. La valeur par défaut est true.
- signal <AbortSignal>: Un AbortSignal qui peut être utilisé pour avorter une requête en cours.
- socketPath <chaîne de caractères> Socket de domaine Unix. Ne peut pas être utilisé si host ou port est spécifié, car ceux-ci spécifient une socket TCP.
- timeout <nombre>: Un nombre spécifiant le délai d'expiration de la socket en millisecondes. Cela définira le délai d'expiration avant que la socket ne soit connectée.
- uniqueHeaders <Tableau> Une liste d'en-têtes de requête qui ne doivent être envoyés qu'une seule fois. Si la valeur de l'en-tête est un tableau, les éléments seront joints à l'aide de ; .
callback <Fonction>
Retourne : <http.ClientRequest>

Les options dans socket.connect() sont également prises en charge.

Node.js maintient plusieurs connexions par serveur pour effectuer des requêtes HTTP. Cette fonction permet d'émettre des requêtes de manière transparente.

url peut être une chaîne de caractères ou un objet URL. Si url est une chaîne de caractères, elle est automatiquement analysée avec new URL(). Si c'est un objet URL, il sera automatiquement converti en un objet options ordinaire.

Si url et options sont tous deux spécifiés, les objets sont fusionnés, les propriétés options ayant priorité.

Le paramètre callback facultatif sera ajouté comme écouteur unique pour l'événement 'response'.

http.request() retourne une instance de la classe http.ClientRequest. L'instance ClientRequest est un flux inscriptible. Si vous devez télécharger un fichier avec une requête POST, écrivez alors sur l'objet 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('Plus de données dans la réponse.')
  })
})

req.on('error', e => {
  console.error(`Problème avec la requête: ${e.message}`)
})

// Écrire des données dans le corps de la requête
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('Plus de données dans la réponse.')
  })
})

req.on('error', e => {
  console.error(`Problème avec la requête: ${e.message}`)
})

// Écrire des données dans le corps de la requête
req.write(postData)
req.end()

Dans l'exemple, req.end() a été appelé. Avec http.request(), il faut toujours appeler req.end() pour signaler la fin de la requête, même s'il n'y a pas de données écrites dans le corps de la requête.

Si une erreur survient pendant la requête (que ce soit avec la résolution DNS, des erreurs de niveau TCP ou des erreurs d'analyse HTTP), un événement 'error' est émis sur l'objet de requête retourné. Comme pour tous les événements 'error', si aucun écouteur n'est enregistré, l'erreur sera levée.

Il y a quelques en-têtes spéciaux à noter.

L'envoi d'un en-tête 'Connection: keep-alive' informera Node.js que la connexion au serveur doit être conservée jusqu'à la requête suivante.
L'envoi d'un en-tête 'Content-Length' désactivera le codage par morceaux par défaut.
L'envoi d'un en-tête 'Expect' enverra immédiatement les en-têtes de la requête. Généralement, lors de l'envoi de 'Expect: 100-continue', un délai d'expiration et un écouteur pour l'événement 'continue' doivent être définis. Voir la section 8.2.3 de la RFC 2616 pour plus d'informations.
L'envoi d'un en-tête Authorization remplacera l'utilisation de l'option auth pour calculer l'authentification de base.

Exemple utilisant un URL comme options :

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

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

Dans une requête réussie, les événements suivants seront émis dans l'ordre suivant :

'socket'
'response'
- 'data' plusieurs fois, sur l'objet res ('data' ne sera pas émis du tout si le corps de la réponse est vide, par exemple, dans la plupart des redirections)
- 'end' sur l'objet res
'close'

En cas d'erreur de connexion, les événements suivants seront émis :

'socket'
'error'
'close'

En cas de fermeture prématurée de la connexion avant la réception de la réponse, les événements suivants seront émis dans l'ordre suivant :

'socket'
'error' avec une erreur avec le message 'Error: socket hang up' et le code 'ECONNRESET'
'close'

En cas de fermeture prématurée de la connexion après la réception de la réponse, les événements suivants seront émis dans l'ordre suivant :

'socket'
'response'
- 'data' plusieurs fois, sur l'objet res
(connexion fermée ici)
'aborted' sur l'objet res
'close'
'error' sur l'objet res avec une erreur avec le message 'Error: aborted' et le code 'ECONNRESET'
'close' sur l'objet res

Si req.destroy() est appelé avant qu'une socket ne soit affectée, les événements suivants seront émis dans l'ordre suivant :

(req.destroy() appelé ici)
'error' avec une erreur avec le message 'Error: socket hang up' et le code 'ECONNRESET', ou l'erreur avec laquelle req.destroy() a été appelé
'close'

Si req.destroy() est appelé avant la réussite de la connexion, les événements suivants seront émis dans l'ordre suivant :

'socket'
(req.destroy() appelé ici)
'error' avec une erreur avec le message 'Error: socket hang up' et le code 'ECONNRESET', ou l'erreur avec laquelle req.destroy() a été appelé
'close'

Si req.destroy() est appelé après la réception de la réponse, les événements suivants seront émis dans l'ordre suivant :

'socket'
'response'
- 'data' plusieurs fois, sur l'objet res
(req.destroy() appelé ici)
'aborted' sur l'objet res
'close'
'error' sur l'objet res avec une erreur avec le message 'Error: aborted' et le code 'ECONNRESET', ou l'erreur avec laquelle req.destroy() a été appelé
'close' sur l'objet res

Si req.abort() est appelé avant qu'une socket ne soit affectée, les événements suivants seront émis dans l'ordre suivant :

(req.abort() appelé ici)
'abort'
'close'

Si req.abort() est appelé avant la réussite de la connexion, les événements suivants seront émis dans l'ordre suivant :

'socket'
(req.abort() appelé ici)
'abort'
'error' avec une erreur avec le message 'Error: socket hang up' et le code 'ECONNRESET'
'close'

Si req.abort() est appelé après la réception de la réponse, les événements suivants seront émis dans l'ordre suivant :

'socket'
'response'
- 'data' plusieurs fois, sur l'objet res
(req.abort() appelé ici)
'abort'
'aborted' sur l'objet res
'error' sur l'objet res avec une erreur avec le message 'Error: aborted' et le code 'ECONNRESET'.
'close'
'close' sur l'objet res

La définition de l'option timeout ou l'utilisation de la fonction setTimeout() n'avortera pas la requête ni ne fera rien d'autre que d'ajouter un événement 'timeout'.

Le passage d'un AbortSignal puis l'appel de abort() sur le AbortController correspondant se comportera de la même manière que l'appel de .destroy() sur la requête. Plus précisément, l'événement 'error' sera émis avec une erreur avec le message 'AbortError: The operation was aborted', le code 'ABORT_ERR' et la cause, si une a été fournie.

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

[Historique]

Version	Modifications
v19.5.0, v18.14.0	Le paramètre `label` a été ajouté.
v14.3.0	Ajouté dans : v14.3.0

name <string>
label <string> Etiquette pour le message d'erreur. Valeur par défaut : 'Header name'.

Effectue les validations de bas niveau sur le name fourni qui sont effectuées lorsque res.setHeader(name, value) est appelé.

La transmission d'une valeur illégale en tant que name entraînera le déclenchement d'une TypeError, identifiée par code : 'ERR_INVALID_HTTP_TOKEN'.

Il n'est pas nécessaire d'utiliser cette méthode avant de transmettre des en-têtes à une requête ou une réponse HTTP. Le module HTTP validera automatiquement ces en-têtes.

Exemple :

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)`

Ajouté dans : v14.3.0

name <string>
value <any>

Effectue les validations de bas niveau sur la value fournie qui sont effectuées lorsque res.setHeader(name, value) est appelé.

La transmission d'une valeur illégale en tant que value entraînera le déclenchement d'une TypeError.

L'erreur de valeur indéfinie est identifiée par code : 'ERR_HTTP_INVALID_HEADER_VALUE'.
L'erreur de caractère de valeur invalide est identifiée par code : 'ERR_INVALID_CHAR'.

Il n'est pas nécessaire d'utiliser cette méthode avant de transmettre des en-têtes à une requête ou une réponse HTTP. Le module HTTP validera automatiquement ces en-têtes.

Exemples :

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)`

Ajouté dans : v18.8.0, v16.18.0

max <nombre> Défaut : 1000.

Définit le nombre maximal d'analyseurs HTTP inactifs.

`WebSocket`

Ajouté dans : v22.5.0

Une implémentation compatible navigateur de WebSocket.

HTTP ​

Classe : 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 ​

Classe : http.ClientRequest ​

Événement : 'abort' ​

Événement : 'close' ​

Événement : 'connect' ​

Événement : 'continue' ​

Événement : 'finish' ​

Événement : 'information' ​

Événement : 'response' ​

Événement : 'socket' ​

Événement : 'timeout' ​

Événement : '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]) ​

Classe : http.Server ​

Événement : 'checkContinue' ​

Événement : 'checkExpectation' ​

Événement : 'clientError' ​

Événement : 'close' ​

Événement : 'connect' ​

Événement : 'connection' ​

Événement : 'dropRequest' ​

Événement : 'request' ​

Événement : '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]() ​

Classe : http.ServerResponse ​

Événement : 'close' ​

HTTP

Classe : `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`

Classe : `http.ClientRequest`

Événement : `'abort'`

Événement : `'close'`

Événement : `'connect'`

Événement : `'continue'`

Événement : `'finish'`

Événement : `'information'`

Événement : `'response'`

Événement : `'socket'`

Événement : `'timeout'`

Événement : `'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])`

Classe : `http.Server`

Événement : `'checkContinue'`

Événement : `'checkExpectation'`

Événement : `'clientError'`

Événement : `'close'`

Événement : `'connect'`

Événement : `'connection'`

Événement : `'dropRequest'`

Événement : `'request'`

Événement : `'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]()`

Classe : `http.ServerResponse`

Événement : `'close'`