Node js http error

http-errors

Create HTTP errors for Express, Koa, Connect, etc. with ease.

Install

This is a Node.js module available through the
npm registry. Installation is done using the
npm install command:

$ npm install http-errors

Example

var createError = require('http-errors')
var express = require('express')
var app = express()

app.use(function (req, res, next) {
  if (!req.user) return next(createError(401, 'Please login to view this page.'))
  next()
})

API

This is the current API, currently extracted from Koa and subject to change.

Error Properties

• expose — can be used to signal if message should be sent to the client,
  defaulting to false when status >= 500
• headers — can be an object of header names to values to be sent to the
  client, defaulting to undefined. When defined, the key names should all
  be lower-cased
• message — the traditional error message, which should be kept short and all
  single line
• status — the status code of the error, mirroring statusCode for general
  compatibility
• statusCode — the status code of the error, defaulting to 500

createError([status], [message], [properties])

Create a new error object with the given message msg.
The error object inherits from createError.HttpError.

var err = createError(404, 'This video does not exist!')

• status: 500 — the status code as a number
• message — the message of the error, defaulting to node’s text for that status code.
• properties — custom properties to attach to the object

createError([status], [error], [properties])

Extend the given error object with createError.HttpError
properties. This will not alter the inheritance of the given
error object, and the modified error object is the
return value.

fs.readFile('foo.txt', function (err, buf) {
  if (err) {
    if (err.code === 'ENOENT') {
      var httpError = createError(404, err, { expose: false })
    } else {
      var httpError = createError(500, err)
    }
  }
})

• status — the status code as a number
• error — the error object to extend
• properties — custom properties to attach to the object

createError.isHttpError(val)

Determine if the provided val is an HttpError. This will return true
if the error inherits from the HttpError constructor of this module or
matches the «duck type» for an error this module creates. All outputs from
the createError factory will return true for this function, including
if an non-HttpError was passed into the factory.

new createError[code || name]([msg]))

Create a new error object with the given message msg.
The error object inherits from createError.HttpError.

var err = new createError.NotFound()

• code — the status code as a number
• name — the name of the error as a «bumpy case», i.e. NotFound or InternalServerError.

List of all constructors

Status Code	Constructor Name
400	BadRequest
401	Unauthorized
402	PaymentRequired
403	Forbidden
404	NotFound
405	MethodNotAllowed
406	NotAcceptable
407	ProxyAuthenticationRequired
408	RequestTimeout
409	Conflict
410	Gone
411	LengthRequired
412	PreconditionFailed
413	PayloadTooLarge
414	URITooLong
415	UnsupportedMediaType
416	RangeNotSatisfiable
417	ExpectationFailed
418	ImATeapot
421	MisdirectedRequest
422	UnprocessableEntity
423	Locked
424	FailedDependency
425	TooEarly
426	UpgradeRequired
428	PreconditionRequired
429	TooManyRequests
431	RequestHeaderFieldsTooLarge
451	UnavailableForLegalReasons
500	InternalServerError
501	NotImplemented
502	BadGateway
503	ServiceUnavailable
504	GatewayTimeout
505	HTTPVersionNotSupported
506	VariantAlsoNegotiates
507	InsufficientStorage
508	LoopDetected
509	BandwidthLimitExceeded
510	NotExtended
511	NetworkAuthenticationRequired

License

MIT

Когда я только начинал работать с Express и пытался разобраться с тем, как обрабатывать ошибки, мне пришлось нелегко. Возникало такое ощущение, будто никто не писал о том, что мне было нужно. В итоге мне пришлось самому искать ответы на мои вопросы. Сегодня я хочу рассказать всё, что знаю об обработке ошибок в Express-приложениях. Начнём с синхронных ошибок.

Обработка синхронных ошибок

Если вам нужно обработать синхронную ошибку, то вы можете, для начала, с помощью инструкции throw, выдать такую ошибку в обработчике запроса Express. Обратите внимание на то, что обработчики запросов ещё называют «контроллерами», но я предпочитаю использовать термин «обработчик запросов» так как он кажется мне понятнее.

Вот как это выглядит:

app.post('/testing', (req, res) => {
  throw new Error('Something broke! ')
})

Такие ошибки можно перехватить с помощью обработчика ошибок Express. Если вы не написали собственный обработчик ошибок (подробнее об этом мы поговорим ниже), то Express обработает ошибку с помощью обработчика, используемого по умолчанию.

Вот что делает стандартный обработчик ошибок Express:

1. Устанавливает код состояния HTTP-ответа в значение 500.
2. Отправляет сущности, выполнившей запрос, текстовый ответ.
3. Логирует текстовый ответ в консоль.

Сообщение об ошибке, выведенное в консоль

Обработка асинхронных ошибок

Для обработки асинхронных ошибок нужно отправить ошибку обработчику ошибок Express через аргумент next:

app.post('/testing', async (req, res, next) => {
  return next(new Error('Something broke again! '))
})

Вот что попадёт в консоль при логировании этой ошибки.

Сообщение об ошибке, выведенное в консоль

Если вы пользуетесь в Express-приложении конструкцией async/await, то вам понадобится использовать функцию-обёртку, наподобие express-async-handler. Это позволяет писать асинхронный код без блоков try/catch. Подробнее об async/await в Express можно почитать здесь.

const asyncHandler = require('express-async-handler')

app.post('/testing', asyncHandler(async (req, res, next) => {
  // Сделать что-нибудь
}))

После того, как обработчик запроса обёрнут в express-async-handler, то можно, так же, как было описано выше, выбросить ошибку с использованием инструкции throw. Эта ошибка попадёт к обработчику ошибок Express.

app.post('/testing', asyncHandler(async (req, res, next) => {
  throw new Error('Something broke yet again! ')
}))

Сообщение об ошибке, выведенное в консоль

Написание собственного обработчика ошибок

Обработчики ошибок Express принимают 4 аргумента:

1. error
2. req
3. res
4. next

Размещать их нужно после промежуточных обработчиков и маршрутов.

app.use(/*...*/)
app.get(/*...*/)
app.post(/*...*/)
app.put(/*...*/)
app.delete(/*...*/)

// Собственный обработчик ошибок нужно поместить после всех остальных промежуточных обработчиков
app.use((error, req, res, next) => { /* ... */ })

Если создать собственный обработчик ошибок, то Express прекратит использование стандартного обработчика. Для того чтобы обработать ошибку, нужно сформировать ответ для фронтенд-приложения, которое обратилось к конечной точке, в которой возникла ошибка. Это означает, что нужно выполнить следующие действия:

1. Сформировать и отправить подходящий код состояния ответа.
2. Сформировать и отправить подходящий ответ.

То, какой именно код состояния подойдёт в каждом конкретном случае, зависит от того, что именно произошло. Вот список типичных ошибок, к обработке которых вы должны быть готовы:

1. Ошибка 400 Bad Request. Используется в двух ситуациях. Во-первых — тогда, когда пользователь не включил в запрос необходимое поле (например — в отправленной платёжной форме не заполнено поле со сведениями о кредитной карте). Во-вторых — тогда, когда в запросе содержатся некорректные данные (например — ввод в поле пароля и в поле подтверждения пароля разных паролей).
2. Ошибка 401 Unauthorized. Этот код состояния ответа применяется в том случае, если пользователь ввёл неправильные учётные данные (вроде имени пользователя, адреса электронной почты или пароля).
3. Ошибка 403 Forbidden. Используется в тех случаях, когда пользователю не разрешён доступ к конечной точке.
4. Ошибка 404 Not Found. Применяется в тех случаях, когда конечную точку невозможно обнаружить.
5. Ошибка 500 Internal Server Error. Применяется тогда, когда запрос, отправленный фронтендом, сформирован правильно, но на бэкенде при этом возникла какая-то ошибка.

После того, как определён подходящий код состояния ответа, его нужно установить с помощью res.status:

app.use((error, req, res, next) => {
  // Ошибка, выдаваемая в ответ на неправильно сформированный запрос
  res.status(400)
  res.json(/* ... */)
})

Код состояния ответа должен соответствовать сообщению об ошибке. Для этого нужно отправлять код состояния вместе с ошибкой.

Легче всего это сделать с помощью пакета http-errors. Он позволяет отправлять в ошибке три фрагмента информации:

1. Код состояния ответа.
2. Сообщение, сопутствующее ошибке.
3. Любые данные, которые нужно отправить (это необязательно).

Вот как установить пакет http-errors:

npm install http-errors --save

Вот как этим пакетом пользоваться:

const createError = require('http-errors')

// Создание ошибки
throw createError(status, message, properties)

Рассмотрим пример, который позволит как следует в этом всём разобраться.

Представим, что мы пытаемся обнаружить пользователя по адресу его электронной почты. Но этого пользователя найти не удаётся. В результате мы решаем отправить в ответ на соответствующий запрос ошибку User not found, сообщающую вызывающей стороне о том, что пользователь не найден.

Вот что нам нужно будет сделать при создании ошибки:

1. Установить код состояния ответа как 400 Bad Request (ведь пользователь ввёл неправильные данные). Это будет наш первый параметр.
2. Отправить вызывающей стороне сообщение наподобие User not found. Это будет второй параметр.

app.put('/testing', asyncHandler(async (req, res) => {
  const { email } = req.body
  const user = await User.findOne({ email })

  // Если пользователь не найден - выбросим ошибку
  if (!user) throw createError(400, `User '${email}' not found`)
}))

Получить код состояния можно с помощью конструкции error.status, а сообщение ошибки — с помощью error.message:

// Логирование ошибки
app.use((error, req, res, next) => {
  console.log('Error status: ', error.status)
  console.log('Message: ', error.message)
})

Результат логирования ошибки в консоли

Затем состояние ответа устанавливают с помощью res.status, а сообщение записывают в res.json:

app.use((error, req, res, next) => {
  // Установка кода состояния ответа
  res.status(error.status)

  // Отправка ответа
  res.json({ message: error.message })
})

Лично я предпочитаю отправлять в подобных ответах код состояния, сообщение и результат трассировки стека. Это облегчает отладку.

app.use((error, req, res, next) => {
  // Установка кода состояния ответа
  res.status(error.status)

  // Отправка ответа
  res.json({
    status: error.status,
    message: error.message,
    stack: error.stack
  })
})

▍Код состояния ответа, используемый по умолчанию

Если источником ошибки не является createError, то у неё не будет свойства status. Вот пример, в котором сделана попытка прочесть несуществующий файл с помощью fs.readFile:

const fs = require('fs')
const util = require('util')

// Преобразуем readFile из функции, использующей коллбэки, в async/await-функцию.
// Подробности об этом смотрите здесь: https://zellwk.com/blog/callbacks-to-promises
const readFilePromise = util.promisify(fs.readFile)

app.get('/testing', asyncHandler(async (req, res, next) => {
  const data = await readFilePromise('some-file')
})

У такого объекта ошибки не будет свойства status:

app.use((error, req, res, next) => {
  console.log('Error status: ', error.status)
  console.log('Message: ', error.message)
})

Результат логирования ошибки в консоли

В подобных случаях можно задать код ошибки, используемый по умолчанию. А именно, речь идёт об ошибке 500 Internal Server Error:

app.use((error, req, res, next) => {
  res.status(error.status || 500)
  res.json({
    status: error.status,
    message: error.message,
    stack: error.stack
  })
})

▍Изменение кода состояния ошибки

Предположим, мы собираемся прочитать некий файл, воспользовавшись данными, предоставленными пользователем. Если такого файла не существует, это значит, что нам нужно выдать ошибку 400 Bad Request. Ведь в том, что файл найти не удаётся, нет вины сервера.

В подобном случае нужно воспользоваться конструкцией try/catch для перехвата исходной ошибки. Затем нужно воссоздать объект ошибки с помощью createError:

app.get('/testing', asyncHandler(async (req, res, next) => {
  try {
    const { file } = req.body
    const contents = await readFilePromise(path.join(__dirname, file))
  } catch (error) {
    throw createError(400, `File ${file} does not exist`)
  }
})

▍Обработка ошибок 404

Если запрос прошёл через все промежуточные обработчики и маршруты, но так и не был обработан, это означает, что конечная точка, соответствующая такому запросу, не была найдена.

Для обработки ошибок 404 Not Found нужно добавить, между маршрутами и обработчиком ошибок, дополнительный обработчик. Вот как выглядит создание объекта ошибки 404:

// Промежуточные обработчики...
// Маршруты...

app.use((req, res, next) => {
  next(createError(404))
})

// Обработчик ошибок...

Сведения об ошибке

▍Замечания об ошибке ERR_HTTP_HEADERS_SENT

Не впадайте в панику если видите сообщение об ошибке ERR_HTTP_HEADERS_SENT: Cannot set headers after they are sent to the client. Она возникает из-за того, что в одном и том же обработчике многократно вызывается метод, устанавливающий заголовки ответа. Вот методы, вызов которых приводит к автоматической установке заголовков ответа:

1. res.send
2. res.json
3. res.render
4. res.sendFile
5. res.sendStatus
6. res.end
7. res.redirect

Так, например, если вы вызовете методы res.render и res.json в одном и том же обработчике ответа, то вы получите ошибку ERR_HTTP_HEADERS_SENT:

app.get('/testing', (req, res) => {
  res.render('new-page')
  res.json({ message: '¯_(ツ)_/¯' })
})

В результате, в том случае, если вы сталкиваетесь с этой ошибкой, тщательно проверьте код обработчиков ответа и убедитесь в том, что в нём нет ситуаций, в которых вызывается несколько вышеописанных методов.

▍Обработка ошибок и потоковая передача данных

Если что-то идёт не так при потоковой передаче ответа фронтенду, то можно столкнуться с той же самой ошибкой ERR_HTTP_HEADERS_SENT.

В подобном случае обработку ошибок нужно передать стандартным обработчикам. Такой обработчик отправит ошибку и автоматически закроет соединение.

app.use((error, req, res, next) => {
  // Сделать это нужно только в том случае, если ответ передаётся в потоковом режиме
  if (res.headersSent) {
    return next(error)
  }

  // Остальной код обработки ошибок
})

Итоги

Сегодня я рассказал вам всё, что знаю об обработке ошибок в Express. Надеюсь, это поможет вам писать более надёжные Express-приложения.

Уважаемые читатели! Как вы обрабатываете ошибки в своих Node.js-проектах?

HTTP-errors module is used for generating errors for Node.js applications. It is very easy to use. We can use it with express, Koa, etc. applications. We will implement this module in an express application.

Installation and Setup: First, initialize the application with package.json file with the following command: 
 

npm init

Then, install the module by the following command:

npm install http-errors --save

Also, we are using an express application, therefore, install the express module by the following command:

npm install express --save

Now, create a file and name it app.js. You can name your file whatever you want.

For importing the modules in your application, write the following code in your app.js file:

Implementation: Here, comes the main part of our application. For using this module, write the following code in your app.js file:
 

Here, we are importing the http-errors module and storing it in a variable named as createError. Next, in app.use(), if the user is not authenticated, then our application will create a 401 error saying Login Required!!. The createError is used for generating errors in an application.

To run the code, run the following command in the terminal:

node app.js

and navigate to http://localhost:8080. The output for the above code will be:

List of all Status Code with their Error Message: 
 

Status
Code    Error Message

400    BadRequest
401    Unauthorized
402    PaymentRequired
403    Forbidden
404    NotFound
405    MethodNotAllowed
406    NotAcceptable
407    ProxyAuthenticationRequired
408    RequestTimeout
409    Conflict
410    Gone
411    LengthRequired
412    PreconditionFailed
413    PayloadTooLarge
414    URITooLong
415    UnsupportedMediaType
416    RangeNotSatisfiable
417    ExpectationFailed
418    ImATeapot
421    MisdirectedRequest
422    UnprocessableEntity
423    Locked
424    FailedDependency
425    UnorderedCollection
426    UpgradeRequired
428    PreconditionRequired
429    TooManyRequests
431    RequestHeaderFieldsTooLarge
451    UnavailableForLegalReasons
500    InternalServerError
501    NotImplemented
502    BadGateway
503    ServiceUnavailable
504    GatewayTimeout
505    HTTPVersionNotSupported
506    VariantAlsoNegotiates
507    InsufficientStorage
508    LoopDetected
509    BandwidthLimitExceeded
510    NotExtended
511    NetworkAuthenticationRequired

Conclusion: The http-errors module is very useful for developers for quick generation of errors with their message. In this article, we learned about the http-errors module for Node.js. We have also seen its installation and Implementation.
 

Node.js v19.4.0 documentation

Errors #

Applications running in Node.js will generally experience four categories of errors:

• Standard JavaScript errors such as , , , , , and .
• System errors triggered by underlying operating system constraints such as attempting to open a file that does not exist or attempting to send data over a closed socket.
• User-specified errors triggered by application code.
• AssertionError s are a special class of error that can be triggered when Node.js detects an exceptional logic violation that should never occur. These are raised typically by the node:assert module.

All JavaScript and system errors raised by Node.js inherit from, or are instances of, the standard JavaScript class and are guaranteed to provide at least the properties available on that class.

Error propagation and interception #

Node.js supports several mechanisms for propagating and handling errors that occur while an application is running. How these errors are reported and handled depends entirely on the type of Error and the style of the API that is called.

All JavaScript errors are handled as exceptions that immediately generate and throw an error using the standard JavaScript throw mechanism. These are handled using the try…catch construct provided by the JavaScript language.

Any use of the JavaScript throw mechanism will raise an exception that must be handled using try…catch or the Node.js process will exit immediately.

With few exceptions, Synchronous APIs (any blocking method that does not accept a callback function, such as fs.readFileSync ), will use throw to report errors.

Errors that occur within Asynchronous APIs may be reported in multiple ways:

Most asynchronous methods that accept a callback function will accept an Error object passed as the first argument to that function. If that first argument is not null and is an instance of Error , then an error occurred that should be handled.

When an asynchronous method is called on an object that is an EventEmitter , errors can be routed to that object’s ‘error’ event.

A handful of typically asynchronous methods in the Node.js API may still use the throw mechanism to raise exceptions that must be handled using try…catch . There is no comprehensive list of such methods; please refer to the documentation of each method to determine the appropriate error handling mechanism required.

The use of the ‘error’ event mechanism is most common for stream-based and event emitter-based APIs, which themselves represent a series of asynchronous operations over time (as opposed to a single operation that may pass or fail).

For all EventEmitter objects, if an ‘error’ event handler is not provided, the error will be thrown, causing the Node.js process to report an uncaught exception and crash unless either: The domain module is used appropriately or a handler has been registered for the ‘uncaughtException’ event.

Errors generated in this way cannot be intercepted using try…catch as they are thrown after the calling code has already exited.

Developers must refer to the documentation for each method to determine exactly how errors raised by those methods are propagated.

Error-first callbacks #

Most asynchronous methods exposed by the Node.js core API follow an idiomatic pattern referred to as an error-first callback. With this pattern, a callback function is passed to the method as an argument. When the operation either completes or an error is raised, the callback function is called with the Error object (if any) passed as the first argument. If no error was raised, the first argument will be passed as null .

The JavaScript try…catch mechanism cannot be used to intercept errors generated by asynchronous APIs. A common mistake for beginners is to try to use throw inside an error-first callback:

This will not work because the callback function passed to fs.readFile() is called asynchronously. By the time the callback has been called, the surrounding code, including the try…catch block, will have already exited. Throwing an error inside the callback can crash the Node.js process in most cases. If domains are enabled, or a handler has been registered with process.on(‘uncaughtException’) , such errors can be intercepted.

Class: Error #

A generic JavaScript object that does not denote any specific circumstance of why the error occurred. Error objects capture a «stack trace» detailing the point in the code at which the Error was instantiated, and may provide a text description of the error.

All errors generated by Node.js, including all system and JavaScript errors, will either be instances of, or inherit from, the Error class.

new Error(message[, options]) #

Creates a new Error object and sets the error.message property to the provided text message. If an object is passed as message , the text message is generated by calling String(message) . If the cause option is provided, it is assigned to the error.cause property. The error.stack property will represent the point in the code at which new Error() was called. Stack traces are dependent on V8’s stack trace API. Stack traces extend only to either (a) the beginning of synchronous code execution, or (b) the number of frames given by the property Error.stackTraceLimit , whichever is smaller.

Error.captureStackTrace(targetObject[, constructorOpt]) #

Creates a .stack property on targetObject , which when accessed returns a string representing the location in the code at which Error.captureStackTrace() was called.

The first line of the trace will be prefixed with $: $ .

The optional constructorOpt argument accepts a function. If given, all frames above constructorOpt , including constructorOpt , will be omitted from the generated stack trace.

The constructorOpt argument is useful for hiding implementation details of error generation from the user. For instance:

Error.stackTraceLimit #

The Error.stackTraceLimit property specifies the number of stack frames collected by a stack trace (whether generated by new Error().stack or Error.captureStackTrace(obj) ).

The default value is 10 but may be set to any valid JavaScript number. Changes will affect any stack trace captured after the value has been changed.

If set to a non-number value, or set to a negative number, stack traces will not capture any frames.

error.cause #

If present, the error.cause property is the underlying cause of the Error . It is used when catching an error and throwing a new one with a different message or code in order to still have access to the original error.

The error.cause property is typically set by calling new Error(message, < cause >) . It is not set by the constructor if the cause option is not provided.

This property allows errors to be chained. When serializing Error objects, util.inspect() recursively serializes error.cause if it is set.

error.code #

The error.code property is a string label that identifies the kind of error. error.code is the most stable way to identify an error. It will only change between major versions of Node.js. In contrast, error.message strings may change between any versions of Node.js. See Node.js error codes for details about specific codes.

error.message #

The error.message property is the string description of the error as set by calling new Error(message) . The message passed to the constructor will also appear in the first line of the stack trace of the Error , however changing this property after the Error object is created may not change the first line of the stack trace (for example, when error.stack is read before this property is changed).

error.stack #

The error.stack property is a string describing the point in the code at which the Error was instantiated.

The first line is formatted as : , and is followed by a series of stack frames (each line beginning with «at «). Each frame describes a call site within the code that lead to the error being generated. V8 attempts to display a name for each function (by variable name, function name, or object method name), but occasionally it will not be able to find a suitable name. If V8 cannot determine a name for the function, only location information will be displayed for that frame. Otherwise, the determined function name will be displayed with location information appended in parentheses.

Frames are only generated for JavaScript functions. If, for example, execution synchronously passes through a C++ addon function called cheetahify which itself calls a JavaScript function, the frame representing the cheetahify call will not be present in the stack traces:

The location information will be one of:

• native , if the frame represents a call internal to V8 (as in [].forEach ).
• plain-filename.js:line:column , if the frame represents a call internal to Node.js.
• /absolute/path/to/file.js:line:column , if the frame represents a call in a user program (using CommonJS module system), or its dependencies.
• :///url/to/module/file.mjs:line:column , if the frame represents a call in a user program (using ES module system), or its dependencies.

The string representing the stack trace is lazily generated when the error.stack property is accessed.

The number of frames captured by the stack trace is bounded by the smaller of Error.stackTraceLimit or the number of available frames on the current event loop tick.

Class: AssertionError #

Indicates the failure of an assertion. For details, see Class: assert.AssertionError .

Class: RangeError #

Indicates that a provided argument was not within the set or range of acceptable values for a function; whether that is a numeric range, or outside the set of options for a given function parameter.

Node.js will generate and throw RangeError instances immediately as a form of argument validation.

Class: ReferenceError #

Indicates that an attempt is being made to access a variable that is not defined. Such errors commonly indicate typos in code, or an otherwise broken program.

While client code may generate and propagate these errors, in practice, only V8 will do so.

Unless an application is dynamically generating and running code, ReferenceError instances indicate a bug in the code or its dependencies.

Class: SyntaxError #

Indicates that a program is not valid JavaScript. These errors may only be generated and propagated as a result of code evaluation. Code evaluation may happen as a result of eval , Function , require , or vm. These errors are almost always indicative of a broken program.

SyntaxError instances are unrecoverable in the context that created them – they may only be caught by other contexts.

Class: SystemError #

Node.js generates system errors when exceptions occur within its runtime environment. These usually occur when an application violates an operating system constraint. For example, a system error will occur if an application attempts to read a file that does not exist.

• address If present, the address to which a network connection failed
• code The string error code
• dest If present, the file path destination when reporting a file system error
• errno The system-provided error number
• info If present, extra details about the error condition
• message A system-provided human-readable description of the error
• path If present, the file path when reporting a file system error
• port If present, the network connection port that is not available
• syscall The name of the system call that triggered the error

error.address #

If present, error.address is a string describing the address to which a network connection failed.

error.code #

The error.code property is a string representing the error code.

error.dest #

If present, error.dest is the file path destination when reporting a file system error.

error.errno #

The error.errno property is a negative number which corresponds to the error code defined in libuv Error handling .

On Windows the error number provided by the system will be normalized by libuv.

To get the string representation of the error code, use util.getSystemErrorName(error.errno) .

error.info #

If present, error.info is an object with details about the error condition.

error.message #

error.message is a system-provided human-readable description of the error.

error.path #

If present, error.path is a string containing a relevant invalid pathname.

error.port #

If present, error.port is the network connection port that is not available.

error.syscall #

The error.syscall property is a string describing the syscall that failed.

Common system errors #

This is a list of system errors commonly-encountered when writing a Node.js program. For a comprehensive list, see the errno (3) man page.

EACCES (Permission denied): An attempt was made to access a file in a way forbidden by its file access permissions.

EADDRINUSE (Address already in use): An attempt to bind a server ( net , http , or https ) to a local address failed due to another server on the local system already occupying that address.

ECONNREFUSED (Connection refused): No connection could be made because the target machine actively refused it. This usually results from trying to connect to a service that is inactive on the foreign host.

ECONNRESET (Connection reset by peer): A connection was forcibly closed by a peer. This normally results from a loss of the connection on the remote socket due to a timeout or reboot. Commonly encountered via the http and net modules.

EEXIST (File exists): An existing file was the target of an operation that required that the target not exist.

EISDIR (Is a directory): An operation expected a file, but the given pathname was a directory.

EMFILE (Too many open files in system): Maximum number of file descriptors allowable on the system has been reached, and requests for another descriptor cannot be fulfilled until at least one has been closed. This is encountered when opening many files at once in parallel, especially on systems (in particular, macOS) where there is a low file descriptor limit for processes. To remedy a low limit, run ulimit -n 2048 in the same shell that will run the Node.js process.

ENOENT (No such file or directory): Commonly raised by fs operations to indicate that a component of the specified pathname does not exist. No entity (file or directory) could be found by the given path.

ENOTDIR (Not a directory): A component of the given pathname existed, but was not a directory as expected. Commonly raised by fs.readdir .

ENOTEMPTY (Directory not empty): A directory with entries was the target of an operation that requires an empty directory, usually fs.unlink .

ENOTFOUND (DNS lookup failed): Indicates a DNS failure of either EAI_NODATA or EAI_NONAME . This is not a standard POSIX error.

EPERM (Operation not permitted): An attempt was made to perform an operation that requires elevated privileges.

EPIPE (Broken pipe): A write on a pipe, socket, or FIFO for which there is no process to read the data. Commonly encountered at the net and http layers, indicative that the remote side of the stream being written to has been closed.

ETIMEDOUT (Operation timed out): A connect or send request failed because the connected party did not properly respond after a period of time. Usually encountered by http or net . Often a sign that a socket.end() was not properly called.

Class: TypeError #

Indicates that a provided argument is not an allowable type. For example, passing a function to a parameter which expects a string would be a TypeError .

Node.js will generate and throw TypeError instances immediately as a form of argument validation.

Exceptions vs. errors #

A JavaScript exception is a value that is thrown as a result of an invalid operation or as the target of a throw statement. While it is not required that these values are instances of Error or classes which inherit from Error , all exceptions thrown by Node.js or the JavaScript runtime will be instances of Error .

Some exceptions are unrecoverable at the JavaScript layer. Such exceptions will always cause the Node.js process to crash. Examples include assert() checks or abort() calls in the C++ layer.

OpenSSL errors #

Errors originating in crypto or tls are of class Error , and in addition to the standard .code and .message properties, may have some additional OpenSSL-specific properties.

error.opensslErrorStack #

An array of errors that can give context to where in the OpenSSL library an error originates from.

error.function #

The OpenSSL function the error originates in.

error.library #

The OpenSSL library the error originates in.

error.reason #

A human-readable string describing the reason for the error.

Node.js error codes #

ABORT_ERR #

Used when an operation has been aborted (typically using an AbortController ).

APIs not using AbortSignal s typically do not raise an error with this code.

This code does not use the regular ERR_* convention Node.js errors use in order to be compatible with the web platform’s AbortError .

ERR_AMBIGUOUS_ARGUMENT #

A function argument is being used in a way that suggests that the function signature may be misunderstood. This is thrown by the node:assert module when the message parameter in assert.throws(block, message) matches the error message thrown by block because that usage suggests that the user believes message is the expected message rather than the message the AssertionError will display if block does not throw.

ERR_ARG_NOT_ITERABLE #

An iterable argument (i.e. a value that works with for. of loops) was required, but not provided to a Node.js API.

ERR_ASSERTION #

A special type of error that can be triggered whenever Node.js detects an exceptional logic violation that should never occur. These are raised typically by the node:assert module.

ERR_ASSERT_SNAPSHOT_NOT_SUPPORTED #

An attempt was made to use assert.snapshot() in an environment that does not support snapshots, such as the REPL, or when using node —eval .

ERR_ASYNC_CALLBACK #

An attempt was made to register something that is not a function as an AsyncHooks callback.

ERR_ASYNC_TYPE #

The type of an asynchronous resource was invalid. Users are also able to define their own types if using the public embedder API.

ERR_BROTLI_COMPRESSION_FAILED #

Data passed to a Brotli stream was not successfully compressed.

ERR_BROTLI_INVALID_PARAM #

An invalid parameter key was passed during construction of a Brotli stream.

ERR_BUFFER_CONTEXT_NOT_AVAILABLE #

An attempt was made to create a Node.js Buffer instance from addon or embedder code, while in a JS engine Context that is not associated with a Node.js instance. The data passed to the Buffer method will have been released by the time the method returns.

When encountering this error, a possible alternative to creating a Buffer instance is to create a normal Uint8Array , which only differs in the prototype of the resulting object. Uint8Array s are generally accepted in all Node.js core APIs where Buffer s are; they are available in all Contexts.

ERR_BUFFER_OUT_OF_BOUNDS #

An operation outside the bounds of a Buffer was attempted.

ERR_BUFFER_TOO_LARGE #

An attempt has been made to create a Buffer larger than the maximum allowed size.

ERR_CANNOT_WATCH_SIGINT #

Node.js was unable to watch for the SIGINT signal.

ERR_CHILD_CLOSED_BEFORE_REPLY #

A child process was closed before the parent received a reply.

ERR_CHILD_PROCESS_IPC_REQUIRED #

Used when a child process is being forked without specifying an IPC channel.

ERR_CHILD_PROCESS_STDIO_MAXBUFFER #

Used when the main process is trying to read data from the child process’s STDERR/STDOUT, and the data’s length is longer than the maxBuffer option.

ERR_CLOSED_MESSAGE_PORT #

There was an attempt to use a MessagePort instance in a closed state, usually after .close() has been called.

ERR_CONSOLE_WRITABLE_STREAM #

Console was instantiated without stdout stream, or Console has a non-writable stdout or stderr stream.

ERR_CONSTRUCT_CALL_INVALID #

A class constructor was called that is not callable.

ERR_CONSTRUCT_CALL_REQUIRED #

A constructor for a class was called without new .

ERR_CONTEXT_NOT_INITIALIZED #

The vm context passed into the API is not yet initialized. This could happen when an error occurs (and is caught) during the creation of the context, for example, when the allocation fails or the maximum call stack size is reached when the context is created.

ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED #

A client certificate engine was requested that is not supported by the version of OpenSSL being used.

ERR_CRYPTO_ECDH_INVALID_FORMAT #

An invalid value for the format argument was passed to the crypto.ECDH() class getPublicKey() method.

ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY #

An invalid value for the key argument has been passed to the crypto.ECDH() class computeSecret() method. It means that the public key lies outside of the elliptic curve.

ERR_CRYPTO_ENGINE_UNKNOWN #

An invalid crypto engine identifier was passed to require(‘node:crypto’).setEngine() .

ERR_CRYPTO_FIPS_FORCED #

The —force-fips command-line argument was used but there was an attempt to enable or disable FIPS mode in the node:crypto module.

ERR_CRYPTO_FIPS_UNAVAILABLE #

An attempt was made to enable or disable FIPS mode, but FIPS mode was not available.

ERR_CRYPTO_HASH_FINALIZED #

hash.digest() was called multiple times. The hash.digest() method must be called no more than one time per instance of a Hash object.

ERR_CRYPTO_HASH_UPDATE_FAILED #

hash.update() failed for any reason. This should rarely, if ever, happen.

ERR_CRYPTO_INCOMPATIBLE_KEY #

The given crypto keys are incompatible with the attempted operation.

ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS #

The selected public or private key encoding is incompatible with other options.

ERR_CRYPTO_INITIALIZATION_FAILED #

Initialization of the crypto subsystem failed.

ERR_CRYPTO_INVALID_AUTH_TAG #

An invalid authentication tag was provided.

ERR_CRYPTO_INVALID_COUNTER #

An invalid counter was provided for a counter-mode cipher.

ERR_CRYPTO_INVALID_CURVE #

An invalid elliptic-curve was provided.

ERR_CRYPTO_INVALID_DIGEST #

An invalid crypto digest algorithm was specified.

ERR_CRYPTO_INVALID_IV #

An invalid initialization vector was provided.

ERR_CRYPTO_INVALID_JWK #

An invalid JSON Web Key was provided.

ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE #

The given crypto key object’s type is invalid for the attempted operation.

ERR_CRYPTO_INVALID_KEYLEN #

An invalid key length was provided.

ERR_CRYPTO_INVALID_KEYPAIR #

An invalid key pair was provided.

ERR_CRYPTO_INVALID_KEYTYPE #

An invalid key type was provided.

ERR_CRYPTO_INVALID_MESSAGELEN #

An invalid message length was provided.

ERR_CRYPTO_INVALID_SCRYPT_PARAMS #

Invalid scrypt algorithm parameters were provided.

ERR_CRYPTO_INVALID_STATE #

A crypto method was used on an object that was in an invalid state. For instance, calling cipher.getAuthTag() before calling cipher.final() .

ERR_CRYPTO_INVALID_TAG_LENGTH #

An invalid authentication tag length was provided.

ERR_CRYPTO_JOB_INIT_FAILED #

Initialization of an asynchronous crypto operation failed.

ERR_CRYPTO_JWK_UNSUPPORTED_CURVE #

Key’s Elliptic Curve is not registered for use in the JSON Web Key Elliptic Curve Registry.

ERR_CRYPTO_JWK_UNSUPPORTED_KEY_TYPE #

Key’s Asymmetric Key Type is not registered for use in the JSON Web Key Types Registry.

ERR_CRYPTO_OPERATION_FAILED #

A crypto operation failed for an otherwise unspecified reason.

ERR_CRYPTO_PBKDF2_ERROR #

The PBKDF2 algorithm failed for unspecified reasons. OpenSSL does not provide more details and therefore neither does Node.js.

ERR_CRYPTO_SCRYPT_INVALID_PARAMETER #

One or more crypto.scrypt() or crypto.scryptSync() parameters are outside their legal range.

ERR_CRYPTO_SCRYPT_NOT_SUPPORTED #

Node.js was compiled without scrypt support. Not possible with the official release binaries but can happen with custom builds, including distro builds.

ERR_CRYPTO_SIGN_KEY_REQUIRED #

A signing key was not provided to the sign.sign() method.

ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH #

crypto.timingSafeEqual() was called with Buffer , TypedArray , or DataView arguments of different lengths.

ERR_CRYPTO_UNKNOWN_CIPHER #

An unknown cipher was specified.

ERR_CRYPTO_UNKNOWN_DH_GROUP #

An unknown Diffie-Hellman group name was given. See crypto.getDiffieHellman() for a list of valid group names.

ERR_CRYPTO_UNSUPPORTED_OPERATION #

An attempt to invoke an unsupported crypto operation was made.

ERR_DEBUGGER_ERROR #

An error occurred with the debugger.

ERR_DEBUGGER_STARTUP_ERROR #

The debugger timed out waiting for the required host/port to be free.

ERR_DLOPEN_DISABLED #

Loading native addons has been disabled using —no-addons .

ERR_DLOPEN_FAILED #

A call to process.dlopen() failed.

ERR_DIR_CLOSED #

The fs.Dir was previously closed.

ERR_DIR_CONCURRENT_OPERATION #

A synchronous read or close call was attempted on an fs.Dir which has ongoing asynchronous operations.

ERR_DNS_SET_SERVERS_FAILED #

c-ares failed to set the DNS server.

ERR_DOMAIN_CALLBACK_NOT_AVAILABLE #

The node:domain module was not usable since it could not establish the required error handling hooks, because process.setUncaughtExceptionCaptureCallback() had been called at an earlier point in time.

ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE #

process.setUncaughtExceptionCaptureCallback() could not be called because the node:domain module has been loaded at an earlier point in time.

The stack trace is extended to include the point in time at which the node:domain module had been loaded.

ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION #

v8.startupSnapshot.setDeserializeMainFunction() could not be called because it had already been called before.

ERR_ENCODING_INVALID_ENCODED_DATA #

Data provided to TextDecoder() API was invalid according to the encoding provided.

ERR_ENCODING_NOT_SUPPORTED #

Encoding provided to TextDecoder() API was not one of the WHATWG Supported Encodings.

ERR_EVAL_ESM_CANNOT_PRINT #

—print cannot be used with ESM input.

ERR_EVENT_RECURSION #

Thrown when an attempt is made to recursively dispatch an event on EventTarget .

ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE #

The JS execution context is not associated with a Node.js environment. This may occur when Node.js is used as an embedded library and some hooks for the JS engine are not set up properly.

ERR_FALSY_VALUE_REJECTION #

A Promise that was callbackified via util.callbackify() was rejected with a falsy value.

ERR_FEATURE_UNAVAILABLE_ON_PLATFORM #

Used when a feature that is not available to the current platform which is running Node.js is used.

ERR_FS_CP_DIR_TO_NON_DIR #

An attempt was made to copy a directory to a non-directory (file, symlink, etc.) using fs.cp() .

ERR_FS_CP_EEXIST #

An attempt was made to copy over a file that already existed with fs.cp() , with the force and errorOnExist set to true .

ERR_FS_CP_EINVAL #

When using fs.cp() , src or dest pointed to an invalid path.

ERR_HTTP_CONTENT_LENGTH_MISMATCH #

Response body size doesn’t match with the specified content-length header value.

ERR_FS_CP_FIFO_PIPE #

An attempt was made to copy a named pipe with fs.cp() .

ERR_FS_CP_NON_DIR_TO_DIR #

An attempt was made to copy a non-directory (file, symlink, etc.) to a directory using fs.cp() .

ERR_FS_CP_SOCKET #

An attempt was made to copy to a socket with fs.cp() .

ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY #

When using fs.cp() , a symlink in dest pointed to a subdirectory of src .

ERR_FS_CP_UNKNOWN #

An attempt was made to copy to an unknown file type with fs.cp() .

ERR_FS_EISDIR #

Path is a directory.

ERR_FS_FILE_TOO_LARGE #

An attempt has been made to read a file whose size is larger than the maximum allowed size for a Buffer .

ERR_FS_INVALID_SYMLINK_TYPE #

An invalid symlink type was passed to the fs.symlink() or fs.symlinkSync() methods.

An attempt was made to add more headers after the headers had already been sent.

An invalid HTTP header value was specified.

ERR_HTTP_INVALID_STATUS_CODE #

Status code was outside the regular status code range (100-999).

ERR_HTTP_REQUEST_TIMEOUT #

The client has not sent the entire request within the allowed time.

ERR_HTTP_SOCKET_ENCODING #

Changing the socket encoding is not allowed per RFC 7230 Section 3.

ERR_HTTP_TRAILER_INVALID #

The Trailer header was set even though the transfer encoding does not support that.

ERR_HTTP2_ALTSVC_INVALID_ORIGIN #

HTTP/2 ALTSVC frames require a valid origin.

ERR_HTTP2_ALTSVC_LENGTH #

HTTP/2 ALTSVC frames are limited to a maximum of 16,382 payload bytes.

For HTTP/2 requests using the CONNECT method, the :authority pseudo-header is required.

ERR_HTTP2_CONNECT_PATH #

For HTTP/2 requests using the CONNECT method, the :path pseudo-header is forbidden.

ERR_HTTP2_CONNECT_SCHEME #

For HTTP/2 requests using the CONNECT method, the :scheme pseudo-header is forbidden.

ERR_HTTP2_ERROR #

A non-specific HTTP/2 error has occurred.

ERR_HTTP2_GOAWAY_SESSION #

New HTTP/2 Streams may not be opened after the Http2Session has received a GOAWAY frame from the connected peer.

Multiple values were provided for an HTTP/2 header field that was required to have only a single value.

An additional headers was specified after an HTTP/2 response was initiated.

An attempt was made to send multiple response headers.

ERR_HTTP2_INFO_STATUS_NOT_ALLOWED #

Informational HTTP status codes ( 1xx ) may not be set as the response status code on HTTP/2 responses.

HTTP/1 connection specific headers are forbidden to be used in HTTP/2 requests and responses.

An invalid HTTP/2 header value was specified.

ERR_HTTP2_INVALID_INFO_STATUS #

An invalid HTTP informational status code has been specified. Informational status codes must be an integer between 100 and 199 (inclusive).

ERR_HTTP2_INVALID_ORIGIN #

HTTP/2 ORIGIN frames require a valid origin.

ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH #

Input Buffer and Uint8Array instances passed to the http2.getUnpackedSettings() API must have a length that is a multiple of six.

Only valid HTTP/2 pseudoheaders ( :status , :path , :authority , :scheme , and :method ) may be used.

ERR_HTTP2_INVALID_SESSION #

An action was performed on an Http2Session object that had already been destroyed.

ERR_HTTP2_INVALID_SETTING_VALUE #

An invalid value has been specified for an HTTP/2 setting.

ERR_HTTP2_INVALID_STREAM #

An operation was performed on a stream that had already been destroyed.

ERR_HTTP2_MAX_PENDING_SETTINGS_ACK #

Whenever an HTTP/2 SETTINGS frame is sent to a connected peer, the peer is required to send an acknowledgment that it has received and applied the new SETTINGS . By default, a maximum number of unacknowledged SETTINGS frames may be sent at any given time. This error code is used when that limit has been reached.

ERR_HTTP2_NESTED_PUSH #

An attempt was made to initiate a new push stream from within a push stream. Nested push streams are not permitted.

ERR_HTTP2_NO_MEM #

Out of memory when using the http2session.setLocalWindowSize(windowSize) API.

ERR_HTTP2_NO_SOCKET_MANIPULATION #

An attempt was made to directly manipulate (read, write, pause, resume, etc.) a socket attached to an Http2Session .

ERR_HTTP2_ORIGIN_LENGTH #

HTTP/2 ORIGIN frames are limited to a length of 16382 bytes.

ERR_HTTP2_OUT_OF_STREAMS #

The number of streams created on a single HTTP/2 session reached the maximum limit.

ERR_HTTP2_PAYLOAD_FORBIDDEN #

A message payload was specified for an HTTP response code for which a payload is forbidden.

ERR_HTTP2_PING_CANCEL #

An HTTP/2 ping was canceled.

ERR_HTTP2_PING_LENGTH #

HTTP/2 ping payloads must be exactly 8 bytes in length.

An HTTP/2 pseudo-header has been used inappropriately. Pseudo-headers are header key names that begin with the : prefix.

ERR_HTTP2_PUSH_DISABLED #

An attempt was made to create a push stream, which had been disabled by the client.

ERR_HTTP2_SEND_FILE #

An attempt was made to use the Http2Stream.prototype.responseWithFile() API to send a directory.

ERR_HTTP2_SEND_FILE_NOSEEK #

An attempt was made to use the Http2Stream.prototype.responseWithFile() API to send something other than a regular file, but offset or length options were provided.

ERR_HTTP2_SESSION_ERROR #

The Http2Session closed with a non-zero error code.

ERR_HTTP2_SETTINGS_CANCEL #

The Http2Session settings canceled.

ERR_HTTP2_SOCKET_BOUND #

An attempt was made to connect a Http2Session object to a net.Socket or tls.TLSSocket that had already been bound to another Http2Session object.

ERR_HTTP2_SOCKET_UNBOUND #

An attempt was made to use the socket property of an Http2Session that has already been closed.

ERR_HTTP2_STATUS_101 #

Use of the 101 Informational status code is forbidden in HTTP/2.

ERR_HTTP2_STATUS_INVALID #

An invalid HTTP status code has been specified. Status codes must be an integer between 100 and 599 (inclusive).

ERR_HTTP2_STREAM_CANCEL #

An Http2Stream was destroyed before any data was transmitted to the connected peer.

ERR_HTTP2_STREAM_ERROR #

A non-zero error code was been specified in an RST_STREAM frame.

ERR_HTTP2_STREAM_SELF_DEPENDENCY #

When setting the priority for an HTTP/2 stream, the stream may be marked as a dependency for a parent stream. This error code is used when an attempt is made to mark a stream and dependent of itself.

ERR_HTTP2_TOO_MANY_INVALID_FRAMES #

The limit of acceptable invalid HTTP/2 protocol frames sent by the peer, as specified through the maxSessionInvalidFrames option, has been exceeded.

ERR_HTTP2_TRAILERS_ALREADY_SENT #

Trailing headers have already been sent on the Http2Stream .

ERR_HTTP2_TRAILERS_NOT_READY #

The http2stream.sendTrailers() method cannot be called until after the ‘wantTrailers’ event is emitted on an Http2Stream object. The ‘wantTrailers’ event will only be emitted if the waitForTrailers option is set for the Http2Stream .

ERR_HTTP2_UNSUPPORTED_PROTOCOL #

http2.connect() was passed a URL that uses any protocol other than http: or https: .

ERR_ILLEGAL_CONSTRUCTOR #

An attempt was made to construct an object using a non-public constructor.

ERR_IMPORT_ASSERTION_TYPE_FAILED #

An import assertion has failed, preventing the specified module to be imported.

ERR_IMPORT_ASSERTION_TYPE_MISSING #

An import assertion is missing, preventing the specified module to be imported.

ERR_IMPORT_ASSERTION_TYPE_UNSUPPORTED #

An import assertion is not supported by this version of Node.js.

ERR_INCOMPATIBLE_OPTION_PAIR #

An option pair is incompatible with each other and cannot be used at the same time.

ERR_INPUT_TYPE_NOT_ALLOWED #

The —input-type flag was used to attempt to execute a file. This flag can only be used with input via —eval , —print , or STDIN .

ERR_INSPECTOR_ALREADY_ACTIVATED #

While using the node:inspector module, an attempt was made to activate the inspector when it already started to listen on a port. Use inspector.close() before activating it on a different address.

ERR_INSPECTOR_ALREADY_CONNECTED #

While using the node:inspector module, an attempt was made to connect when the inspector was already connected.

ERR_INSPECTOR_CLOSED #

While using the node:inspector module, an attempt was made to use the inspector after the session had already closed.

ERR_INSPECTOR_COMMAND #

An error occurred while issuing a command via the node:inspector module.

ERR_INSPECTOR_NOT_ACTIVE #

The inspector is not active when inspector.waitForDebugger() is called.

ERR_INSPECTOR_NOT_AVAILABLE #

The node:inspector module is not available for use.

ERR_INSPECTOR_NOT_CONNECTED #

While using the node:inspector module, an attempt was made to use the inspector before it was connected.

ERR_INSPECTOR_NOT_WORKER #

An API was called on the main thread that can only be used from the worker thread.

ERR_INTERNAL_ASSERTION #

There was a bug in Node.js or incorrect usage of Node.js internals. To fix the error, open an issue at https://github.com/nodejs/node/issues.

ERR_INVALID_ADDRESS_FAMILY #

The provided address family is not understood by the Node.js API.

ERR_INVALID_ARG_TYPE #

An argument of the wrong type was passed to a Node.js API.

ERR_INVALID_ARG_VALUE #

An invalid or unsupported value was passed for a given argument.

ERR_INVALID_ASYNC_ID #

An invalid asyncId or triggerAsyncId was passed using AsyncHooks . An id less than -1 should never happen.

ERR_INVALID_BUFFER_SIZE #

A swap was performed on a Buffer but its size was not compatible with the operation.

ERR_INVALID_CHAR #

Invalid characters were detected in headers.

ERR_INVALID_CURSOR_POS #

A cursor on a given stream cannot be moved to a specified row without a specified column.

ERR_INVALID_FD #

A file descriptor (‘fd’) was not valid (e.g. it was a negative value).

ERR_INVALID_FD_TYPE #

A file descriptor (‘fd’) type was not valid.

ERR_INVALID_FILE_URL_HOST #

A Node.js API that consumes file: URLs (such as certain functions in the fs module) encountered a file URL with an incompatible host. This situation can only occur on Unix-like systems where only localhost or an empty host is supported.

ERR_INVALID_FILE_URL_PATH #

A Node.js API that consumes file: URLs (such as certain functions in the fs module) encountered a file URL with an incompatible path. The exact semantics for determining whether a path can be used is platform-dependent.

ERR_INVALID_HANDLE_TYPE #

An attempt was made to send an unsupported «handle» over an IPC communication channel to a child process. See subprocess.send() and process.send() for more information.

ERR_INVALID_HTTP_TOKEN #

An invalid HTTP token was supplied.

ERR_INVALID_IP_ADDRESS #

An IP address is not valid.

ERR_INVALID_MIME_SYNTAX #

The syntax of a MIME is not valid.

ERR_INVALID_MODULE #

An attempt was made to load a module that does not exist or was otherwise not valid.

ERR_INVALID_MODULE_SPECIFIER #

The imported module string is an invalid URL, package name, or package subpath specifier.

ERR_INVALID_OBJECT_DEFINE_PROPERTY #

An error occurred while setting an invalid attribute on the property of an object.

ERR_INVALID_PACKAGE_CONFIG #

An invalid package.json file failed parsing.

ERR_INVALID_PACKAGE_TARGET #

The package.json «exports» field contains an invalid target mapping value for the attempted module resolution.

ERR_INVALID_PERFORMANCE_MARK #

While using the Performance Timing API ( perf_hooks ), a performance mark is invalid.

ERR_INVALID_PROTOCOL #

An invalid options.protocol was passed to http.request() .

ERR_INVALID_REPL_EVAL_CONFIG #

Both breakEvalOnSigint and eval options were set in the REPL config, which is not supported.

ERR_INVALID_REPL_INPUT #

The input may not be used in the REPL . The conditions under which this error is used are described in the REPL documentation.

ERR_INVALID_RETURN_PROPERTY #

Thrown in case a function option does not provide a valid value for one of its returned object properties on execution.

ERR_INVALID_RETURN_PROPERTY_VALUE #

Thrown in case a function option does not provide an expected value type for one of its returned object properties on execution.

ERR_INVALID_RETURN_VALUE #

Thrown in case a function option does not return an expected value type on execution, such as when a function is expected to return a promise.

ERR_INVALID_STATE #

Indicates that an operation cannot be completed due to an invalid state. For instance, an object may have already been destroyed, or may be performing another operation.

ERR_INVALID_SYNC_FORK_INPUT #

A Buffer , TypedArray , DataView , or string was provided as stdio input to an asynchronous fork. See the documentation for the child_process module for more information.

ERR_INVALID_THIS #

A Node.js API function was called with an incompatible this value.

ERR_INVALID_TRANSFER_OBJECT #

An invalid transfer object was passed to postMessage() .

ERR_INVALID_TUPLE #

An element in the iterable provided to the WHATWG URLSearchParams constructor did not represent a [name, value] tuple – that is, if an element is not iterable, or does not consist of exactly two elements.

ERR_INVALID_URI #

An invalid URI was passed.

ERR_INVALID_URL #

An invalid URL was passed to the WHATWG URL constructor or the legacy url.parse() to be parsed. The thrown error object typically has an additional property ‘input’ that contains the URL that failed to parse.

ERR_INVALID_URL_SCHEME #

An attempt was made to use a URL of an incompatible scheme (protocol) for a specific purpose. It is only used in the WHATWG URL API support in the fs module (which only accepts URLs with ‘file’ scheme), but may be used in other Node.js APIs as well in the future.

ERR_IPC_CHANNEL_CLOSED #

An attempt was made to use an IPC communication channel that was already closed.

ERR_IPC_DISCONNECTED #

An attempt was made to disconnect an IPC communication channel that was already disconnected. See the documentation for the child_process module for more information.

ERR_IPC_ONE_PIPE #

An attempt was made to create a child Node.js process using more than one IPC communication channel. See the documentation for the child_process module for more information.

ERR_IPC_SYNC_FORK #

An attempt was made to open an IPC communication channel with a synchronously forked Node.js process. See the documentation for the child_process module for more information.

ERR_LOADER_CHAIN_INCOMPLETE #

An ESM loader hook returned without calling next() and without explicitly signaling a short circuit.

ERR_MANIFEST_ASSERT_INTEGRITY #

An attempt was made to load a resource, but the resource did not match the integrity defined by the policy manifest. See the documentation for policy manifests for more information.

ERR_MANIFEST_DEPENDENCY_MISSING #

An attempt was made to load a resource, but the resource was not listed as a dependency from the location that attempted to load it. See the documentation for policy manifests for more information.

ERR_MANIFEST_INTEGRITY_MISMATCH #

An attempt was made to load a policy manifest, but the manifest had multiple entries for a resource which did not match each other. Update the manifest entries to match in order to resolve this error. See the documentation for policy manifests for more information.

ERR_MANIFEST_INVALID_RESOURCE_FIELD #

A policy manifest resource had an invalid value for one of its fields. Update the manifest entry to match in order to resolve this error. See the documentation for policy manifests for more information.

ERR_MANIFEST_INVALID_SPECIFIER #

A policy manifest resource had an invalid value for one of its dependency mappings. Update the manifest entry to match to resolve this error. See the documentation for policy manifests for more information.

ERR_MANIFEST_PARSE_POLICY #

An attempt was made to load a policy manifest, but the manifest was unable to be parsed. See the documentation for policy manifests for more information.

ERR_MANIFEST_TDZ #

An attempt was made to read from a policy manifest, but the manifest initialization has not yet taken place. This is likely a bug in Node.js.

ERR_MANIFEST_UNKNOWN_ONERROR #

A policy manifest was loaded, but had an unknown value for its «onerror» behavior. See the documentation for policy manifests for more information.

ERR_MEMORY_ALLOCATION_FAILED #

An attempt was made to allocate memory (usually in the C++ layer) but it failed.

ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE #

A message posted to a MessagePort could not be deserialized in the target vm Context . Not all Node.js objects can be successfully instantiated in any context at this time, and attempting to transfer them using postMessage() can fail on the receiving side in that case.

ERR_METHOD_NOT_IMPLEMENTED #

A method is required but not implemented.

ERR_MISSING_ARGS #

A required argument of a Node.js API was not passed. This is only used for strict compliance with the API specification (which in some cases may accept func(undefined) but not func() ). In most native Node.js APIs, func(undefined) and func() are treated identically, and the ERR_INVALID_ARG_TYPE error code may be used instead.

ERR_MISSING_OPTION #

For APIs that accept options objects, some options might be mandatory. This code is thrown if a required option is missing.

ERR_MISSING_PASSPHRASE #

An attempt was made to read an encrypted key without specifying a passphrase.

ERR_MISSING_PLATFORM_FOR_WORKER #

The V8 platform used by this instance of Node.js does not support creating Workers. This is caused by lack of embedder support for Workers. In particular, this error will not occur with standard builds of Node.js.

ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST #

An object that needs to be explicitly listed in the transferList argument is in the object passed to a postMessage() call, but is not provided in the transferList for that call. Usually, this is a MessagePort .

In Node.js versions prior to v15.0.0, the error code being used here was ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST . However, the set of transferable object types has been expanded to cover more types than MessagePort .

ERR_MODULE_NOT_FOUND #

A module file could not be resolved by the ECMAScript modules loader while attempting an import operation or when loading the program entry point.

ERR_MULTIPLE_CALLBACK #

A callback was called more than once.

A callback is almost always meant to only be called once as the query can either be fulfilled or rejected but not both at the same time. The latter would be possible by calling a callback more than once.

ERR_NAPI_CONS_FUNCTION #

While using Node-API , a constructor passed was not a function.

ERR_NAPI_INVALID_DATAVIEW_ARGS #

While calling napi_create_dataview() , a given offset was outside the bounds of the dataview or offset + length was larger than a length of given buffer .

ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT #

While calling napi_create_typedarray() , the provided offset was not a multiple of the element size.

ERR_NAPI_INVALID_TYPEDARRAY_LENGTH #

While calling napi_create_typedarray() , (length * size_of_element) + byte_offset was larger than the length of given buffer .

ERR_NAPI_TSFN_CALL_JS #

An error occurred while invoking the JavaScript portion of the thread-safe function.

ERR_NAPI_TSFN_GET_UNDEFINED #

An error occurred while attempting to retrieve the JavaScript undefined value.

ERR_NAPI_TSFN_START_IDLE_LOOP #

On the main thread, values are removed from the queue associated with the thread-safe function in an idle loop. This error indicates that an error has occurred when attempting to start the loop.

ERR_NAPI_TSFN_STOP_IDLE_LOOP #

Once no more items are left in the queue, the idle loop must be suspended. This error indicates that the idle loop has failed to stop.

ERR_NOT_BUILDING_SNAPSHOT #

An attempt was made to use operations that can only be used when building V8 startup snapshot even though Node.js isn’t building one.

ERR_NO_CRYPTO #

An attempt was made to use crypto features while Node.js was not compiled with OpenSSL crypto support.

ERR_NO_ICU #

An attempt was made to use features that require ICU, but Node.js was not compiled with ICU support.

ERR_NON_CONTEXT_AWARE_DISABLED #

A non-context-aware native addon was loaded in a process that disallows them.

ERR_OUT_OF_RANGE #

A given value is out of the accepted range.

ERR_PACKAGE_IMPORT_NOT_DEFINED #

The package.json «imports» field does not define the given internal package specifier mapping.

ERR_PACKAGE_PATH_NOT_EXPORTED #

The package.json «exports» field does not export the requested subpath. Because exports are encapsulated, private internal modules that are not exported cannot be imported through the package resolution, unless using an absolute URL.

ERR_PARSE_ARGS_INVALID_OPTION_VALUE #

When strict set to true , thrown by util.parseArgs() if a value is provided for an option of type , or if a value is provided for an option of type .

ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL #

Thrown by util.parseArgs() , when a positional argument is provided and allowPositionals is set to false .

ERR_PARSE_ARGS_UNKNOWN_OPTION #

When strict set to true , thrown by util.parseArgs() if an argument is not configured in options .

ERR_PERFORMANCE_INVALID_TIMESTAMP #

An invalid timestamp value was provided for a performance mark or measure.

ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS #

Invalid options were provided for a performance measure.

ERR_PROTO_ACCESS #

Accessing Object.prototype.__proto__ has been forbidden using —disable-proto=throw . Object.getPrototypeOf and Object.setPrototypeOf should be used to get and set the prototype of an object.

ERR_REQUIRE_ESM #

An attempt was made to require() an ES Module.

ERR_SCRIPT_EXECUTION_INTERRUPTED #

Script execution was interrupted by SIGINT (For example, Ctrl + C was pressed.)

ERR_SCRIPT_EXECUTION_TIMEOUT #

Script execution timed out, possibly due to bugs in the script being executed.

ERR_SERVER_ALREADY_LISTEN #

The server.listen() method was called while a net.Server was already listening. This applies to all instances of net.Server , including HTTP, HTTPS, and HTTP/2 Server instances.

ERR_SERVER_NOT_RUNNING #

The server.close() method was called when a net.Server was not running. This applies to all instances of net.Server , including HTTP, HTTPS, and HTTP/2 Server instances.

ERR_SOCKET_ALREADY_BOUND #

An attempt was made to bind a socket that has already been bound.

ERR_SOCKET_BAD_BUFFER_SIZE #

An invalid (negative) size was passed for either the recvBufferSize or sendBufferSize options in dgram.createSocket() .

ERR_SOCKET_BAD_PORT #

An API function expecting a port >= 0 and ERR_SOCKET_BAD_TYPE #

An API function expecting a socket type ( udp4 or udp6 ) received an invalid value.

ERR_SOCKET_BUFFER_SIZE #

While using dgram.createSocket() , the size of the receive or send Buffer could not be determined.

ERR_SOCKET_CLOSED #

An attempt was made to operate on an already closed socket.

ERR_SOCKET_CLOSED_BEFORE_CONNECTION #

When calling net.Socket.write() on a connecting socket and the socket was closed before the connection was established.

ERR_SOCKET_DGRAM_IS_CONNECTED #

A dgram.connect() call was made on an already connected socket.

ERR_SOCKET_DGRAM_NOT_CONNECTED #

A dgram.disconnect() or dgram.remoteAddress() call was made on a disconnected socket.

ERR_SOCKET_DGRAM_NOT_RUNNING #

A call was made and the UDP subsystem was not running.

ERR_SRI_PARSE #

A string was provided for a Subresource Integrity check, but was unable to be parsed. Check the format of integrity attributes by looking at the Subresource Integrity specification.

ERR_STREAM_ALREADY_FINISHED #

A stream method was called that cannot complete because the stream was finished.

ERR_STREAM_CANNOT_PIPE #

An attempt was made to call stream.pipe() on a Writable stream.

ERR_STREAM_DESTROYED #

A stream method was called that cannot complete because the stream was destroyed using stream.destroy() .

ERR_STREAM_NULL_VALUES #

An attempt was made to call stream.write() with a null chunk.

ERR_STREAM_PREMATURE_CLOSE #

An error returned by stream.finished() and stream.pipeline() , when a stream or a pipeline ends non gracefully with no explicit error.

ERR_STREAM_PUSH_AFTER_EOF #

An attempt was made to call stream.push() after a null (EOF) had been pushed to the stream.

ERR_STREAM_UNSHIFT_AFTER_END_EVENT #

An attempt was made to call stream.unshift() after the ‘end’ event was emitted.

ERR_STREAM_WRAP #

Prevents an abort if a string decoder was set on the Socket or if the decoder is in objectMode .

ERR_STREAM_WRITE_AFTER_END #

An attempt was made to call stream.write() after stream.end() has been called.

ERR_STRING_TOO_LONG #

An attempt has been made to create a string longer than the maximum allowed length.

ERR_SYNTHETIC #

An artificial error object used to capture the call stack for diagnostic reports.

ERR_SYSTEM_ERROR #

An unspecified or non-specific system error has occurred within the Node.js process. The error object will have an err.info object property with additional details.

ERR_TAP_LEXER_ERROR #

An error representing a failing lexer state.

ERR_TAP_PARSER_ERROR #

An error representing a failing parser state. Additional information about the token causing the error is available via the cause property.

ERR_TAP_VALIDATION_ERROR #

This error represents a failed TAP validation.

ERR_TEST_FAILURE #

This error represents a failed test. Additional information about the failure is available via the cause property. The failureType property specifies what the test was doing when the failure occurred.

ERR_TLS_CERT_ALTNAME_FORMAT #

This error is thrown by checkServerIdentity if a user-supplied subjectaltname property violates encoding rules. Certificate objects produced by Node.js itself always comply with encoding rules and will never cause this error.

ERR_TLS_CERT_ALTNAME_INVALID #

While using TLS, the host name/IP of the peer did not match any of the subjectAltNames in its certificate.

ERR_TLS_DH_PARAM_SIZE #

While using TLS, the parameter offered for the Diffie-Hellman ( DH ) key-agreement protocol is too small. By default, the key length must be greater than or equal to 1024 bits to avoid vulnerabilities, even though it is strongly recommended to use 2048 bits or larger for stronger security.

ERR_TLS_HANDSHAKE_TIMEOUT #

A TLS/SSL handshake timed out. In this case, the server must also abort the connection.

ERR_TLS_INVALID_CONTEXT #

The context must be a SecureContext .

ERR_TLS_INVALID_PROTOCOL_METHOD #

The specified secureProtocol method is invalid. It is either unknown, or disabled because it is insecure.

ERR_TLS_INVALID_PROTOCOL_VERSION #

Valid TLS protocol versions are ‘TLSv1’ , ‘TLSv1.1’ , or ‘TLSv1.2’ .

ERR_TLS_INVALID_STATE #

The TLS socket must be connected and securely established. Ensure the ‘secure’ event is emitted before continuing.

ERR_TLS_PROTOCOL_VERSION_CONFLICT #

Attempting to set a TLS protocol minVersion or maxVersion conflicts with an attempt to set the secureProtocol explicitly. Use one mechanism or the other.

ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED #

Failed to set PSK identity hint. Hint may be too long.

ERR_TLS_RENEGOTIATION_DISABLED #

An attempt was made to renegotiate TLS on a socket instance with TLS disabled.

ERR_TLS_REQUIRED_SERVER_NAME #

While using TLS, the server.addContext() method was called without providing a host name in the first parameter.

ERR_TLS_SESSION_ATTACK #

An excessive amount of TLS renegotiations is detected, which is a potential vector for denial-of-service attacks.

ERR_TLS_SNI_FROM_SERVER #

An attempt was made to issue Server Name Indication from a TLS server-side socket, which is only valid from a client.

ERR_TRACE_EVENTS_CATEGORY_REQUIRED #

The trace_events.createTracing() method requires at least one trace event category.

ERR_TRACE_EVENTS_UNAVAILABLE #

The node:trace_events module could not be loaded because Node.js was compiled with the —without-v8-platform flag.

ERR_TRANSFORM_ALREADY_TRANSFORMING #

A Transform stream finished while it was still transforming.

ERR_TRANSFORM_WITH_LENGTH_0 #

A Transform stream finished with data still in the write buffer.

ERR_TTY_INIT_FAILED #

The initialization of a TTY failed due to a system error.

ERR_UNAVAILABLE_DURING_EXIT #

Function was called within a process.on(‘exit’) handler that shouldn’t be called within process.on(‘exit’) handler.

ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET #

process.setUncaughtExceptionCaptureCallback() was called twice, without first resetting the callback to null .

This error is designed to prevent accidentally overwriting a callback registered from another module.

ERR_UNESCAPED_CHARACTERS #

A string that contained unescaped characters was received.

ERR_UNHANDLED_ERROR #

An unhandled error occurred (for instance, when an ‘error’ event is emitted by an EventEmitter but an ‘error’ handler is not registered).

ERR_UNKNOWN_BUILTIN_MODULE #

Used to identify a specific kind of internal Node.js error that should not typically be triggered by user code. Instances of this error point to an internal bug within the Node.js binary itself.

ERR_UNKNOWN_CREDENTIAL #

A Unix group or user identifier that does not exist was passed.

ERR_UNKNOWN_ENCODING #

An invalid or unknown encoding option was passed to an API.

ERR_UNKNOWN_FILE_EXTENSION #

An attempt was made to load a module with an unknown or unsupported file extension.

ERR_UNKNOWN_MODULE_FORMAT #

An attempt was made to load a module with an unknown or unsupported format.

ERR_UNKNOWN_SIGNAL #

An invalid or unknown process signal was passed to an API expecting a valid signal (such as subprocess.kill() ).

ERR_UNSUPPORTED_DIR_IMPORT #

import a directory URL is unsupported. Instead, self-reference a package using its name and define a custom subpath in the «exports» field of the package.json file.

ERR_UNSUPPORTED_ESM_URL_SCHEME #

import with URL schemes other than file and data is unsupported.

ERR_USE_AFTER_CLOSE #

An attempt was made to use something that was already closed.

ERR_VALID_PERFORMANCE_ENTRY_TYPE #

While using the Performance Timing API ( perf_hooks ), no valid performance entry types are found.

ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING #

A dynamic import callback was not specified.

ERR_VM_MODULE_ALREADY_LINKED #

The module attempted to be linked is not eligible for linking, because of one of the following reasons:

• It has already been linked ( linkingStatus is ‘linked’ )
• It is being linked ( linkingStatus is ‘linking’ )
• Linking has failed for this module ( linkingStatus is ‘errored’ )

ERR_VM_MODULE_CACHED_DATA_REJECTED #

The cachedData option passed to a module constructor is invalid.

ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA #

Cached data cannot be created for modules which have already been evaluated.

ERR_VM_MODULE_DIFFERENT_CONTEXT #

The module being returned from the linker function is from a different context than the parent module. Linked modules must share the same context.

ERR_VM_MODULE_LINK_FAILURE #

The module was unable to be linked due to a failure.

ERR_VM_MODULE_NOT_MODULE #

The fulfilled value of a linking promise is not a vm.Module object.

ERR_VM_MODULE_STATUS #

The current module’s status does not allow for this operation. The specific meaning of the error depends on the specific function.

ERR_WASI_ALREADY_STARTED #

The WASI instance has already started.

ERR_WASI_NOT_STARTED #

The WASI instance has not been started.

ERR_WEBASSEMBLY_RESPONSE #

The Response that has been passed to WebAssembly.compileStreaming or to WebAssembly.instantiateStreaming is not a valid WebAssembly response.

ERR_WORKER_INIT_FAILED #

The Worker initialization failed.

ERR_WORKER_INVALID_EXEC_ARGV #

The execArgv option passed to the Worker constructor contains invalid flags.

ERR_WORKER_NOT_RUNNING #

An operation failed because the Worker instance is not currently running.

ERR_WORKER_OUT_OF_MEMORY #

The Worker instance terminated because it reached its memory limit.

ERR_WORKER_PATH #

The path for the main script of a worker is neither an absolute path nor a relative path starting with ./ or ../ .

ERR_WORKER_UNSERIALIZABLE_ERROR #

All attempts at serializing an uncaught exception from a worker thread failed.

ERR_WORKER_UNSUPPORTED_OPERATION #

The requested functionality is not supported in worker threads.

ERR_ZLIB_INITIALIZATION_FAILED #

Creation of a zlib object failed due to incorrect configuration.

History

Max header size in http_parser was set to 8 KiB.

Too much HTTP header data was received. In order to protect against malicious or malconfigured clients, if more than 8 KiB of HTTP header data is received then HTTP parsing will abort without a request or response object being created, and an Error with this code will be emitted.

HPE_UNEXPECTED_CONTENT_LENGTH #

Server is sending both a Content-Length header and Transfer-Encoding: chunked .

Transfer-Encoding: chunked allows the server to maintain an HTTP persistent connection for dynamically generated content. In this case, the Content-Length HTTP header cannot be used.

Use Content-Length or Transfer-Encoding: chunked .

MODULE_NOT_FOUND #

History

Version	Changes
v11.4.0, v10.15.0

Added requireStack property.

A module file could not be resolved by the CommonJS modules loader while attempting a require() operation or when loading the program entry point.

Legacy Node.js error codes #

ERR_CANNOT_TRANSFER_OBJECT #

The value passed to postMessage() contained an object that is not supported for transferring.

ERR_CRYPTO_HASH_DIGEST_NO_UTF16 #

The UTF-16 encoding was used with hash.digest() . While the hash.digest() method does allow an encoding argument to be passed in, causing the method to return a string rather than a Buffer , the UTF-16 encoding (e.g. ucs or utf16le ) is not supported.

ERR_HTTP2_FRAME_ERROR #

Used when a failure occurs sending an individual frame on the HTTP/2 session.

Used when an HTTP/2 Headers Object is expected.

Used when a required header is missing in an HTTP/2 message.

HTTP/2 informational headers must only be sent prior to calling the Http2Stream.prototype.respond() method.

ERR_HTTP2_STREAM_CLOSED #

Used when an action has been performed on an HTTP/2 Stream that has already been closed.

ERR_HTTP_INVALID_CHAR #

Used when an invalid character is found in an HTTP response status message (reason phrase).

ERR_INDEX_OUT_OF_RANGE #

A given index was out of the accepted range (e.g. negative offsets).

ERR_INVALID_OPT_VALUE #

An invalid or unexpected value was passed in an options object.

ERR_INVALID_OPT_VALUE_ENCODING #

An invalid or unknown file encoding was passed.

ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST #

This error code was replaced by ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST in Node.js v15.0.0, because it is no longer accurate as other types of transferable objects also exist now.

ERR_NAPI_CONS_PROTOTYPE_OBJECT #

Used by the Node-API when Constructor.prototype is not an object.

ERR_NETWORK_IMPORT_BAD_RESPONSE #

Response was received but was invalid when importing a module over the network.

ERR_NETWORK_IMPORT_DISALLOWED #

A network module attempted to load another module that it is not allowed to load. Likely this restriction is for security reasons.

ERR_NO_LONGER_SUPPORTED #

A Node.js API was called in an unsupported manner, such as Buffer.write(string, encoding, offset[, length]) .

ERR_OPERATION_FAILED #

An operation failed. This is typically used to signal the general failure of an asynchronous operation.

ERR_OUTOFMEMORY #

Used generically to identify that an operation caused an out of memory condition.

ERR_PARSE_HISTORY_DATA #

The node:repl module was unable to parse data from the REPL history file.

ERR_SOCKET_CANNOT_SEND #

Data could not be sent on a socket.

ERR_STDERR_CLOSE #

History

Version	Changes
v12.0.0

Rather than emitting an error, process.stderr.end() now only closes the stream side but not the underlying resource, making this error obsolete.

Removed in: v10.12.0

An attempt was made to close the process.stderr stream. By design, Node.js does not allow stdout or stderr streams to be closed by user code.

ERR_STDOUT_CLOSE #

History

Version	Changes
v10.12.0

Rather than emitting an error, process.stderr.end() now only closes the stream side but not the underlying resource, making this error obsolete.

Removed in: v10.12.0

An attempt was made to close the process.stdout stream. By design, Node.js does not allow stdout or stderr streams to be closed by user code.

ERR_STREAM_READ_NOT_IMPLEMENTED #

Used when an attempt is made to use a readable stream that has not implemented readable._read() .

ERR_TLS_RENEGOTIATION_FAILED #

Used when a TLS renegotiation request has failed in a non-specific way.

ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER #

A SharedArrayBuffer whose memory is not managed by the JavaScript engine or by Node.js was encountered during serialization. Such a SharedArrayBuffer cannot be serialized.

This can only happen when native addons create SharedArrayBuffer s in «externalized» mode, or put existing SharedArrayBuffer into externalized mode.

ERR_UNKNOWN_STDIN_TYPE #

An attempt was made to launch a Node.js process with an unknown stdin file type. This error is usually an indication of a bug within Node.js itself, although it is possible for user code to trigger it.

ERR_UNKNOWN_STREAM_TYPE #

An attempt was made to launch a Node.js process with an unknown stdout or stderr file type. This error is usually an indication of a bug within Node.js itself, although it is possible for user code to trigger it.

ERR_V8BREAKITERATOR #

The V8 BreakIterator API was used but the full ICU data set is not installed.

ERR_VALUE_OUT_OF_RANGE #

Used when a given value is out of the accepted range.

ERR_VM_MODULE_NOT_LINKED #

The module must be successfully linked before instantiation.

ERR_VM_MODULE_LINKING_ERRORED #

The linker function returned a module for which linking has failed.

ERR_WORKER_UNSUPPORTED_EXTENSION #

The pathname used for the main script of a worker has an unknown file extension.

ERR_ZLIB_BINDING_CLOSED #

Used when an attempt is made to use a zlib object after it has already been closed.

Источник

Adblock
detector

Version	Changes
v10.12.0

Stability: 3 - Stable

To use the HTTP server and client one must require('http').

The HTTP interfaces in Node are designed to support many features
of the protocol which have been traditionally difficult to use.
In particular, large, possibly chunk-encoded, messages. The interface is
careful to never buffer entire requests or responses—the
user is able to stream data.

HTTP message headers are represented by an object like this:

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

Keys are lowercased. Values are not modified.

In order to support the full spectrum of possible HTTP applications, Node’s
HTTP API is very low-level. It deals with stream handling and message
parsing only. It parses a message into headers and body but it does not
parse the actual headers or the body.

Defined headers that allow multiple values are concatenated with a ,
character, except for the set-cookie and cookie headers which are
represented as an array of values. Headers such as content-length
which can only have a single value are parsed accordingly, and only a
single value is represented on the parsed object.

The raw headers as they were received are retained in the rawHeaders
property, which is an array of [key, value, key2, value2, ...]. For
example, the previous message header object might have a rawHeaders
list like the following:

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

http.METHODS

• {Array}

A list of the HTTP methods that are supported by the parser.

http.STATUS_CODES

• {Object}

A collection of all the standard HTTP response status codes, and the
short description of each. For example, http.STATUS_CODES[404] === 'Not
Found'.

http.createServer([requestListener])

Returns a new instance of http.Server.

The requestListener is a function which is automatically
added to the 'request' event.

http.createClient([port][, host])

This function is deprecated; please use http.request() instead.
Constructs a new HTTP client. port and host refer to the server to be
connected to.

Class: http.Server

This is an EventEmitter with the following events:

Event: ‘request’

function (request, response) { }

Emitted each time there is a request. Note that there may be multiple requests
per connection (in the case of keep-alive connections).
request is an instance of http.IncomingMessage and response is
an instance of http.ServerResponse.

Event: ‘connection’

function (socket) { }

When a new TCP stream is established. socket is an object of type
net.Socket. Usually users will not want to access this event. In
particular, the socket will not emit readable events because of how
the protocol parser attaches to the socket. The socket can also be
accessed at request.connection.

Event: ‘close’

function () { }

Emitted when the server closes.

Event: ‘checkContinue’

function (request, response) { }

Emitted each time a request with an http Expect: 100-continue is received.
If this event isn’t listened for, the server will automatically respond
with a 100 Continue as appropriate.

Handling this event involves calling response.writeContinue() if the client
should continue to send the request body, or generating an appropriate HTTP
response (e.g., 400 Bad Request) if the client should not continue to send the
request body.

Note that when this event is emitted and handled, the request event will
not be emitted.

Event: ‘connect’

function (request, socket, head) { }

Emitted each time a client requests a http CONNECT method. If this event isn’t
listened for, then clients requesting a CONNECT method will have their
connections closed.

• request is the arguments for the http request, as it is in the request
  event.
• socket is the network socket between the server and client.
• head is an instance of Buffer, the first packet of the tunneling stream,
  this may be empty.

After this event is emitted, the request’s socket will not have a data
event listener, meaning you will need to bind to it in order to handle data
sent to the server on that socket.

Event: ‘upgrade’

function (request, socket, head) { }

Emitted each time a client requests a http upgrade. If this event isn’t
listened for, then clients requesting an upgrade will have their connections
closed.

• request is the arguments for the http request, as it is in the request
  event.
• socket is the network socket between the server and client.
• head is an instance of Buffer, the first packet of the upgraded stream,
  this may be empty.

After this event is emitted, the request’s socket will not have a data
event listener, meaning you will need to bind to it in order to handle data
sent to the server on that socket.

Event: ‘clientError’

function (exception, socket) { }

If a client connection emits an ‘error’ event, it will be forwarded here.

socket is the net.Socket object that the error originated from.

server.listen(port[, hostname][, backlog][, callback])

Begin accepting connections on the specified port and hostname. If the
hostname is omitted, the server will accept connections directed to any
IPv4 address (INADDR_ANY).

To listen to a unix socket, supply a filename instead of port and hostname.

Backlog is the maximum length of the queue of pending connections.
The actual length will be determined by your OS through sysctl settings such as
tcp_max_syn_backlog and somaxconn on linux. The default value of this
parameter is 511 (not 512).

This function is asynchronous. The last parameter callback will be added as
a listener for the ‘listening’ event. See also net.Server.listen(port).

server.listen(path[, callback])

Start a UNIX socket server listening for connections on the given path.

This function is asynchronous. The last parameter callback will be added as
a listener for the ‘listening’ event. See also net.Server.listen(path).

server.listen(handle[, callback])

• handle {Object}
• callback {Function}

The handle object can be set to either a server or socket (anything
with an underlying _handle member), or a {fd: <n>} object.

This will cause the server to accept connections on the specified
handle, but it is presumed that the file descriptor or handle has
already been bound to a port or domain socket.

Listening on a file descriptor is not supported on Windows.

This function is asynchronous. The last parameter callback will be added as
a listener for the ‘listening’ event.
See also net.Server.listen().

server.close([callback])

Stops the server from accepting new connections. See net.Server.close().

Limits maximum incoming headers count, equal to 1000 by default. If set to 0 —
no limit will be applied.

server.setTimeout(msecs, callback)

• msecs {Number}
• callback {Function}

Sets the timeout value for sockets, and emits a 'timeout' event on
the Server object, passing the socket as an argument, if a timeout
occurs.

If there is a 'timeout' event listener on the Server object, then it
will be called with the timed-out socket as an argument.

By default, the Server’s timeout value is 2 minutes, and sockets are
destroyed automatically if they time out. However, if you assign a
callback to the Server’s 'timeout' event, then you are responsible
for handling socket timeouts.

server.timeout

• {Number} Default = 120000 (2 minutes)

The number of milliseconds of inactivity before a socket is presumed
to have timed out.

Note that the socket timeout logic is set up on connection, so
changing this value only affects new connections to the server, not
any existing connections.

Set to 0 to disable any kind of automatic timeout behavior on incoming
connections.

Class: http.ServerResponse

This object is created internally by a HTTP server—not by the user. It is
passed as the second parameter to the 'request' event.

The response implements the Writable Stream interface. This is an
EventEmitter with the following events:

Event: ‘close’

function () { }

Indicates that the underlying connection was terminated before
response.end() was called or able to flush.

Event: ‘finish’

function () { }

Emitted when the response has been sent. More specifically, this event is
emitted when the last segment of the response headers and body have been
handed off to the operating system for transmission over the network. It
does not imply that the client has received anything yet.

After this event, no more events will be emitted on the response object.

response.writeContinue()

Sends a HTTP/1.1 100 Continue message to the client, indicating that
the request body should be sent. See the ‘checkContinue’ event on Server.

Sends a response header to the request. The status code is a 3-digit HTTP
status code, like 404. The last argument, headers, are the response headers.
Optionally one can give a human-readable statusMessage as the second
argument.

Example:

var body = 'hello world';
response.writeHead(200, {
  'Content-Length': body.length,
  'Content-Type': 'text/plain' });

This method must only be called once on a message and it must
be called before response.end() is called.

If you call response.write() or response.end() before calling this, the
implicit/mutable headers will be calculated and call this function for you.

Note that Content-Length is given in bytes not characters. The above example
works because the string 'hello world' contains only single byte characters.
If the body contains higher coded characters then Buffer.byteLength()
should be used to determine the number of bytes in a given encoding.
And Node does not check whether Content-Length and the length of the body
which has been transmitted are equal or not.

response.setTimeout(msecs, callback)

• msecs {Number}
• callback {Function}

Sets the Socket’s timeout value to msecs. If a callback is
provided, then it is added as a listener on the 'timeout' event on
the response object.

If no 'timeout' listener is added to the request, the response, or
the server, then sockets are destroyed when they time out. If you
assign a handler on the request, the response, or the server’s
'timeout' events, then it is your responsibility to handle timed out
sockets.

response.statusCode

When using implicit headers (not calling response.writeHead() explicitly),
this property controls the status code that will be sent to the client when
the headers get flushed.

Example:

response.statusCode = 404;

After response header was sent to the client, this property indicates the
status code which was sent out.

response.statusMessage

When using implicit headers (not calling response.writeHead() explicitly), this property
controls the status message that will be sent to the client when the headers get
flushed. If this is left as undefined then the standard message for the status
code will be used.

Example:

response.statusMessage = 'Not found';

After response header was sent to the client, this property indicates the
status message which was sent out.

Sets a single header value for implicit headers. If this header already exists
in the to-be-sent headers, its value will be replaced. Use an array of strings
here if you need to send multiple headers with the same name.

Example:

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

or

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

Boolean (read-only). True if headers were sent, false otherwise.

response.sendDate

When true, the Date header will be automatically generated and sent in
the response if it is not already present in the headers. Defaults to true.

This should only be disabled for testing; HTTP requires the Date header
in responses.

Reads out a header that’s already been queued but not sent to the client. Note
that the name is case insensitive. This can only be called before headers get
implicitly flushed.

Example:

var contentType = response.getHeader('content-type');

Removes a header that’s queued for implicit sending.

Example:

response.removeHeader("Content-Encoding");

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

If this method is called and response.writeHead() has not been called,
it will switch to implicit header mode and flush the implicit headers.

This sends a chunk of the response body. This method may
be called multiple times to provide successive parts of the body.

chunk can be a string or a buffer. If chunk is a string,
the second parameter specifies how to encode it into a byte stream.
By default the encoding is 'utf8'. The last parameter callback
will be called when this chunk of data is flushed.

Note: This is the raw HTTP body and has nothing to do with
higher-level multi-part body encodings that may be used.

The first time response.write() is called, it will send the buffered
header information and the first body to the client. The second time
response.write() is called, Node assumes you’re going to be streaming
data, and sends that separately. That is, the response is buffered up to the
first chunk of body.

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

This method adds HTTP trailing headers (a header but at the end of the
message) to the response.

Trailers will only be emitted if chunked encoding is used for the
response; if it is not (e.g., if the request was HTTP/1.0), they will
be silently discarded.

Note that HTTP requires the Trailer header to be sent if you intend to
emit trailers, with a list of the header fields in its value. E.g.,

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

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

This method signals to the server that all of the response headers and body
have been sent; that server should consider this message complete.
The method, response.end(), MUST be called on each
response.

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

If callback is specified, it will be called when the response stream
is finished.

http.request(options[, callback])

Node maintains several connections per server to make HTTP requests.
This function allows one to transparently issue requests.

options can be an object or a string. If options is a string, it is
automatically parsed with url.parse().

Options:

• host: A domain name or IP address of the server to issue the request to.
  Defaults to 'localhost'.
• hostname: To support url.parse() hostname is preferred over host
• port: Port of remote server. Defaults to 80.
• localAddress: Local interface to bind for network connections.
• socketPath: Unix Domain Socket (use one of host:port or socketPath)
• method: A string specifying the HTTP request method. Defaults to 'GET'.
• path: Request path. Defaults to '/'. Should include query string if any.
  E.G. '/index.html?page=12'. An exception is thrown when the request path
  contains illegal characters. Currently, only spaces are rejected but that
  may change in the future.
• headers: An object containing request headers.
• auth: Basic authentication i.e. 'user:password' to compute an
  Authorization header.
• agent: Controls Agent behavior. When an Agent is used request will
  default to Connection: keep-alive. Possible values:
• undefined (default): use global Agent for this host and port.
• Agent object: explicitly use the passed in Agent.
• false: opts out of connection pooling with an Agent, defaults request to
  Connection: close.
• keepAlive: {Boolean} Keep sockets around in a pool to be used
  by other requests in the future. Default = false
• keepAliveMsecs: {Integer} When using HTTP KeepAlive, how often to
  send TCP KeepAlive packets over sockets being kept alive. Default =
  1000. Only relevant if keepAlive is set to true.

The optional callback parameter will be added as a one time listener for
the ‘response’ event.

http.request() returns an instance of the http.ClientRequest
class. The ClientRequest instance is a writable stream. If one needs to
upload a file with a POST request, then write to the ClientRequest object.

Example:

var postData = querystring.stringify({
  'msg' : 'Hello World!'
});

var options = {
  hostname: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': postData.length
  }
};

var req = http.request(options, function(res) {
  console.log('STATUS: ' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));
  res.setEncoding('utf8');
  res.on('data', function (chunk) {
    console.log('BODY: ' + chunk);
  });
});

req.on('error', function(e) {
  console.log('problem with request: ' + e.message);
});

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

Note that in the example req.end() was called. With http.request() one
must always call req.end() to signify that you’re done with the request —
even if there is no data being written to the request body.

If any error is encountered during the request (be that with DNS resolution,
TCP level errors, or actual HTTP parse errors) an 'error' event is emitted
on the returned request object.

There are a few special headers that should be noted.

• Sending a ‘Connection: keep-alive’ will notify Node that the connection to
  the server should be persisted until the next request.

• Sending a ‘Content-length’ header will disable the default chunked encoding.

• Sending an ‘Expect’ header will immediately send the request headers.
  Usually, when sending ‘Expect: 100-continue’, you should both set a timeout
  and listen for the continue event. See RFC2616 Section 8.2.3 for more
  information.

• Sending an Authorization header will override using the auth option
  to compute basic authentication.

http.get(options[, callback])

Since most requests are GET requests without bodies, Node provides this
convenience method. The only difference between this method and http.request()
is that it sets the method to GET and calls req.end() automatically.

Example:

http.get("http://www.google.com/index.html", function(res) {
  console.log("Got response: " + res.statusCode);
}).on('error', function(e) {
  console.log("Got error: " + e.message);
});

Class: http.Agent

The HTTP Agent is used for pooling sockets used in HTTP client
requests.

The HTTP Agent also defaults client requests to using
Connection:keep-alive. If no pending HTTP requests are waiting on a
socket to become free the socket is closed. This means that Node’s
pool has the benefit of keep-alive when under load but still does not
require developers to manually close the HTTP clients using
KeepAlive.

If you opt into using HTTP KeepAlive, you can create an Agent object
with that flag set to true. (See the constructor
options below.) Then, the Agent will keep
unused sockets in a pool for later use. They will be explicitly
marked so as to not keep the Node process running. However, it is
still a good idea to explicitly destroy()
KeepAlive agents when they are no longer in use, so that the Sockets
will be shut down.

Sockets are removed from the agent’s pool when the socket emits either
a «close» event or a special «agentRemove» event. This means that if
you intend to keep one HTTP request open for a long time and don’t
want it to stay in the pool you can do something along the lines of:

http.get(options, function(res) {
  // Do stuff
}).on("socket", function (socket) {
  socket.emit("agentRemove");
});

Alternatively, you could just opt out of pooling entirely using
agent:false:

http.get({
  hostname: 'localhost',
  port: 80,
  path: '/',
  agent: false  // create a new agent just for this one request
}, function (res) {
  // Do stuff with response
})

new Agent([options])

• options {Object} Set of configurable options to set on the agent.
  Can have the following fields:
• keepAlive {Boolean} Keep sockets around in a pool to be used by
  other requests in the future. Default = false
• keepAliveMsecs {Integer} When using HTTP KeepAlive, how often
  to send TCP KeepAlive packets over sockets being kept alive.
  Default = 1000. Only relevant if keepAlive is set to true.
• maxSockets {Number} Maximum number of sockets to allow per
  host. Default = Infinity.
• maxFreeSockets {Number} Maximum number of sockets to leave open
  in a free state. Only relevant if keepAlive is set to true.
  Default = 256.

The default http.globalAgent that is used by http.request has all
of these values set to their respective defaults.

To configure any of them, you must create your own Agent object.

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

agent.maxSockets

By default set to Infinity. Determines how many concurrent sockets the agent
can have open per origin. Origin is either a ‘host:port’ or
‘host:port:localAddress’ combination.

agent.maxFreeSockets

By default set to 256. For Agents supporting HTTP KeepAlive, this
sets the maximum number of sockets that will be left open in the free
state.

agent.sockets

An object which contains arrays of sockets currently in use by the
Agent. Do not modify.

agent.freeSockets

An object which contains arrays of sockets currently awaiting use by
the Agent when HTTP KeepAlive is used. Do not modify.

agent.requests

An object which contains queues of requests that have not yet been assigned to
sockets. Do not modify.

agent.destroy()

Destroy any sockets that are currently in use by the agent.

It is usually not necessary to do this. However, if you are using an
agent with KeepAlive enabled, then it is best to explicitly shut down
the agent when you know that it will no longer be used. Otherwise,
sockets may hang open for quite a long time before the server
terminates them.

agent.getName(options)

Get a unique name for a set of request options, to determine whether a
connection can be reused. In the http agent, this returns
host:port:localAddress. In the https agent, the name includes the
CA, cert, ciphers, and other HTTPS/TLS-specific options that determine
socket reusability.

http.globalAgent

Global instance of Agent which is used as the default for all http client
requests.

Class: http.ClientRequest

This object is created internally and returned from http.request(). It
represents an in-progress request whose header has already been queued. The
header is still mutable using the setHeader(name, value), getHeader(name),
removeHeader(name) API. The actual header will be sent along with the first
data chunk or when closing the connection.

To get the response, add a listener for 'response' to the request object.
'response' will be emitted from the request object when the response
headers have been received. The 'response' event is executed with one
argument which is an instance of http.IncomingMessage.

During the 'response' event, one can add listeners to the
response object; particularly to listen for the 'data' event.

If no 'response' handler is added, then the response will be
entirely discarded. However, if you add a 'response' event handler,
then you must consume the data from the response object, either by
calling response.read() whenever there is a 'readable' event, or
by adding a 'data' handler, or by calling the .resume() method.
Until the data is consumed, the 'end' event will not fire. Also, until
the data is read it will consume memory that can eventually lead to a
‘process out of memory’ error.

Note: Node does not check whether Content-Length and the length of the body
which has been transmitted are equal or not.

The request implements the Writable Stream interface. This is an
EventEmitter with the following events:

Event: ‘response’

function (response) { }

Emitted when a response is received to this request. This event is emitted only
once. The response argument will be an instance of http.IncomingMessage.

Options:

• host: A domain name or IP address of the server to issue the request to.
• port: Port of remote server.
• socketPath: Unix Domain Socket (use one of host:port or socketPath)

Event: ‘socket’

function (socket) { }

Emitted after a socket is assigned to this request.

Event: ‘connect’

function (response, socket, head) { }

Emitted each time a server responds to a request with a CONNECT method. If this
event isn’t being listened for, clients receiving a CONNECT method will have
their connections closed.

A client server pair that show you how to listen for the connect event.

var http = require('http');
var net = require('net');
var url = require('url');

// Create an HTTP tunneling proxy
var proxy = http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('okay');
});
proxy.on('connect', function(req, cltSocket, head) {
  // connect to an origin server
  var srvUrl = url.parse('http://' + req.url);
  var srvSocket = net.connect(srvUrl.port, srvUrl.hostname, function() {
    cltSocket.write('HTTP/1.1 200 Connection Establishedrn' +
                    'Proxy-agent: Node-Proxyrn' +
                    'rn');
    srvSocket.write(head);
    srvSocket.pipe(cltSocket);
    cltSocket.pipe(srvSocket);
  });
});

// now that proxy is running
proxy.listen(1337, '127.0.0.1', function() {

  // make a request to a tunneling proxy
  var options = {
    port: 1337,
    hostname: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80'
  };

  var req = http.request(options);
  req.end();

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

    // make a request over an HTTP tunnel
    socket.write('GET / HTTP/1.1rn' +
                 'Host: www.google.com:80rn' +
                 'Connection: closern' +
                 'rn');
    socket.on('data', function(chunk) {
      console.log(chunk.toString());
    });
    socket.on('end', function() {
      proxy.close();
    });
  });
});

Event: ‘upgrade’

function (response, socket, head) { }

Emitted each time a server responds to a request with an upgrade. If this
event isn’t being listened for, clients receiving an upgrade header will have
their connections closed.

A client server pair that show you how to listen for the upgrade event.

var http = require('http');

// Create an HTTP server
var srv = http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('okay');
});
srv.on('upgrade', function(req, socket, head) {
  socket.write('HTTP/1.1 101 Web Socket Protocol Handshakern' +
               'Upgrade: WebSocketrn' +
               'Connection: Upgradern' +
               'rn');

  socket.pipe(socket); // echo back
});

// now that server is running
srv.listen(1337, '127.0.0.1', function() {

  // make a request
  var options = {
    port: 1337,
    hostname: '127.0.0.1',
    headers: {
      'Connection': 'Upgrade',
      'Upgrade': 'websocket'
    }
  };

  var req = http.request(options);
  req.end();

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

Event: ‘continue’

function () { }

Emitted when the server sends a ‘100 Continue’ HTTP response, usually because
the request contained ‘Expect: 100-continue’. This is an instruction that
the client should send the request body.

Flush the request headers.

For efficiency reasons, node.js normally buffers the request headers until you
call request.end() or write the first chunk of request data. It then tries
hard to pack the request headers and data into a single TCP packet.

That’s usually what you want (it saves a TCP round-trip) but not when the first
data isn’t sent until possibly much later. request.flush() lets you bypass
the optimization and kickstart the request.

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

Sends a chunk of the body. By calling this method
many times, the user can stream a request body to a
server—in that case it is suggested to use the
['Transfer-Encoding', 'chunked'] header line when
creating the request.

The chunk argument should be a Buffer or a string.

The encoding argument is optional and only applies when chunk is a string.
Defaults to 'utf8'.

The callback argument is optional and will be called when this chunk of data
is flushed.

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

Finishes sending the request. If any parts of the body are
unsent, it will flush them to the stream. If the request is
chunked, this will send the terminating '0rnrn'.

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

If callback is specified, it will be called when the request stream
is finished.

request.abort()

Aborts a request. (New since v0.3.8.)

request.setTimeout(timeout[, callback])

Once a socket is assigned to this request and is connected
socket.setTimeout() will be called.

request.setNoDelay([noDelay])

Once a socket is assigned to this request and is connected
socket.setNoDelay() will be called.

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

Once a socket is assigned to this request and is connected
socket.setKeepAlive() will be called.

http.IncomingMessage

An IncomingMessage object is created by http.Server or
http.ClientRequest and passed as the first argument to the 'request'
and 'response' event respectively. It may be used to access response status,
headers and data.

It implements the Readable Stream interface, as well as the
following additional events, methods, and properties.

Event: ‘close’

function () { }

Indicates that the underlying connection was closed.
Just like 'end', this event occurs only once per response.

message.httpVersion

In case of server request, the HTTP version sent by the client. In the case of
client response, the HTTP version of the connected-to server.
Probably either '1.1' or '1.0'.

Also response.httpVersionMajor is the first integer and
response.httpVersionMinor is the second.

The request/response headers object.

Read only map of header names and values. Header names are lower-cased.
Example:

// Prints something like:
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers);

The raw request/response headers list exactly as they were received.

Note that the keys and values are in the same list. It is not a
list of tuples. So, the even-numbered offsets are key values, and the
odd-numbered offsets are the associated values.

Header names are not lowercased, and duplicates are not merged.

// Prints something like:
//
// [ '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.trailers

The request/response trailers object. Only populated at the ‘end’ event.

message.rawTrailers

The raw request/response trailer keys and values exactly as they were
received. Only populated at the ‘end’ event.

message.setTimeout(msecs, callback)

• msecs {Number}
• callback {Function}

Calls message.connection.setTimeout(msecs, callback).

message.method

Only valid for request obtained from http.Server.

The request method as a string. Read only. Example:
'GET', 'DELETE'.

message.url

Only valid for request obtained from http.Server.

Request URL string. This contains only the URL that is
present in the actual HTTP request. If the request is:

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

Then request.url will be:

'/status?name=ryan'

If you would like to parse the URL into its parts, you can use
require('url').parse(request.url). Example:

node> require('url').parse('/status?name=ryan')
{ href: '/status?name=ryan',
  search: '?name=ryan',
  query: 'name=ryan',
  pathname: '/status' }

If you would like to extract the params from the query string,
you can use the require('querystring').parse function, or pass
true as the second argument to require('url').parse. Example:

node> require('url').parse('/status?name=ryan', true)
{ href: '/status?name=ryan',
  search: '?name=ryan',
  query: { name: 'ryan' },
  pathname: '/status' }

message.statusCode

Only valid for response obtained from http.ClientRequest.

The 3-digit HTTP response status code. E.G. 404.

message.statusMessage

Only valid for response obtained from http.ClientRequest.

The HTTP response status message (reason phrase). E.G. OK or Internal Server Error.

message.socket

The net.Socket object associated with the connection.

With HTTPS support, use request.connection.verifyPeer() and
request.connection.getPeerCertificate() to obtain the client’s
authentication details.

Стабильность: 2 — стабильная

Для использования HTTP-сервера и клиента необходимо: require('http').

Интерфейсы HTTP в Node.js предназначены для поддержки многих функций протокола, которые традиционно было трудно использовать. В частности, большие сообщения, возможно, закодированные по частям. Интерфейс старается никогда не буферизовать целые запросы или ответы, поэтому пользователь может передавать данные в потоке.

Заголовки HTTP-сообщений представлены таким объектом:

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

Ключи в нижнем регистре. Значения не изменяются.

Чтобы поддерживать полный спектр возможных HTTP-приложений, HTTP-интерфейс Node.js является очень низкоуровневым. Он занимается только обработкой потоков и анализом сообщений. Он разбирает сообщение на заголовки и тело, но не анализирует фактические заголовки или тело.

Видеть message.headers для получения подробной информации о том, как обрабатываются повторяющиеся заголовки.

Необработанные заголовки в том виде, в котором они были получены, сохраняются в rawHeaders свойство, которое представляет собой массив [key, value, key2, value2, ...]. Например, объект заголовка предыдущего сообщения может иметь rawHeaders список, подобный следующему:

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

Класс: http.Agent¶

An Agent отвечает за управление сохранением и повторным использованием соединения для клиентов HTTP. Он поддерживает очередь ожидающих запросов для данного хоста и порта, повторно используя одно соединение сокета для каждого, пока очередь не станет пустой, и в это время сокет либо уничтожается, либо помещается в пул, где он сохраняется для повторного использования для запросов. к тому же хосту и порту. Будет ли он уничтожен или объединен, зависит от keepAlive вариант.

Для объединенных в пул соединений включена поддержка TCP Keep-Alive, но серверы могут по-прежнему закрывать неактивные соединения, и в этом случае они будут удалены из пула, и будет создано новое соединение, когда будет сделан новый HTTP-запрос для этого хоста и порта. Серверы также могут отказать в разрешении нескольких запросов по одному и тому же соединению, и в этом случае соединение должно быть переделано для каждого запроса и не может быть объединено в пул. В Agent будет по-прежнему делать запросы к этому серверу, но каждый из них будет выполняться через новое соединение.

Когда соединение закрывается клиентом или сервером, оно удаляется из пула. Любые неиспользуемые сокеты в пуле не будут обновлены, чтобы не продолжать работу процесса Node.js, когда нет ожидающих запросов. (видеть socket.unref()).

Хорошая практика — destroy() ан Agent Например, когда он больше не используется, потому что неиспользуемые сокеты потребляют ресурсы ОС.

Сокеты удаляются из агента, когда сокет излучает либо 'close' событие или 'agentRemove' событие. Если вы собираетесь держать один HTTP-запрос открытым в течение длительного времени, не сохраняя его в агенте, можно сделать что-то вроде следующего:

http
  .get(options, (res) => {
    // Do stuff
  })
  .on('socket', (socket) => {
    socket.emit('agentRemove');
  });

Агент также может быть использован для индивидуального запроса. Предоставляя {agent: false} как вариант для http.get() или http.request() функции, разовое использование Agent с параметрами по умолчанию будет использоваться для подключения клиента.

agent:false:

http.get(
  {
    hostname: 'localhost',
    port: 80,
    path: '/',
    agent: false, // Create a new agent just for this one request
  },
  (res) => {
    // Do stuff with response
  }
);

new Agent([options])¶

• options {Object} Набор настраиваемых параметров для настройки агента. Может иметь следующие поля:
• keepAlive {boolean} Сохраняйте сокеты, даже если нет ожидающих запросов, чтобы их можно было использовать для будущих запросов без необходимости повторно устанавливать TCP-соединение. Не путать с keep-alive ценность Connection заголовок. В Connection: keep-alive заголовок всегда отправляется при использовании агента, кроме случаев, когда Connection заголовок указан явно или когда keepAlive а также maxSockets параметры соответственно установлены на false а также Infinity, в таком случае Connection: close будет использоваться. Дефолт: false.
• keepAliveMsecs {number} При использовании keepAlive опция, определяет начальная задержка для пакетов TCP Keep-Alive. Игнорируется, когда keepAlive вариант false или undefined. Дефолт: 1000.
• maxSockets {number} Максимальное количество сокетов для каждого хоста. Если один и тот же хост открывает несколько одновременных подключений, каждый запрос будет использовать новый сокет до тех пор, пока maxSockets значение достигнуто. Если хост пытается открыть больше соединений, чем maxSockets, дополнительные запросы будут помещены в очередь ожидающих запросов и войдут в активное состояние соединения, когда существующее соединение завершится. Это гарантирует, что есть не более maxSockets активные соединения в любой момент времени с заданного хоста. Дефолт: Infinity.
• maxTotalSockets {число} Максимальное количество сокетов, разрешенное для всех хостов в сумме. Каждый запрос будет использовать новый сокет, пока не будет достигнут максимум. Дефолт: Infinity.
• maxFreeSockets {number} Максимальное количество сокетов, которые можно оставить открытыми в свободном состоянии. Уместно, только если keepAlive установлен на true. Дефолт: 256.
• scheduling {string} Стратегия планирования, применяемая при выборе следующего свободного сокета для использования. Может быть 'fifo' или 'lifo'. Основное различие между двумя стратегиями планирования заключается в том, что 'lifo' выбирает последний использованный сокет, а 'fifo' выбирает сокет, который использовался меньше всего. В случае низкой скорости запросов в секунду 'lifo' планирование снизит риск выбора сокета, который мог быть закрыт сервером из-за бездействия. В случае высокой скорости запросов в секунду 'fifo' планирование максимизирует количество открытых сокетов, в то время как 'lifo' планирование будет держать его на минимальном уровне. Дефолт: 'lifo'.
• timeout {number} Тайм-аут сокета в миллисекундах. Это установит тайм-аут при создании сокета.

options в socket.connect() также поддерживаются.

По умолчанию http.globalAgent что используется http.request() для всех этих значений установлены соответствующие значения по умолчанию.

Чтобы настроить любой из них, пользовательский http.Agent экземпляр должен быть создан.

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

agent.createConnection(options[, callback])¶

• options {Object} Параметры, содержащие сведения о подключении. Проверять net.createConnection() для формата опций
• callback {Function} Функция обратного вызова, которая получает созданный сокет
• Возвращает: {stream.Duplex}

Создает сокет / поток, который будет использоваться для HTTP-запросов.

По умолчанию эта функция такая же, как и net.createConnection(). Однако специальные агенты могут переопределить этот метод, если требуется большая гибкость.

Сокет / поток может быть предоставлен одним из двух способов: путем возврата сокета / потока из этой функции или путем передачи сокета / потока в callback.

Этот метод гарантированно возвращает экземпляр класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не указывает тип сокета, отличный от {net.Socket}.

callback имеет подпись (err, stream).

agent.keepSocketAlive(socket)¶

• socket {stream.Duplex}

Вызывается, когда socket отделяется от запроса и может сохраняться Agent. По умолчанию:

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

Этот метод может быть отменен конкретным Agent подкласс. Если этот метод возвращает ложное значение, сокет будет уничтожен, а не сохранен для использования со следующим запросом.

В socket аргумент может быть экземпляром {net.Socket}, подклассом {stream.Duplex}.

agent.reuseSocket(socket, request)¶

• socket {stream.Duplex}
• request {http.ClientRequest}

Вызывается, когда socket прикреплен к request после сохранения из-за опций сохранения активности. По умолчанию:

Этот метод может быть отменен конкретным Agent подкласс.

В socket аргумент может быть экземпляром {net.Socket}, подклассом {stream.Duplex}.

agent.destroy()¶

Уничтожьте все сокеты, которые в настоящее время используются агентом.

Обычно в этом нет необходимости. Однако при использовании агента с keepAlive включен, то лучше явно закрыть агент, когда он больше не нужен. В противном случае сокеты могут оставаться открытыми довольно долгое время, прежде чем сервер их отключит.

agent.freeSockets¶

• {Объект}

Объект, содержащий массивы сокетов, ожидающих в настоящее время использования агентом, когда keepAlive включен. Не модифицируйте.

Розетки в freeSockets список будет автоматически уничтожен и удален из массива на 'timeout'.

agent.getName(options)¶

• options {Object} Набор параметров, предоставляющих информацию для генерации имени
• host {строка} Доменное имя или IP-адрес сервера, на который будет отправлен запрос
• port {number} Порт удаленного сервера
• localAddress {строка} Локальный интерфейс для привязки сетевых подключений при выдаче запроса
• family {integer} Должно быть 4 или 6, если это не равно undefined.
• Возвращает: {строка}

Получите уникальное имя для набора параметров запроса, чтобы определить, можно ли повторно использовать соединение. Для агента HTTP это возвращает host:port:localAddress или host:port:localAddress:family. Для агента HTTPS имя включает CA, сертификат, шифры и другие параметры, специфичные для HTTPS / TLS, которые определяют возможность повторного использования сокета.

agent.maxFreeSockets¶

• {количество}

По умолчанию установлено значение 256. Для агентов с keepAlive enabled, это устанавливает максимальное количество сокетов, которые будут оставлены открытыми в свободном состоянии.

agent.maxSockets¶

• {количество}

По умолчанию установлено на Infinity. Определяет, сколько одновременных сокетов может быть открыто агентом для каждого источника. Происхождение — это возвращаемое значение agent.getName().

agent.maxTotalSockets¶

• {количество}

По умолчанию установлено на Infinity. Определяет, сколько одновременных сокетов может быть открыто агентом. В отличие от maxSockets, этот параметр применяется ко всем источникам.

agent.requests¶

• {Объект}

Объект, содержащий очереди запросов, которые еще не назначены сокетам. Не модифицируйте.

agent.sockets¶

• {Объект}

Объект, который содержит массивы сокетов, которые в настоящее время используются агентом. Не модифицируйте.

Класс: http.ClientRequest¶

• Расширяется: {Stream}

Этот объект создается внутри и возвращается из http.request(). Он представляет собой в ходе выполнения запрос, заголовок которого уже поставлен в очередь. Заголовок все еще изменяем с помощью setHeader(name, value), getHeader(name), removeHeader(name) API. Фактический заголовок будет отправлен вместе с первым блоком данных или при вызове request.end().

Чтобы получить ответ, добавьте слушателя для 'response' к объекту запроса. 'response' будет испущен из объекта запроса, когда будут получены заголовки ответа. В 'response' событие выполняется с одним аргументом, который является экземпляром http.IncomingMessage.

В течение 'response' событие, можно добавить слушателей к объекту ответа; особенно слушать 'data' событие.

Если нет 'response' обработчик добавлен, то ответ будет полностью отброшен. Однако если 'response' добавляется обработчик событий, затем данные из объекта ответа должен быть потребленным, либо позвонив response.read() всякий раз, когда есть 'readable' событие, или добавив 'data' обработчик, или вызвав .resume() метод. Пока данные не будут использованы, 'end' событие не сработает. Кроме того, до тех пор, пока данные не будут считаны, они будут занимать память, что в конечном итоге может привести к ошибке «процесса не хватает памяти».

Для обратной совместимости res будет только излучать 'error' если есть 'error' слушатель зарегистрировался.

Node.js не проверяет, равны ли Content-Length и длина переданного тела.

Событие: 'abort'¶

Стабильность: 0 — Не рекомендуется. Слушайте 'close' событие вместо этого.

Выдается, когда запрос был прерван клиентом. Это событие генерируется только при первом вызове abort().

Событие: 'connect'¶

• response {http.IncomingMessage}
• socket {stream.Duplex}
• head {Буфер}

Излучается каждый раз, когда сервер отвечает на запрос с помощью CONNECT метод. Если это событие не прослушивается, клиенты, получающие CONNECT будут закрыты их соединения.

Это событие гарантированно будет передано экземпляру класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не укажет тип сокета, отличный от {net.Socket}.

Пара клиент и сервер, демонстрирующая, как прослушивать 'connect' событие:

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

// Create an HTTP tunneling proxy
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
proxy.on('connect', (req, clientSocket, head) => {
  // Connect to an origin server
  const { port, hostname } = new URL(`http://${req.url}`);
  const serverSocket = net.connect(
    port || 80,
    hostname,
    () => {
      clientSocket.write(
        'HTTP/1.1 200 Connection Establishedrn' +
          'Proxy-agent: Node.js-Proxyrn' +
          'rn'
      );
      serverSocket.write(head);
      serverSocket.pipe(clientSocket);
      clientSocket.pipe(serverSocket);
    }
  );
});

// Now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {
  // Make a request to a tunneling proxy
  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!');

    // Make a request over an HTTP tunnel
    socket.write(
      'GET / HTTP/1.1rn' +
        'Host: www.google.com:80rn' +
        'Connection: closern' +
        'rn'
    );
    socket.on('data', (chunk) => {
      console.log(chunk.toString());
    });
    socket.on('end', () => {
      proxy.close();
    });
  });
});

Событие: 'continue'¶

Генерируется, когда сервер отправляет HTTP-ответ «100 Continue», обычно потому, что запрос содержит «Expect: 100-continue». Это инструкция о том, что клиент должен отправить тело запроса.

Событие: 'information'¶

• info {Объект}
• httpVersion {нить}
• httpVersionMajor {целое число}
• httpVersionMinor {целое число}
• statusCode {целое число}
• statusMessage {нить}
• headers {Объект}
• rawHeaders {нить[]}

Выдается, когда сервер отправляет промежуточный ответ 1xx (за исключением 101 Upgrade). Слушатели этого события получат объект, содержащий версию HTTP, код состояния, сообщение о состоянии, объект заголовков значений ключа и массив с именами необработанных заголовков, за которыми следуют их соответствующие значения.

const http = require('http');

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

// Make a request
const req = http.request(options);
req.end();

req.on('information', (info) => {
  console.log(
    `Got information prior to main response: ${info.statusCode}`
  );
});

101 Статусы обновления не вызывают это событие из-за их разрыва с традиционной цепочкой HTTP-запросов / ответов, такой как веб-сокеты, обновления TLS на месте или HTTP 2.0. Чтобы получать уведомления об обновлении 101, прислушайтесь к 'upgrade' событие вместо этого.

Событие: 'response'¶

• response {http.IncomingMessage}

Выдается при получении ответа на этот запрос. Это событие генерируется только один раз.

Событие: 'socket'¶

• socket {stream.Duplex}

Это событие гарантированно будет передано экземпляру класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не укажет тип сокета, отличный от {net.Socket}.

Событие: 'timeout'¶

Генерируется, когда базовый сокет выходит из строя по тайм-ауту. Это только уведомляет о том, что сокет бездействует. Запрос необходимо уничтожить вручную.

Смотрите также: request.setTimeout().

Событие: 'upgrade'¶

• response {http.IncomingMessage}
• socket {stream.Duplex}
• head {Буфер}

Излучается каждый раз, когда сервер отвечает на запрос об обновлении. Если это событие не прослушивается, а код состояния ответа — 101 Switching Protocols, клиенты, получающие заголовок обновления, будут закрывать свои соединения.

Это событие гарантированно будет передано экземпляру класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не укажет тип сокета, отличный от {net.Socket}.

Пара клиент-сервер, демонстрирующая, как прослушивать 'upgrade' событие.

const http = require('http');

// Create an HTTP server
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 Handshakern' +
      'Upgrade: WebSocketrn' +
      'Connection: Upgradern' +
      'rn'
  );

  socket.pipe(socket); // echo back
});

// Now that server is running
server.listen(1337, '127.0.0.1', () => {
  // make a request
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      Connection: 'Upgrade',
      Upgrade: 'websocket',
    },
  };

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

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

request.abort()¶

Стабильность: 0 — Не рекомендуется: использовать request.destroy() вместо.

Отмечает запрос как прерывающийся. Вызов этого приведет к удалению оставшихся данных в ответе и уничтожению сокета.

request.aborted¶

Стабильность: 0 — Не рекомендуется. Проверять request.destroyed вместо.

• {логический}

В request.aborted собственность будет true если запрос был прерван.

request.connection¶

Стабильность: 0 — Не рекомендуется. Использовать request.socket.

• {stream.Duplex}

Видеть request.socket.

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

• data {строка | буфер}
• encoding {нить}
• callback {Функция}
• Возвращает: {this}

Завершает отправку запроса. Если какие-либо части тела не отправлены, он смывает их в поток. Если запрос разбит на части, будет отправлен завершающий '0rnrn'.

Если data указано, это эквивалентно вызову request.write(data, encoding) с последующим request.end(callback).

Если callback указан, он будет вызываться по завершении потока запроса.

request.destroy([error])¶

• error {Error} Необязательно, сообщение об ошибке 'error' событие.
• Возвращает: {this}

Уничтожьте запрос. При желании испустить 'error' событие и испустить 'close' событие. Вызов этого приведет к удалению оставшихся данных в ответе и уничтожению сокета.

Видеть writable.destroy() для получения дополнительной информации.

request.destroyed¶

• {логический}

Является true после request.destroy() был вызван.

Видеть writable.destroyed для получения дополнительной информации.

request.finished¶

Стабильность: 0 — Не рекомендуется. Использовать request.writableEnded.

• {логический}

В request.finished собственность будет true если request.end() был вызван. request.end() будет автоматически вызываться, если запрос был инициирован через http.get().

Очищает заголовки запроса.

Из соображений эффективности Node.js обычно буферизует заголовки запроса до тех пор, пока request.end() вызывается или записывается первый фрагмент данных запроса. Затем он пытается упаковать заголовки запроса и данные в один TCP-пакет.

Обычно это желательно (это экономит TCP-обход), но не тогда, когда первые данные не отправляются, возможно, намного позже. request.flushHeaders() обходит оптимизацию и запускает запрос.

• name {нить}
• Возврат: {любой}

Считывает заголовок запроса. Имя не чувствительно к регистру. Тип возвращаемого значения зависит от аргументов, предоставленных для 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' is 'text/html'
const contentLength = request.getHeader('Content-Length');
// 'contentLength' is of type number
const cookie = request.getHeader('Cookie');
// 'cookie' is of type string[]

• Возвращает: {строка []}

Возвращает массив, содержащий уникальные имена текущих исходящих необработанных заголовков. Имена заголовков возвращаются с установленным их точным регистром.

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

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

• {количество} Дефолт: 2000

Ограничивает максимальное количество заголовков ответа. Если установлено значение 0, ограничение не применяется.

request.path¶

• {строка} Путь запроса.

request.method¶

• {строка} Метод запроса.

request.host¶

• {строка} Хост запроса.

request.protocol¶

• {строка} Протокол запроса.

• name {нить}

Удаляет заголовок, который уже определен в объекте заголовков.

request.removeHeader('Content-Type');

request.reusedSocket¶

• {boolean} Отправляется ли запрос через повторно используемый сокет.

При отправке запроса через агент с активным поддержанием активности базовый сокет может быть повторно использован. Но если сервер закрывает соединение в неподходящий момент, клиент может столкнуться с ошибкой «ECONNRESET».

const http = require('http');

// Server has a 5 seconds keep-alive timeout by default
http
  .createServer((req, res) => {
    res.write('hellon');
    res.end();
  })
  .listen(3000);

setInterval(() => {
  // Adapting a keep-alive agent
  http.get('http://localhost:3000', { agent }, (res) => {
    res.on('data', (data) => {
      // Do nothing
    });
  });
}, 5000); // Sending request on 5s interval so it's easy to hit idle timeout

Пометив запрос, независимо от того, использовался ли он повторно или нет, мы можем выполнить на нем автоматическую повторную попытку ошибки.

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

function retriableRequest() {
  const req = http
    .get('http://localhost:3000', { agent }, (res) => {
      // ...
    })
    .on('error', (err) => {
      // Check if retry is needed
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest();
      }
    });
}

retriableRequest();

• name {нить}
• value {любой}

Устанавливает одно значение заголовка для объекта заголовков. Если этот заголовок уже существует в заголовках для отправки, его значение будет заменено. Используйте здесь массив строк, чтобы отправить несколько заголовков с одним и тем же именем. Нестроковые значения будут сохранены без изменений. Следовательно, request.getHeader() может возвращать нестроковые значения. Однако нестроковые значения будут преобразованы в строки для передачи по сети.

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

или

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

request.setNoDelay([noDelay])¶

• noDelay {логический}

Как только сокет назначен этому запросу и подключен socket.setNoDelay() будет называться.

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

• enable {логический}
• initialDelay {количество}

Как только сокет назначен этому запросу и подключен socket.setKeepAlive() будет называться.

request.setTimeout(timeout[, callback])¶

• timeout {number} Миллисекунды до истечения времени ожидания запроса.
• callback {Функция} Необязательная функция, вызываемая при истечении времени ожидания. То же, что и привязка к 'timeout' событие.
• Возвращает: {http.ClientRequest}

Как только сокет назначен этому запросу и подключен socket.setTimeout() будет называться.

request.socket¶

• {stream.Duplex}

Ссылка на базовый сокет. Обычно пользователи не хотят получать доступ к этому свойству. В частности, сокет не будет излучать 'readable' события из-за того, как парсер протокола подключается к сокету.

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

Это свойство гарантированно является экземпляром класса {net.Socket}, подкласса {stream.Duplex}, если только пользователь не указал тип сокета, отличный от {net.Socket}.

request.writableEnded¶

• {логический}

Является true после request.end() был вызван. Это свойство не указывает, были ли данные сброшены, для этого использования. request.writableFinished вместо.

request.writableFinished¶

• {логический}

Является true если все данные были сброшены в базовую систему, непосредственно перед 'finish' событие испускается.

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

• chunk {строка | буфер}
• encoding {нить}
• callback {Функция}
• Возвращает: {логическое}

Отправляет кусок тела. Этот метод можно вызывать несколько раз. Если нет Content-Length установлен, данные будут автоматически закодированы в кодировке передачи HTTP Chunked, чтобы сервер знал, когда данные заканчиваются. В Transfer-Encoding: chunked заголовок добавлен. Вызов request.end() необходимо для завершения отправки запроса.

В encoding аргумент является необязательным и применяется только тогда, когда chunk это строка. По умолчанию 'utf8'.

В callback Аргумент является необязательным и будет вызываться, когда этот фрагмент данных будет сброшен, но только если этот фрагмент не пуст.

Возврат true если все данные были успешно сброшены в буфер ядра. Возврат false если все или часть данных были помещены в очередь в пользовательской памяти. 'drain' будет выдан, когда буфер снова освободится.

Когда write функция вызывается с пустой строкой или буфером, она ничего не делает и ожидает ввода дополнительных данных.

Класс: http.Server¶

• Расширяется: {net.Server}

Событие: 'checkContinue'¶

• request {http.IncomingMessage}
• response {http.ServerResponse}

Выдается каждый раз, когда запрос с HTTP Expect: 100-continue получен. Если это событие не прослушивается, сервер автоматически ответит 100 Continue по мере необходимости.

Обработка этого события включает вызов response.writeContinue() если клиент должен продолжать отправлять тело запроса, или генерировать соответствующий HTTP-ответ (например, 400 Bad Request), если клиент не должен продолжать отправлять тело запроса.

Когда это событие генерируется и обрабатывается, 'request' событие не будет отправлено.

Событие: 'checkExpectation'¶

• request {http.IncomingMessage}
• response {http.ServerResponse}

Выдается каждый раз, когда запрос с HTTP Expect заголовок получен, где значение не 100-continue. Если это событие не прослушивается, сервер автоматически ответит 417 Expectation Failed по мере необходимости.

Когда это событие генерируется и обрабатывается, 'request' событие не будет отправлено.

Событие: 'clientError'¶

• exception {Ошибка}
• socket {stream.Duplex}

Если клиентское соединение выдает 'error' событие будет перенаправлено сюда. Слушатель этого события отвечает за закрытие / уничтожение базового сокета. Например, кто-то может захотеть более аккуратно закрыть сокет с помощью настраиваемого HTTP-ответа, вместо того, чтобы резко разорвать соединение.

Это событие гарантированно будет передано экземпляру класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не укажет тип сокета, отличный от {net.Socket}.

Поведение по умолчанию — попытаться закрыть сокет с помощью HTTP «400 Bad Request» или HTTP «431 Request Header Fields Too Large» в случае HPE_HEADER_OVERFLOW ошибка. Если сокет недоступен для записи или уже записал данные, он немедленно уничтожается.

socket это net.Socket объект, из-за которого возникла ошибка.

const http = require('http');

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

Когда 'clientError' событие происходит, нет request или response объект, поэтому любой отправленный HTTP-ответ, включая заголовки и полезную нагрузку, должен быть написано прямо в socket объект. Необходимо позаботиться о том, чтобы ответ был правильно отформатированным ответным сообщением HTTP.

err это пример Error с двумя дополнительными столбцами:

• bytesParsed: количество байтов пакета запроса, который Node.js мог правильно проанализировать;
• rawPacket: необработанный пакет текущего запроса.

В некоторых случаях клиент уже получил ответ и / или сокет уже был уничтожен, как в случае ECONNRESET ошибки. Прежде чем пытаться отправить данные в сокет, лучше убедиться, что он все еще доступен для записи.

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

  socket.end('HTTP/1.1 400 Bad Requestrnrn');
});

Событие: 'close'¶

Выдается при закрытии сервера.

Событие: 'connect'¶

• request {http.IncomingMessage} Аргументы для HTTP-запроса, как в 'request' событие
• socket {stream.Duplex} Сетевой сокет между сервером и клиентом
• head {Buffer} Первый пакет туннельного потока (может быть пустым)

Излучается каждый раз, когда клиент запрашивает HTTP CONNECT метод. Если это событие не прослушивается, то клиенты, запрашивающие CONNECT будут закрыты их соединения.

Это событие гарантированно будет передано экземпляру класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не укажет тип сокета, отличный от {net.Socket}.

После того, как это событие будет сгенерировано, сокет запроса не будет иметь 'data' прослушиватель событий, то есть его необходимо связать, чтобы обрабатывать данные, отправленные на сервер через этот сокет.

Событие: 'connection'¶

• socket {stream.Duplex}

Это событие генерируется, когда устанавливается новый поток TCP. socket обычно является объектом типа net.Socket. Обычно пользователи не хотят получать доступ к этому событию. В частности, сокет не будет излучать 'readable' события из-за того, как парсер протокола подключается к сокету. В socket также можно получить на request.socket.

Это событие также может быть явно отправлено пользователями для вставки соединений в HTTP-сервер. В этом случае любой Duplex поток можно пропустить.

Если socket.setTimeout() здесь вызывается, тайм-аут будет заменен на server.keepAliveTimeout когда сокет обслужил запрос (если server.keepAliveTimeout не равно нулю).

Это событие гарантированно будет передано экземпляру класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не укажет тип сокета, отличный от {net.Socket}.

Событие: 'request'¶

• request {http.IncomingMessage}
• response {http.ServerResponse}

Выдается каждый раз при запросе. На одно соединение может быть несколько запросов (в случае соединений HTTP Keep-Alive).

Событие: 'upgrade'¶

• request {http.IncomingMessage} Аргументы для HTTP-запроса, как в 'request' событие
• socket {stream.Duplex} Сетевой сокет между сервером и клиентом
• head {Buffer} Первый пакет обновленного потока (может быть пустым)

Выдается каждый раз, когда клиент запрашивает обновление HTTP. Прослушивание этого события необязательно, и клиенты не могут настаивать на изменении протокола.

После того, как это событие будет сгенерировано, сокет запроса не будет иметь 'data' прослушиватель событий, то есть его необходимо связать, чтобы обрабатывать данные, отправленные на сервер через этот сокет.

Это событие гарантированно будет передано экземпляру класса {net.Socket}, подкласса {stream.Duplex}, если пользователь не укажет тип сокета, отличный от {net.Socket}.

server.close([callback])¶

• callback {Функция}

Останавливает сервер от приема новых подключений. Видеть net.Server.close().

• {количество} Дефолт: 60000

Ограничьте время ожидания парсером получения полных заголовков HTTP.

В случае бездействия правила, определенные в server.timeout подать заявление. Однако этот тайм-аут, основанный на неактивности, по-прежнему позволяет поддерживать соединение открытым, если заголовки отправляются очень медленно (по умолчанию до байта в 2 минуты). Чтобы предотвратить это, всякий раз, когда поступают данные заголовка, выполняется дополнительная проверка, что более чем server.headersTimeout миллисекунд не прошло с момента установления соединения. Если проверка не удалась, 'timeout' событие генерируется на объекте сервера, и (по умолчанию) сокет уничтожается. Видеть server.timeout для получения дополнительной информации о том, как настроить поведение тайм-аута.

server.listen()¶

Запускает HTTP-сервер, ожидающий подключений. Этот метод идентичен server.listen() из net.Server.

server.listening¶

• {boolean} Указывает, прослушивает ли сервер соединения.

• {количество} Дефолт: 2000

Ограничивает максимальное количество входящих заголовков. Если установлено значение 0, ограничение не применяется.

server.requestTimeout¶

• {количество} Дефолт: 0

Устанавливает значение тайм-аута в миллисекундах для получения всего запроса от клиента.

Если тайм-аут истекает, сервер отвечает статусом 408, не перенаправляя запрос в приемник запросов, а затем закрывает соединение.

Он должен быть установлен на ненулевое значение (например, 120 секунд) для защиты от потенциальных атак типа «отказ в обслуживании» в случае, если сервер развернут без обратного прокси-сервера.

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

• msecs {количество} Дефолт: 0 (без тайм-аута)
• callback {Функция}
• Возвращает: {http.Server}

Устанавливает значение тайм-аута для сокетов и выдает 'timeout' в объекте Server, передавая сокет в качестве аргумента, если происходит тайм-аут.

Если есть 'timeout' прослушиватель событий на объекте Server, тогда он будет вызываться с тайм-аутом сокета в качестве аргумента.

По умолчанию сервер не отключает сокеты по таймауту. Однако, если обратный вызов назначен серверу 'timeout' событие таймауты должны обрабатываться явно.

server.maxRequestsPerSocket¶

• {число} запросов на сокет. Дефолт: 0 (без ограничений)

Максимальное количество запросов, которые сокет может обработать перед закрытием соединения keep alive.

Ценность 0 отключит ограничение.

Когда предел будет достигнут, он установит Connection значение заголовка для close, но фактически не закроет соединение, последующие запросы, отправленные после достижения лимита, получат 503 Service Unavailable как ответ.

server.timeout¶

• {number} Тайм-аут в миллисекундах. Дефолт: 0 (без тайм-аута)

Количество миллисекунд бездействия до истечения тайм-аута сокета.

Ценность 0 отключит поведение тайм-аута для входящих подключений.

Логика тайм-аута сокета настраивается при подключении, поэтому изменение этого значения влияет только на новые подключения к серверу, но не на существующие подключения.

server.keepAliveTimeout¶

• {number} Тайм-аут в миллисекундах. Дефолт: 5000 (5 секунд).

Количество миллисекунд бездействия, необходимое серверу для ожидания дополнительных входящих данных после того, как он закончит запись последнего ответа, прежде чем сокет будет уничтожен. Если сервер получит новые данные до того, как истечет тайм-аут проверки активности, он сбросит обычный тайм-аут бездействия, т. Е. server.timeout.

Ценность 0 отключит тайм-аут сохранения активности для входящих подключений. Ценность 0 заставляет http-сервер вести себя аналогично версиям Node.js до 8.0.0, в которых не было тайм-аута сохранения активности.

Логика тайм-аута сокета настраивается при подключении, поэтому изменение этого значения влияет только на новые подключения к серверу, но не на существующие подключения.

Класс: http.ServerResponse¶

• Расширяется: {Stream}

Этот объект создается внутри HTTP-сервером, а не пользователем. Он передается вторым параметром в 'request' событие.

Событие: 'close'¶

Указывает, что ответ завершен или его базовое соединение было преждевременно прервано (до завершения ответа).

Событие: 'finish'¶

Выдается после отправки ответа. В частности, это событие генерируется, когда последний сегмент заголовков и тела ответа передан операционной системе для передачи по сети. Это не означает, что клиент еще что-то получил.

• headers {Объект}

Этот метод добавляет к ответу завершающие заголовки HTTP (заголовок, но в конце сообщения).

Прицепы будут Только выдается, если для ответа используется кодирование по частям; если это не так (например, если запрос был HTTP / 1.0), они будут отброшены без уведомления.

HTTP требует Trailer заголовок, который будет отправлен для отправки трейлеров, со списком полей заголовка в его значении. Например.,

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

Попытка установить имя поля заголовка или значение, содержащее недопустимые символы, приведет к TypeError быть брошенным.

response.connection¶

Стабильность: 0 — Не рекомендуется. Использовать response.socket.

• {stream.Duplex}

Видеть response.socket.

response.cork()¶

Видеть writable.cork().

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

• data {строка | буфер}
• encoding {нить}
• callback {Функция}
• Возвращает: {this}

Этот метод сигнализирует серверу, что все заголовки и тело ответа отправлены; этот сервер должен считать это сообщение завершенным. Метод, response.end(), ДОЛЖЕН вызываться при каждом ответе.

Если data указан, он аналогичен вызову response.write(data, encoding) с последующим response.end(callback).

Если callback указан, он будет вызываться по завершении потока ответа.

response.finished¶

Стабильность: 0 — Не рекомендуется. Использовать response.writableEnded.

• {логический}

В response.finished собственность будет true если response.end() был вызван.

Удаляет заголовки ответа. Смотрите также: request.flushHeaders().

• name {нить}
• Возврат: {любой}

Считывает заголовок, который уже поставлен в очередь, но не отправлен клиенту. Имя не чувствительно к регистру. Тип возвращаемого значения зависит от аргументов, предоставленных для 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 is 'text/html'
const contentLength = response.getHeader('Content-Length');
// contentLength is of type number
const setCookie = response.getHeader('set-cookie');
// setCookie is of type string[]

• Возвращает: {строка []}

Возвращает массив, содержащий уникальные имена текущих исходящих заголовков. Все имена заголовков в нижнем регистре.

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

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

• Возвращает: {Object}

Возвращает частичную копию текущих исходящих заголовков. Поскольку используется неглубокая копия, значения массива можно изменять без дополнительных вызовов различных методов HTTP-модуля, связанных с заголовками. Ключи возвращаемого объекта — это имена заголовков, а значения — соответствующие значения заголовков. Все имена заголовков в нижнем регистре.

Объект, возвращаемый response.getHeaders() метод не прототипно унаследовать от JavaScript Object. Это означает, что типичный Object такие методы как obj.toString(), obj.hasOwnProperty(), а другие не определены и не будет работать.

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

• name {нить}
• Возвращает: {логическое}

Возврат true если заголовок идентифицирован name в настоящее время устанавливается в исходящих заголовках. При сопоставлении имени заголовка регистр не учитывается.

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

• {логический}

Boolean (только для чтения). Истина, если заголовки были отправлены, в противном случае — ложь.

• name {нить}

Удаляет заголовок, поставленный в очередь для неявной отправки.

response.removeHeader('Content-Encoding');

response.req¶

• {http.IncomingMessage}

Ссылка на исходный HTTP request объект.

response.sendDate¶

• {логический}

Если установлено значение true, заголовок Date будет автоматически сгенерирован и отправлен в ответе, если он еще не присутствует в заголовках. По умолчанию true.

Это следует отключать только для тестирования; HTTP требует заголовка Date в ответах.

• name {нить}
• value {любой}
• Возвращает: {http.ServerResponse}

Возвращает объект ответа.

Устанавливает одно значение заголовка для неявных заголовков. Если этот заголовок уже существует в заголовках для отправки, его значение будет заменено. Используйте здесь массив строк, чтобы отправить несколько заголовков с одним и тем же именем. Нестроковые значения будут сохранены без изменений. Следовательно, response.getHeader() может возвращать нестроковые значения. Однако нестроковые значения будут преобразованы в строки для передачи по сети. Тот же объект ответа возвращается вызывающему, чтобы включить цепочку вызовов.

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

или

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

Попытка установить имя поля заголовка или значение, содержащее недопустимые символы, приведет к TypeError быть брошенным.

Когда заголовки были установлены с response.setHeader(), они будут объединены с любыми заголовками, переданными в response.writeHead(), с заголовками, переданными в response.writeHead() учитывая приоритет.

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

Если response.writeHead() вызывается метод, и этот метод не был вызван, он будет напрямую записывать предоставленные значения заголовка в сетевой канал без внутреннего кэширования, а response.getHeader() в заголовке не даст ожидаемого результата. Если желательно прогрессивное заполнение заголовков с возможным извлечением и модификацией в будущем, используйте response.setHeader() вместо того response.writeHead().

response.setTimeout(msecs[, callback])¶

• msecs {количество}
• callback {Функция}
• Возвращает: {http.ServerResponse}

Устанавливает значение тайм-аута сокета равным msecs. Если предоставляется обратный вызов, он добавляется в качестве слушателя на 'timeout' событие в объекте ответа.

Если нет 'timeout' слушатель добавляется к запросу, ответу или серверу, а затем сокеты уничтожаются по истечении времени ожидания. Если на запрос назначен обработчик, ответ или серверный 'timeout' события, сокеты с истекшим временем ожидания должны обрабатываться явно.

response.socket¶

• {stream.Duplex}

Ссылка на базовый сокет. Обычно пользователи не хотят получать доступ к этому свойству. В частности, сокет не будет излучать 'readable' события из-за того, как парсер протокола подключается к сокету. После response.end(), собственность аннулирована.

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

Это свойство гарантированно является экземпляром класса {net.Socket}, подкласса {stream.Duplex}, если только пользователь не указал тип сокета, отличный от {net.Socket}.

response.statusCode¶

• {количество} Дефолт: 200

При использовании неявных заголовков (не вызывающих response.writeHead() явно), это свойство управляет кодом состояния, который будет отправлен клиенту при сбросе заголовков.

response.statusCode = 404;

После того, как заголовок ответа был отправлен клиенту, это свойство указывает код состояния, который был отправлен.

response.statusMessage¶

• {нить}

При использовании неявных заголовков (не вызывающих response.writeHead() явно), это свойство управляет сообщением о состоянии, которое будет отправлено клиенту, когда заголовки будут сброшены. Если это оставить как undefined тогда будет использоваться стандартное сообщение для кода состояния.

response.statusMessage = 'Not found';

После того, как заголовок ответа был отправлен клиенту, это свойство указывает сообщение о состоянии, которое было отправлено.

response.uncork()¶

Видеть writable.uncork().

response.writableEnded¶

• {логический}

Является true после response.end() был вызван. Это свойство не указывает, были ли данные сброшены, для этого использования. response.writableFinished вместо.

response.writableFinished¶

• {логический}

Является true если все данные были сброшены в базовую систему, непосредственно перед 'finish' событие испускается.

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

• chunk {строка | буфер}
• encoding {нить} Дефолт: 'utf8'
• callback {Функция}
• Возвращает: {логическое}

Если этот метод вызван и response.writeHead() не был вызван, он переключится в режим неявного заголовка и сбрасывает неявные заголовки.

Это отправляет кусок тела ответа. Этот метод может вызываться несколько раз для получения последовательных частей тела.

в http модуль, тело ответа опускается, если запрос является запросом HEAD. Аналогичным образом 204 а также 304 ответы не должен включить тело сообщения.

chunk может быть строкой или буфером. Если chunk является строкой, второй параметр указывает, как ее кодировать в поток байтов. callback будет вызываться, когда этот фрагмент данных будет сброшен.

Это необработанное тело HTTP и не имеет ничего общего с кодировками, состоящими из нескольких частей, которые могут быть использованы.

Первый раз response.write() вызывается, он отправит клиенту буферизованную информацию заголовка и первый фрагмент тела. Второй раз response.write() вызывается, Node.js предполагает, что данные будут передаваться в потоковом режиме, и отправляет новые данные отдельно. То есть ответ буферизируется до первого фрагмента тела.

Возврат true если все данные были успешно сброшены в буфер ядра. Возврат false если все или часть данных были помещены в очередь в пользовательской памяти. 'drain' будет выдан, когда буфер снова освободится.

response.writeContinue()¶

Отправляет клиенту сообщение HTTP / 1.1 100 Continue, указывающее, что тело запроса должно быть отправлено. Увидеть 'checkContinue' событие на Server.

• statusCode {количество}
• statusMessage {нить}
• headers {Объект | Массив}
• Возвращает: {http.ServerResponse}

Отправляет заголовок ответа на запрос. Код состояния представляет собой трехзначный код состояния HTTP, например 404. Последний аргумент, headers, являются заголовками ответа. При желании можно указать удобочитаемый statusMessage как второй аргумент.

headers может быть Array где ключи и значения находятся в одном списке. это нет список кортежей. Таким образом, смещения с четными номерами являются ключевыми значениями, а смещения с нечетными номерами — соответствующими значениями. Массив имеет тот же формат, что и request.rawHeaders.

Возвращает ссылку на ServerResponse, так что вызовы можно связывать.

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

Этот метод должен вызываться только один раз в сообщении, и он должен быть вызван перед response.end() называется.

Если response.write() или response.end() вызываются перед вызовом этого, неявные / изменяемые заголовки будут вычислены и вызовут эту функцию.

Когда заголовки были установлены с response.setHeader(), они будут объединены с любыми заголовками, переданными в response.writeHead(), с заголовками, переданными в response.writeHead() учитывая приоритет.

Если этот метод вызван и response.setHeader() не был вызван, он будет напрямую записывать предоставленные значения заголовка в сетевой канал без внутреннего кэширования, а response.getHeader() в заголовке не даст ожидаемого результата. Если желательно прогрессивное заполнение заголовков с возможным извлечением и модификацией в будущем, используйте response.setHeader() вместо.

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

Content-Length дается в байтах, а не в символах. Использовать Buffer.byteLength() для определения длины тела в байтах. Node.js не проверяет, Content-Length и длина переданного тела равна или нет.

Попытка установить имя поля заголовка или значение, содержащее недопустимые символы, приведет к TypeError быть брошенным.

response.writeProcessing()¶

Отправляет клиенту сообщение HTTP / 1.1 102 Processing, указывающее, что тело запроса должно быть отправлено.

Класс: http.IncomingMessage¶

• Расширяется: {stream.Readable}

An IncomingMessage объект создан http.Server или http.ClientRequest и передается в качестве первого аргумента в 'request' а также 'response' событие соответственно. Его можно использовать для доступа к статусу ответа, заголовкам и данным.

В отличие от своего socket значение, которое является подклассом {stream.Duplex}, IncomingMessage сам расширяет {stream.Readable} и создается отдельно для синтаксического анализа и выдачи входящих HTTP-заголовков и полезной нагрузки, так как базовый сокет может быть повторно использован несколько раз в случае сохранения активности.

Событие: 'aborted'¶

Стабильность: 0 — Не рекомендуется. Слушай 'close' событие вместо этого.

Выдается, когда запрос был прерван.

Событие: 'close'¶

Указывает, что базовое соединение было закрыто.

message.aborted¶

Стабильность: 0 — Не рекомендуется. Проверять message.destroyed из {stream.Readable}.

• {логический}

В message.aborted собственность будет true если запрос был прерван.

message.complete¶

• {логический}

В message.complete собственность будет true если было получено и успешно проанализировано полное сообщение HTTP.

Это свойство особенно полезно как средство определения того, полностью ли клиент или сервер передал сообщение до того, как соединение было разорвано:

const req = http.request(
  {
    host: '127.0.0.1',
    port: 8080,
    method: 'POST',
  },
  (res) => {
    res.resume();
    res.on('end', () => {
      if (!res.complete)
        console.error(
          'The connection was terminated while the message was still being sent'
        );
    });
  }
);

message.connection¶

Стабильность: 0 — Не рекомендуется. Использовать message.socket.

Псевдоним для message.socket.

message.destroy([error])¶

• error {Ошибка}
• Возвращает: {this}

Звонки destroy() на сокете, который получил IncomingMessage. Если error предоставляется, 'error' событие испускается в сокете и error передается в качестве аргумента всем слушателям события.

• {Объект}

Объект заголовков запроса / ответа.

Пары «ключ-значение», состоящие из имен и значений заголовков. Имена заголовков в нижнем регистре.

// Prints something like:
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers);

Дубликаты в необработанных заголовках обрабатываются следующими способами, в зависимости от имени заголовка:

• Дубликаты age, authorization, content-length, content-type, etag, expires, from, host, if-modified-since, if-unmodified-since, last-modified, location, max-forwards, proxy-authorization, referer, retry-after, server, или user-agent отбрасываются.
• set-cookie всегда массив. В массив добавляются дубликаты.
• Для дубликата cookie заголовки, значения объединяются вместе с помощью ‘; ‘.
• Для всех остальных заголовков значения объединяются вместе с помощью ‘,’.

message.httpVersion¶

• {нить}

В случае запроса сервера — версия HTTP, отправленная клиентом. В случае ответа клиента — версия HTTP подключенного сервера. Наверное, либо '1.1' или '1.0'.

Также message.httpVersionMajor — первое целое число и message.httpVersionMinor это второй.

message.method¶

• {нить}

Действительно только для запроса, полученного от http.Server.

Метод запроса в виде строки. Только чтение. Примеры: 'GET', 'DELETE'.

• {нить[]}

Необработанные заголовки запроса / ответа перечислены в том виде, в котором они были получены.

Ключи и значения находятся в одном списке. это нет список кортежей. Таким образом, смещения с четными номерами являются ключевыми значениями, а смещения с нечетными номерами — соответствующими значениями.

Имена заголовков не в нижнем регистре, и дубликаты не объединяются.

// Prints something like:
//
// [ '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¶

• {нить[]}

Необработанные ключи и значения трейлера запроса / ответа в том виде, в котором они были получены. Заселены только в 'end' событие.

message.setTimeout(msecs[, callback])¶

• msecs {количество}
• callback {Функция}
• Возвращает: {http.IncomingMessage}

Звонки message.socket.setTimeout(msecs, callback).

message.socket¶

• {stream.Duplex}

В net.Socket объект, связанный с подключением.

С поддержкой HTTPS используйте request.socket.getPeerCertificate() чтобы получить данные аутентификации клиента.

Это свойство гарантированно является экземпляром класса {net.Socket}, подкласса {stream.Duplex}, если только пользователь не указал тип сокета, отличный от {net.Socket}.

message.statusCode¶

• {количество}

Действительно только для ответа, полученного от http.ClientRequest.

3-значный код состояния ответа HTTP. НАПРИМЕР. 404.

message.statusMessage¶

• {нить}

Действительно только для ответа, полученного от http.ClientRequest.

Сообщение о статусе ответа HTTP (фраза причины). НАПРИМЕР. OK или Internal Server Error.

message.trailers¶

• {Объект}

Объект трейлеров запроса / ответа. Заселены только в 'end' событие.

message.url¶

• {нить}

Действительно только для запроса, полученного от http.Server.

Строка URL-адреса запроса. Он содержит только URL-адрес, который присутствует в фактическом HTTP-запросе. Примите следующий запрос:

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

Чтобы разобрать URL-адрес на части:

new URL(request.url, `http://${request.headers.host}`);

Когда request.url является '/status?name=ryan' а также request.headers.host является 'localhost:3000':

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

Класс: http.OutgoingMessage¶

• Расширяется: {Stream}

Этот класс служит родительским классом для http.ClientRequest а также http.ServerResponse. Это абстракция исходящего сообщения с точки зрения участников HTTP-транзакции.

Событие: drain¶

Выдается, когда буфер сообщения снова становится свободным.

Событие: finish¶

Выдается после успешного завершения передачи.

Событие: prefinish¶

Выдается, когда outgoingMessage.end назывался. Когда событие генерируется, все данные были обработаны, но не обязательно полностью сброшены.

• headers {Объект}

Добавляет к сообщению трейлеры HTTP (заголовки, но в конце сообщения).

Прицепы Только будет отправлено, если сообщение закодировано по частям. В противном случае трейлер будет отброшен.

HTTP требует Trailer заголовок, который будет отправлен для отправки трейлеров, со списком полей заголовка в его значении, например

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

Попытка установить имя поля заголовка или значение, содержащее недопустимые символы, приведет к TypeError быть брошенным.

outgoingMessage.connection¶

Стабильность: 0 — Не рекомендуется: использовать outgoingMessage.socket вместо.

Псевдонимы outgoingMessage.socket

outgoingMessage.cork()¶

Видеть writable.cork().

outgoingMessage.destroy([error])¶

• error {Error} Необязательно, сообщение об ошибке error событие
• Возвращает: {this}

Уничтожает сообщение. Как только сокет связан с сообщением и подключен, этот сокет также будет уничтожен.

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

• chunk {строка | Buffer}
• encoding {string} Необязательно, Дефолт: utf8
• callback {Function} Необязательно
• Возвращает: {this}

Завершает исходящее сообщение. Если какие-либо части тела не отправлены, они будут сброшены в нижележащую систему. Если сообщение разбито на фрагменты, оно отправит завершающий фрагмент. 0rnrn, и отправьте трейлер (если есть).

Если chunk указано, это эквивалентно вызову outgoingMessage.write(chunk, encoding), с последующим outgoingMessage.end(callback).

Если callback предоставлен, он будет вызываться по завершении сообщения. (эквивалент обратного вызова для события finish)

Обязательно очищает заголовки сообщений

По соображениям эффективности Node.js обычно буферизует заголовки сообщений до тех пор, пока outgoingMessage.end() вызывается или записывается первый фрагмент данных сообщения. Затем он пытается упаковать заголовки и данные в один TCP-пакет.

Обычно это желательно (это экономит время приема-передачи TCP), но не тогда, когда первые данные не отправляются, возможно, гораздо позже. outgoingMessage.flushHeaders() обходит оптимизацию и запускает запрос.

• name {строка} Название заголовка
• Возвращает {строку | неопределенный}

Получает значение заголовка HTTP с заданным именем. Если такого имени нет в сообщении, оно будет undefined.

• Возвращает {строку []}

Возвращает массив имен заголовков исходящего сообщения outgoingMessage. Все имена в нижнем регистре.

• Возвращает: {Object}

Возвращает частичную копию текущих исходящих заголовков. Поскольку используется неглубокая копия, значения массива могут изменяться без дополнительных вызовов различных методов модуля HTTP, связанных с заголовками. Ключи возвращаемого объекта — это имена заголовков, а значения — соответствующие значения заголовков. Все имена заголовков в нижнем регистре.

Объект, возвращаемый outgoingMessage.getHeaders() не наследуется прототипом от объекта JavaScript. Это означает, что типичные методы объекта, такие как obj.toString(), obj.hasOwnProperty(), и другие не определены и работать не будут.

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

• name {нить}
• Возвращает {логическое}

Возврат true если заголовок идентифицирован name в настоящее время устанавливается в исходящих заголовках. Имя заголовка не чувствительно к регистру.

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

• {логический}

Только для чтения. true если заголовки были отправлены, иначе false.

outgoingMessage.pipe()¶

Переопределяет метод канала прежней версии Stream который является родительским классом http.outgoingMessage.

С OutgoingMessage должен быть потоком только для записи, вызов этой функции вызовет Error. Таким образом, он отключил метод канала, который он наследует от Stream.

Пользователь не должен вызывать эту функцию напрямую.

Удаляет заголовок, поставленный в очередь для неявной отправки.

outgoingMessage.removeHeader('Content-Encoding');

• name {строка} Название заголовка
• value {строка} значение заголовка
• Возвращает: {this}

Устанавливает одно значение заголовка для объекта заголовка.

outgoingMessage.setTimeout(msesc[, callback])¶

• msesc {количество}
• callback {Функция} Необязательная функция, вызываемая при истечении времени ожидания. То же, что и привязка к timeout событие.
• Возвращает: {this}

Как только сокет связан с сообщением и подключен, socket.setTimeout() будет называться с msecs в качестве первого параметра.

outgoingMessage.socket¶

• {stream.Duplex}

Ссылка на базовый сокет. Обычно пользователи не хотят получать доступ к этому свойству.

После звонка outgoingMessage.end(), это свойство будет обнулено.

outgoingMessage.uncork()¶

Видеть writable.uncork()

outgoingMessage.writableCorked¶

• {количество}

Этот outgoingMessage.writableCorked вернет время сколько outgoingMessage.cork() были вызваны.

outgoingMessage.writableEnded¶

• {логический}

Только чтение, true если outgoingMessage.end() был вызван. Отметил, что это свойство не отражает, были ли данные сброшены. Для этого используйте message.writableFinished вместо.

outgoingMessage.writableFinished¶

• {логический}

Только для чтения. true если все данные были сброшены в базовую систему.

outgoingMessage.writableHighWaterMark¶

• {количество}

Этот outgoingMessage.writableHighWaterMark будет highWaterMark базового сокета, если сокет существует. В противном случае это будет по умолчанию highWaterMark.

highWaterMark — это максимальный объем данных, который потенциально может буферизоваться сокетом.

outgoingMessage.writableLength¶

• {количество}

Только для чтения, Это outgoingMessage.writableLength содержит количество байтов (или объектов) в буфере, готовых к отправке.

outgoingMessage.writableObjectMode¶

• {логический}

Только чтение, всегда возвращается false.

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

• chunk {строка | Buffer}
• encoding {нить} Дефолт: utf8
• callback {Функция}
• Возвращает {логическое}

Если этот метод вызван, а заголовок не отправлен, он вызовет this._implicitHeader чтобы очистить неявный заголовок. Если у сообщения не должно быть тела (обозначено this._hasBody) вызов игнорируется и chunk не будут отправлены. Это может быть полезно при обработке конкретного сообщения, которое не должно включать тело. например ответ на HEAD запрос, 204 а также 304 отклик.

chunk может быть строкой или буфером. Когда chunk это строка, encoding параметр определяет, как кодировать chunk в поток байтов. callback будет вызван, когда chunk покраснел.

Если сообщение передается в кодировке chucked (обозначено this.chunkedEncoding), chunk будет сброшен как один фрагмент среди потока фрагментов. В противном случае он будет сброшен как тело сообщения.

Этот метод обрабатывает необработанное тело сообщения HTTP и не имеет ничего общего с кодировками, состоящими из нескольких частей, которые могут быть использованы.

Если это первый вызов этого метода сообщения, он сначала отправит буферизованный заголовок, а затем сбросит chunk как описано выше.

Второй и последующие вызовы этого метода предполагают, что данные будут переданы в потоковом режиме, и отправят новые данные отдельно. Это означает, что ответ буферизируется до первого фрагмента тела.

Возврат true если все данные были успешно сброшены в буфер ядра. Возврат false если все или часть данных были помещены в очередь в пользовательской памяти. Мероприятие drain будет выдан, когда буфер снова освободится.

http.METHODS¶

• {нить[]}

Список HTTP-методов, поддерживаемых парсером.

http.STATUS_CODES¶

• {Объект}

Коллекция всех стандартных кодов состояния ответа HTTP и краткое описание каждого из них. Например, http.STATUS_CODES[404] === 'Not Found'.

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

• options {Объект}

• IncomingMessage {http.IncomingMessage} Определяет IncomingMessage класс, который будет использоваться. Полезно для расширения оригинала IncomingMessage. Дефолт: IncomingMessage.

• ServerResponse {http.ServerResponse} Определяет ServerResponse класс, который будет использоваться. Полезно для расширения оригинала ServerResponse. Дефолт: ServerResponse.
• insecureHTTPParser {boolean} Использовать небезопасный анализатор HTTP, который принимает недопустимые заголовки HTTP, когда true. Следует избегать использования небезопасного парсера. Видеть --insecure-http-parser для дополнительной информации. Дефолт: false

• maxHeaderSize {number} Необязательно переопределяет значение --max-http-header-size для запросов, полученных этим сервером, т. е. максимальная длина заголовков запроса в байтах. Дефолт: 16384 (16 КБ).

• requestListener {Функция}

• Возвращает: {http.Server}

Возвращает новый экземпляр http.Server.

В requestListener это функция, которая автоматически добавляется к 'request' событие.

const http = require('http');

// Create a local server to receive data from
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('http');

// Create a local server to receive data from
const server = http.createServer();

// Listen to the request event
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])¶

• url {строка | URL}
• options {Object} принимает то же самое options в качестве http.request(), с method всегда установлен на GET. Свойства, унаследованные от прототипа, игнорируются.
• callback {Функция}
• Возвращает: {http.ClientRequest}

Поскольку большинство запросов представляют собой GET-запросы без тел, Node.js предоставляет этот удобный метод. Единственная разница между этим методом и http.request() в том, что он устанавливает метод в GET и вызывает req.end() автоматически. Обратный вызов должен позаботиться о потреблении данных ответа по причинам, указанным в http.ClientRequest раздел.

В callback вызывается с одним аргументом, который является экземпляром http.IncomingMessage.

Пример получения JSON:

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

    let error;
    // Any 2xx status code signals a successful response but
    // here we're only checking for 200.
    if (statusCode !== 200) {
      error = new Error(
        'Request Failed.n' + `Status Code: ${statusCode}`
      );
    } else if (!/^application/json/.test(contentType)) {
      error = new Error(
        'Invalid content-type.n' +
          `Expected application/json but received ${contentType}`
      );
    }
    if (error) {
      console.error(error.message);
      // Consume response data to free up memory
      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(`Got error: ${e.message}`);
  });

// Create a local server to receive data from
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¶

• {http.Agent}

Глобальный экземпляр Agent который используется по умолчанию для всех клиентских HTTP-запросов.

• {количество}

Свойство только для чтения, указывающее максимально допустимый размер заголовков HTTP в байтах. По умолчанию 8 КБ. Настраивается с помощью --max-http-header-size Вариант CLI.

Это можно изменить для запросов серверов и клиентов, передав maxHeaderSize вариант.

http.request(options[, callback])¶

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

• url {строка | URL}
• options {Объект}
• agent {http.Agent | boolean} Элементы управления Agent поведение. Возможные значения:
  • undefined (по умолчанию): использовать http.globalAgent для этого хоста и порта.
  • Agent объект: явно использовать переданный Agent.
  • false: вызывает новый Agent со значениями по умолчанию, которые будут использоваться.
• auth {строка} Базовая аутентификация, т.е. 'user:password' для вычисления заголовка авторизации.
• createConnection {Функция} Функция, которая создает сокет / поток для использования в запросе, когда agent опция не используется. Это можно использовать, чтобы избежать создания настраиваемого Agent класс, чтобы переопределить значение по умолчанию createConnection функция. Видеть agent.createConnection() Больше подробностей. Любой Duplex stream — допустимое возвращаемое значение.
• defaultPort {number} Порт по умолчанию для протокола. Дефолт: agent.defaultPort если Agent используется, иначе undefined.
• family {number} семейство IP-адресов для использования при разрешении host или hostname. Допустимые значения: 4 или 6. Если не указано иное, будут использоваться IP v4 и v6.
• headers {Object} Объект, содержащий заголовки запроса.
• hints {number} Необязательно dns.lookup() подсказки.
• host {строка} Доменное имя или IP-адрес сервера, на который будет отправлен запрос. Дефолт: 'localhost'.
• hostname {string} Псевдоним для host. Поддерживать url.parse(), hostname будет использоваться, если оба host а также hostname указаны.
• insecureHTTPParser {boolean} Использовать небезопасный анализатор HTTP, который принимает недопустимые заголовки HTTP, когда true. Следует избегать использования небезопасного парсера. Видеть --insecure-http-parser для дополнительной информации. Дефолт: false
• localAddress {строка} Локальный интерфейс для привязки сетевых подключений.
• localPort {number} Локальный порт для подключения.
• lookup {Функция} Пользовательская функция поиска. Дефолт: dns.lookup().
• maxHeaderSize {number} Необязательно переопределяет значение --max-http-header-size для ответов, полученных от сервера, т. е. максимальная длина заголовков ответов в байтах. Дефолт: 16384 (16 КБ).
• method {строка} Строка, определяющая метод HTTP-запроса. Дефолт: 'GET'.
• path {строка} Путь запроса. Должен включать строку запроса, если таковая имеется. НАПРИМЕР. '/index.html?page=12'. Исключение возникает, когда путь запроса содержит недопустимые символы. В настоящее время отклоняются только пробелы, но это может измениться в будущем. Дефолт: '/'.
• port {номер} Порт удаленного сервера. Дефолт: defaultPort если установлено, иначе 80.
• protocol {строка} Используемый протокол. Дефолт: 'http:'.
• setHost {boolean}: указывает, следует ли автоматически добавлять Host заголовок. По умолчанию true.
• socketPath {string} Сокет домена Unix (не может использоваться, если один из host или port указано, это указывает сокет TCP).
• timeout {число}: число, указывающее время ожидания сокета в миллисекундах. Это установит тайм-аут до подключения сокета.
• signal {AbortSignal}: AbortSignal, который может использоваться для прерывания текущего запроса.
• callback {Функция}
• Возвращает: {http.ClientRequest}

Node.js поддерживает несколько подключений к серверу для выполнения HTTP-запросов. Эта функция позволяет прозрачно отправлять запросы.

url может быть строкой или URL объект. Если url является строкой, она автоматически анализируется с помощью new URL(). Если это URL объект, он будет автоматически преобразован в обычный options объект.

Если оба url а также options указаны, объекты объединяются, при этом options свойства имеют приоритет.

Необязательный callback будет добавлен как одноразовый слушатель для 'response' событие.

http.request() возвращает экземпляр http.ClientRequest класс. В ClientRequest instance — это поток с возможностью записи. Если нужно загрузить файл с помощью POST-запроса, напишите в ClientRequest объект.

const http = require('http');

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

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

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

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

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

В примере req.end() назывался. С участием http.request() нужно всегда звонить req.end() чтобы обозначить конец запроса — даже если в тело запроса не записываются никакие данные.

Если во время запроса обнаружена какая-либо ошибка (будь то разрешение DNS, ошибки уровня TCP или фактические ошибки синтаксического анализа HTTP), 'error' Событие генерируется для возвращенного объекта запроса. Как и все 'error' события, если слушатели не зарегистрированы, будет выдана ошибка.

Следует отметить несколько специальных заголовков.

• Отправка «Connection: keep-alive» уведомит Node.js о том, что соединение с сервером должно быть сохранено до следующего запроса.

• Отправка заголовка Content-Length отключит кодировку фрагментов по умолчанию.

• Отправка заголовка Expect немедленно отправит заголовки запроса. Обычно при отправке «Expect: 100-continue» и тайм-аут, и прослушиватель для 'continue' событие должно быть установлено. Для получения дополнительной информации см. RFC 2616, раздел 8.2.3.

• Отправка заголовка авторизации переопределит использование auth возможность вычисления базовой аутентификации.

Пример использования URL в качестве options:

const options = new URL('http://abc:[email protected]');

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

При успешном запросе будут сгенерированы следующие события в следующем порядке:

• 'socket'
• 'response'
• 'data' любое количество раз на res объект ('data' не будет генерироваться вообще, если тело ответа пусто, например, в большинстве редиректов)
• 'end' на res объект
• 'close'

В случае ошибки подключения будут выданы следующие события:

• 'socket'
• 'error'
• 'close'

В случае преждевременного закрытия соединения до получения ответа будут отправлены следующие события в следующем порядке:

• 'socket'
• 'error' с ошибкой с сообщением 'Error: socket hang up' и код 'ECONNRESET'
• 'close'

В случае преждевременного закрытия соединения после получения ответа будут сгенерированы следующие события в следующем порядке:

• 'socket'
• 'response'
• 'data' любое количество раз на res объект
• (соединение здесь закрыто)
• 'aborted' на res объект
• 'error' на res объект с ошибкой с сообщением 'Error: aborted' и код 'ECONNRESET'.
• 'close'
• 'close' на res объект

Если req.destroy() вызывается перед назначением сокета, следующие события будут генерироваться в следующем порядке:

• (req.destroy() звонил сюда)
• 'error' с ошибкой с сообщением 'Error: socket hang up' и код 'ECONNRESET'
• 'close'

Если req.destroy() вызывается до того, как соединение будет установлено, следующие события будут генерироваться в следующем порядке:

• 'socket'
• (req.destroy() звонил сюда)
• 'error' с ошибкой с сообщением 'Error: socket hang up' и код 'ECONNRESET'
• 'close'

Если req.destroy() вызывается после получения ответа, следующие события будут сгенерированы в следующем порядке:

• 'socket'
• 'response'
• 'data' любое количество раз на res объект
• (req.destroy() звонил сюда)
• 'aborted' на res объект
• 'error' на res объект с ошибкой с сообщением 'Error: aborted' и код 'ECONNRESET'.
• 'close'
• 'close' на res объект

Если req.abort() вызывается перед назначением сокета, следующие события будут генерироваться в следующем порядке:

• (req.abort() звонил сюда)
• 'abort'
• 'close'

Если req.abort() вызывается до того, как соединение будет установлено, следующие события будут генерироваться в следующем порядке:

• 'socket'
• (req.abort() звонил сюда)
• 'abort'
• 'error' с ошибкой с сообщением 'Error: socket hang up' и код 'ECONNRESET'
• 'close'

Если req.abort() вызывается после получения ответа, следующие события будут сгенерированы в следующем порядке:

• 'socket'
• 'response'
• 'data' любое количество раз на res объект
• (req.abort() звонил сюда)
• 'abort'
• 'aborted' на res объект
• 'error' на res объект с ошибкой с сообщением 'Error: aborted' и код 'ECONNRESET'.
• 'close'
• 'close' на res объект

Установка timeout вариант или используя setTimeout() функция не прервет запрос и не сделает ничего, кроме добавления 'timeout' событие.

Прохождение AbortSignal а затем позвонив abort на соответствующем AbortController будет вести себя так же, как вызов .destroy() по самому запросу.

• name {нить}

Выполняет низкоуровневые проверки предоставленных name это делается, когда res.setHeader(name, value) называется.

Передача недопустимого значения как name приведет к TypeError быть брошенным, идентифицированным code: 'ERR_INVALID_HTTP_TOKEN'.

Нет необходимости использовать этот метод перед передачей заголовков в HTTP-запрос или ответ. Модуль HTTP автоматически проверяет такие заголовки. Примеры:

Пример:

const { validateHeaderName } = require('http');

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

• name {нить}
• value {любой}

Выполняет низкоуровневые проверки предоставленных value это делается, когда res.setHeader(name, value) называется.

Передача недопустимого значения как value приведет к TypeError быть брошенным.

• Ошибка неопределенного значения обозначается code: 'ERR_HTTP_INVALID_HEADER_VALUE'.
• Ошибка символа недопустимого значения обозначается code: 'ERR_INVALID_CHAR'.

Нет необходимости использовать этот метод перед передачей заголовков в HTTP-запрос или ответ. Модуль HTTP автоматически проверяет такие заголовки.

Примеры:

const { validateHeaderValue } = require('http');

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

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

Don’t you hate it when you see an uncaughtException error pop up and crash your Node.js app?

Yeah… I feel you. Can anything be worse? Oh yeah, sorry, unhandledRejection I didn’t see you there. What a nightmare you are. 😬

I maintain all Node.js open-source repos at Sematext. A few of them can help you out with error handling, but more about that further down.

Here at Sematext, we take error handling seriously! I want to share a bit of that today.

I want to guide you through what I’ve learned so far about error handling in Node.js while working on open-source projects. Hopefully, it’ll help you improve your code, make it more robust, and ultimately help you step up your bug hunting, and help improve your general developer experience.

I don’t want you to have to stay up late and burn the midnight oil troubleshooting bugs. Ah! About that, here’s an epic song I really like!

What Is Error Handling in Node.js

I’ve heard a ton of my fellow developers say error handling in Node.js is way too hard. Well, I can’t lie. It’s not easy. But, I have to be fair and say it’s not that hard either once you set up centralized error handling.

What is an error anyhow? It’s a way to see bugs in your code. Following this logic, error handling is a way to find these bugs and solve them as quickly as humanly possible.

From this explanation, it’s obvious the hard part is setting up a good base for your error handling. It’s all about keeping you sane at the end of the day. Handling errors properly means developing a robust codebase and reducing development time by finding bugs and errors easily.

Why Do You Need Error Handling

Why? For your own sanity. You want to make bug fixing less painful. It helps you write cleaner code. It centralizes all errors and lets you enable alerting and notifications so you know when and how your code breaks.

Types of Errors: Operational vs. Programmer Errors

Would you believe me when I said not all errors are caused by humans? Don’t get me wrong, most still are, but not all of them! Errors can be Operational and Programmer errors.

Operational Errors

Operational errors represent runtime problems. These errors are expected in the Node.js runtime and should be dealt with in a proper way. This does not mean the application itself has bugs. It means they need to be handled properly. Here’s a list of common operational errors:

• failed to connect to server
• failed to resolve hostname
• invalid user input
• request timeout
• server returned a 500 response
• socket hang-up
• system is out of memory

Programmer Errors

Programmer errors are what we call bugs. They represent issues in the code itself. Here’s a common one for Node.js, when you try reading a property of an undefined object. It’s a classic case of programmer error. Here are a few more:

• called an asynchronous function without a callback
• did not resolve a promise
• did not catch a rejected promise
• passed a string where an object was expected
• passed an object where a string was expected
• passed incorrect parameters in a function

Now you understand what types of errors you’ll be facing, and how they are different. Operational errors are part of the runtime and application while programmer errors are bugs you introduce in your codebase.

Now you’re thinking, why do we divide them into two categories? It’s simple really.

Do you want to restart your app if there’s a user not found error? Absolutely not. Other users are still enjoying your app. This is an example of an operational error.

What about failing to catch a rejected promise? Does it make sense to keep the app running even when a bug threatens your app? No! Restart it.

What Is an Error Object?

The error object is a built-in object in the Node.js runtime. It gives you a set of info about an error when it happens. The Node.js docs have a more in-depth explanation.

A basic error looks like this:

const error = new Error("An error message")
console.log(error.stack)

It has an error.stack field that gives you a stack trace showing where the error came from. It also lists all functions that were called before the error occurred. The error.stack field is optimal to use while debugging as it prints the error.message as well.

How Do You Handle Errors in Node.js: Best Practices You Should Follow

From my experience, there are a few best practices that will make it easier to handle errors in Node.js.

You can handle errors in callbacks. There are some serious drawbacks to using callbacks because it creates a nested “callback hell”. It’s notoriously hard to debug and fix errors if you need to look for them in nested functions.

A better way is to use async/await and try-catch statements, or .catch() errors in promises.

Let me show you what I mean.

1. Use Custom Errors to Handle Operational Errors

With the async/await pattern you can write code that looks synchronous, but actually is asynchronous.

const anAsyncTask = async () => {
 try {
 const user = await getUser()
 const cart = await getCart(user)

 return cart
 } catch (error) {
 console.error(error)
 } finally {
 await cleanUp()
 }
}

This pattern will clean up your code and avoid the dreaded callback hell.

You can use the built-in Error object in Node.js as I mentioned above, as it gives you detailed info about stack traces.

However, I also want to show you how to create custom Error objects with more meaningful properties like HTTP status codes and more detailed descriptions.

Here’s a file called baseError.js where you set the base for every custom error you’ll use.

// baseError.js

class BaseError extends Error {
 constructor (name, statusCode, isOperational, description) {
 super(description)

 Object.setPrototypeOf(this, new.target.prototype)
 this.name = name
 this.statusCode = statusCode
 this.isOperational = isOperational
 Error.captureStackTrace(this)
 }
}

module.exports = BaseError

Also create an httpStatusCodes.js file to keep a map of all status codes you want to handle.

// httpStatusCodes.js

const httpStatusCodes = {
 OK: 200,
 BAD_REQUEST: 400,
 NOT_FOUND: 404,
 INTERNAL_SERVER: 500
}

module.exports = httpStatusCodes

Then, you can create an api404Error.js file, and extend the BaseError with a custom error for handling 404s.

// api404Error.js

const httpStatusCodes = require('./httpStatusCodes')
const BaseError = require('./baseError')

class Api404Error extends BaseError {
 constructor (
 name,
 statusCode = httpStatusCodes.NOT_FOUND,
 description = 'Not found.',
 isOperational = true
 ) {
 super(name, statusCode, isOperational, description)
 }
}

module.exports = Api404Error

How do you use it? Throw it in your code when you want to handle 404 errors.

const Api404Error = require('./api404Error')

...
const user = await User.getUserById(req.params.id)
if (user === null) {
 throw new Api404Error(`User with id: ${req.params.id} not found.`)
}
...

You can duplicate this code for any custom error, 500, 400, and any other you want to handle.

2. Use a Middleware

Once you have a set of custom errors, you can configure centralized error handling. You want to have a middleware that catches all errors. There you can decide what to do with them and where to send them if they need to notify you via an alert notification.

In your API routes you’ll end up using the next() function to forward errors to the error handler middleware.

Let me show you.

...
app.post('/user', async (req, res, next) => {
 try {
const newUser = User.create(req.body)
 } catch (error) {
 next(error)
 }
})
...

The next() function is a special function in Express.js middlewares that sends values down the middleware chain. At the bottom of your routes files you should have a .use() method that uses the error handler middleware function.

const { logError, returnError } = require('./errorHandler')

app.use(logError)
app.use(returnError)

The error handler middleware should have a few key parts. You should check if the error is operational, and decide which errors to send as alert notifications so you can debug them in more detail. Here’s what I suggest you add to your error handler.

function logError (err) {
 console.error(err)
}

function logErrorMiddleware (err, req, res, next) {
 logError(err)
 next(err)
}

function returnError (err, req, res, next) {
 res.status(err.statusCode || 500).send(err.message)
}

function isOperationalError(error) {
 if (error instanceof BaseError) {
 return error.isOperational
 }
 return false
}

module.exports = {
 logError,
 logErrorMiddleware,
 returnError,
 isOperationalError
}

3. Restart Your App Gracefully to Handle Programmer Errors

Everything I’ve explained so far has been related to operational errors. I’ve shown how to gracefully handle expected errors and how to send them down the middleware chain to a custom error handling middleware.

Let’s jump into programmer errors now. These errors can often cause issues in your apps like memory leaks and high CPU usage. The best thing to do is to crash the app and restart it gracefully by using the Node.js cluster mode or a tool like PM2. I wrote another article where I describe in detail how to detect Node.js memory leaks using various solutions.

4. Catch All Uncaught Exceptions

When unexpected errors like these happen, you want to handle it immediately by sending a notification and restarting the app to avoid unexpected behavior.

const { logError, isOperationalError } = require('./errorHandler')

...
process.on('uncaughtException', error => {
 logError(error)

 if (!isOperationalError(error)) {
 process.exit(1)
 }
})
...

5. Catch All Unhandled Promise Rejections

Promise rejections in Node.js only cause warnings. You want them to throw errors, so you can handle them properly.

It’s good practice to use fallback and subscribe to:

process.on('unhandledRejection', callback)

This lets you throw an error properly.

Here’s what the error handling flow should look like.

...
const user = User.getUserById(req.params.id)
 .then(user => user)
 // missing a .catch() block
...

// if the Promise is rejected this will catch it
process.on('unhandledRejection', error => {
 throw error
})

process.on('uncaughtException', error => {
 logError(error)

 if (!isOperationalError(error)) {
 process.exit(1)
 }
})

6. Use a Centralized Location for Logs and Error Alerting

I recently wrote a detailed tutorial about Node.js logging best practices you should check out.

The gist of it is to use structured logging to print errors in a formatted way and send them for safekeeping to a central location, like Sematext Logs, our log management tool.

It’ll help with your sanity and persist the logs over time, so you can go back and troubleshoot issues whenever things break.

To do this, you should use loggers like winston and morgan. Additionally, you can add winston-logsene to send the logs to Sematext right away.

First, create a setup for winston and winston-logsene. Create a loggers directory and a logger.js file. Paste this into the file.

// logger.js

const winston = require('winston')
const Logsene = require('winston-logsene')

const options = {
 console: {
 level: 'debug',
 handleExceptions: true,
 json: false,
 colorize: true
 },
 logsene: {
 token: process.env.LOGS_TOKEN,
 level: 'debug',
 type: 'app_logs',
 url: 'https://logsene-receiver.sematext.com/_bulk'
 }
}

const logger = winston.createLogger({
 levels: winston.config.npm.levels,
 transports: [
 new winston.transports.Console(options.console),
 new Logsene(options.logsene)
 ],
 exitOnError: false
})

module.exports = logger

The good thing with this is that you get JSON formatted logs you can analyze to get more useful information about your app. You’ll also get all logs forwarded to Sematext. This will alert you whenever errors occur. That’s pretty awesome!

Furthermore, you should add an httpLogger.js file in the loggers directory and add morgan and morgan-json to print out access logs. Paste this into the httpLogger.js:

const morgan = require('morgan')
const json = require('morgan-json')
const format = json({
 method: ':method',
 url: ':url',
 status: ':status',
 contentLength: ':res[content-length]',
 responseTime: ':response-time'
})

const logger = require('./logger')
const httpLogger = morgan(format, {
 stream: {
 write: (message) => {
 const {
 method,
 url,
 status,
 contentLength,
 responseTime
 } = JSON.parse(message)

 logger.info('HTTP Access Log', {
 timestamp: new Date().toString(),
 method,
 url,
 status: Number(status),
 contentLength,
 responseTime: Number(responseTime)
 })
 }
 }
})

module.exports = httpLogger

In your app.js file you can now require both the logger.js and httpLogger.js, and use the logger instead of console.log().

// app.js

const logger = require('./loggers/logger')
const httpLogger = require('./loggers/httpLogger')
...

app.use(httpLogger)
...

In your errorHandler.js you can now replace all console.error() statements with logger.error() to persist the logs in Sematext.

// errorHandler.js

const logger = require('../loggers/logger')
const BaseError = require('./baseError')

function logError (err) {
 logger.error(err)
}

function logErrorMiddleware (err, req, res, next) {
 logError(err)
 next(err)
}

function returnError (err, req, res, next) {
 res.status(err.statusCode || 500).send(err.message)
}

function isOperationalError(error) {
 if (error instanceof BaseError) {
 return error.isOperational
 }
 return false
}

module.exports = {
 logError,
 logErrorMiddleware,
 returnError,
 isOperationalError
}

That’s it. You now know how to properly handle errors!

However, I do want to cover how to deliver errors. Should you be throwing them, passing errors in callback functions or promise rejections, or emit an “error” event via an EventEmitter.

How to Deliver Errors: Function Patterns

Let’s go over the four main ways to deliver an error in Node.js:

• throw the error (making it an exception).
• pass the error to a callback, a function provided specifically for handling errors and the results of asynchronous operations
• pass the error to a reject Promise function
• emit an “error” event on an EventEmitter

We’ve talked about how to handle errors, but when you’re writing a new function, how do you deliver errors to the code that called your function?

Throwing Errors

When you throw an error it unwinds the entire function call stack ignoring any functions you have on the stack. It gets delivered synchronously, in the same context where the function was called.

If you use a try-catch block you can handle the error gracefully. Otherwise, the app usually crashes, unless you have a fallback for catching Uncaught Exceptions as I explained above.

Here’s an example of throwing an error and handling it in a try-catch block:

const getUserWithAsyncAwait = async (id) => {
 try {
 const user = await getUser(id)
 if (!user) {
 throw new 404ApiError('No user found.')
 }

 return user
 } catch (error) {
 // handle the error
 logError(error)
 }
}

const user = await getUserWithAsyncAwait(1)

...

Using Callback

Callbacks are the most basic way of delivering an error asynchronously. The user passes you a function – the callback, and you invoke it sometime later when the asynchronous operation completes. The usual pattern is that the callback is invoked as callback(err, result), where only one of err and result is non-null, depending on whether the operation succeeded or failed.

Callbacks have been around for ages. It’s the oldest way of writing asynchronous JavaScript code. It’s also the oldest way of delivering errors asynchronously.

You pass a callback function as a parameter to the calling function, which you later invoke when the asynchronous function completes executing.

The usual pattern looks like this:

callback(err, result)

The first parameter in the callback is always the error.

Inside the callback function, you’ll then first check if the error exists and only if it’s a non-null value you continue executing the callback function.

function getUserWithCallback(id, callback) {
 getUser(id, function(user) {
 if (!user) {
 return callback(new 404ApiError('No user found.'))
 }

 callback(null, user)
 })
}

getUserWithCallback(1, function(err, user) {
 if (err) {
 // handle the error
 logError(error)
 }

 const user = user
 ...
})

Using Promises

Promises have replaced callbacks as the new and improved way of writing asynchronous code.

This pattern has become the new norm since Node.js version 8 that included async/await out of the box. Asynchronous code can be written to look like synchronous code. Catch errors can be done by using try-catch.

function getUserWithPromise(id) {
 return new Promise((resolve, reject) => {
 getUser(id, function(user) {
 if (!user) {
 return reject(new 404ApiError('No user found.'))
 }

 resolve(user)
 })
 })
}

getUserWithPromise(1)
 .then(user => {
 const user = user
 ...
 })
 .catch(err => {
 logError(error)
 })

Using EventEmitter

Ready for some more complicated use cases?

In some cases, you can’t rely on promise rejection or callbacks. What if you’re reading files from a stream. Or, fetching rows from a database and reading them as they arrive. A use case I see on a daily basis is streaming log lines and handling them as they’re coming in.

You can’t rely on one error because you need to listen for error events on the EventEmitter object.

In this case, instead of returning a Promise, your function would return an EventEmitter and emit row events for each result, an end event when all results have been reported, and an error event if any error is encountered.

Here’s a code sample from Logagent, an open-source log shipper I maintain. The socket value is an EventEmitter object.

net.createServer(socket => {
...

 socket
 .on('data', data => {
 ...

 })
 .on('end', result => {
 …

 })
 .on('error', console.error) // handle multiple errors
}

Throw, Callback, Promises, or EventEmitter: Which Pattern Is the Best?

Now, we’ve finally come to the verdict, when should you throw errors, and when do you use promise rejections or EventEmitters?

For operational errors, you should use Promise rejections or a try-catch block with async/await. You want to handle these errors asynchronously. It works well and is widely used.

If you have a more complicated case like I explained above, you should use an event emitter instead.

You want to explicitly throw errors if unwinding the whole call stack is needed. This can mean when handling programmer errors and you want the app to restart.

How to Write Functions for Efficient Error Handling

Whatever you do, choose one way to deliver operational errors. You can throw errors and deliver them synchronously, or asynchronously by using Promise rejections, passing them in callbacks, or emitting errors on an EventEmitter.

After setting up centralized error handling, the next logical step is to use a central location for your logs that also gives you error alerting.

Sematext Logs provides log management and error alerting to help analyze logs and debug and fix errors and exceptions. Definitely check it out and try it yourself. But you can also take a look at the lists where we compare the best log management tools, log analysis software, and cloud logging services available today.

Closing Thoughts

In this tutorial, I wanted to give you a way to handle the dreaded unhandledException and unhandledRejection errors in Node.js apps. I hope it was useful to you and that you’ll use what you learned today in your own apps.

Alongside this, I also explained a few best practices about error handling, like how to set up centralized error handling with middlewares and use a central location for your error logs. Don’t forget that logging frameworks like winston and morgan are crucial for this to work.

Lastly, I explained a few different ways of delivering errors, either with throw or with Promise .reject(), callback functions or the .on(‘error’) event on an EventEmitter.

I’ve tried to share all the knowledge I’ve gained over the last few years while maintaining open-source repos to keep you from making the same mistakes I’ve made in the past. Best of luck!

If you ever need alerting, error handling, and log management for your production apps, check us out.