<!--introduced_in=v4.0.0-->

- System errors triggered by underlying operating system constraints such

instances of, the standard JavaScript {Error} class and are guaranteed

to provide *at least* the properties available on that class.

handled depends entirely on the type of `Error` and the style of the API that is

are handled using the [`try…catch` construct][try-catch] 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.

Errors that occur within _Asynchronous APIs_ may be reported in multiple ways:

<!-- eslint-disable no-useless-return -->

```js

```js

`try…catch`. There is no comprehensive list of such methods; please

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`][domains] 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.

### Error-first callbacks

Most asynchronous methods exposed by the Node.js core API follow an idiomatic

function errorFirstCallback(err, data) {

}

```

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:

}

});

} catch (err) {

// This will not catch the throw!

console.error(err);

surrounding code (including the `try { } catch (err) { }` block will have

## Class: Error

### new Error(message)

* `message` {string}

(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

myObject.stack; // similar to `new Error().stack`

```

// Without passing MyError to captureStackTrace, the MyError

// frame would show up in the .stack property. By passing

// the constructor, we omit that frame, and retain all frames below it.

new MyError().stack;

```

### Error.stackTraceLimit

* {number}

### error.code

### error.message

* {string}

console.error(err.message);

// Prints: The message

```

### error.stack

* {string}

```txt

```

The location information will be one of:

System-level errors are generated as augmented `Error` instances, which are

detailed [here](#errors_system_errors).

## Class: RangeError

A subclass of `Error` that indicates that a provided argument was not within the

// throws "RangeError: "port" option should be >= 0 and < 65536: -1"

```

Node.js will generate and throw `RangeError` instances *immediately* as a form

of argument validation.

## Class: ReferenceError

// throws ReferenceError, doesNotExist is not a variable in this program.

```

## Class: SyntaxError

A subclass of `Error` that indicates that a program is not valid JavaScript.

`require`, or [vm][]. These errors are almost always indicative of a broken

} catch (err) {

## Class: TypeError