Node.js v12.16.3 Documentation

Table of Contents

• About this Documentation

  • Contributing
  • Stability Index
  • JSON Output
  • System calls and man pages

• Usage & Example

  • Usage
  • Example

• Assert

  • Strict assertion mode
  • Legacy assertion mode

  • Class: assert.AssertionError

    • new assert.AssertionError(options)
  • assert(value[, message])

  • assert.deepEqual(actual, expected[, message])

    • Comparison details

  • assert.deepStrictEqual(actual, expected[, message])

    • Comparison details
  • assert.doesNotMatch(string, regexp[, message])
  • assert.doesNotReject(asyncFn[, error][, message])
  • assert.doesNotThrow(fn[, error][, message])
  • assert.equal(actual, expected[, message])
  • assert.fail([message])
  • assert.fail(actual, expected[, message[, operator[, stackStartFn]]])
  • assert.ifError(value)
  • assert.match(string, regexp[, message])
  • assert.notDeepEqual(actual, expected[, message])
  • assert.notDeepStrictEqual(actual, expected[, message])
  • assert.notEqual(actual, expected[, message])
  • assert.notStrictEqual(actual, expected[, message])
  • assert.ok(value[, message])
  • assert.rejects(asyncFn[, error][, message])
  • assert.strictEqual(actual, expected[, message])
  • assert.throws(fn[, error][, message])

• Async Hooks

  • Terminology

  • Public API

    • Overview

      • async_hooks.createHook(callbacks)

        • Error Handling
        • Printing in AsyncHooks callbacks

    • Class: AsyncHook

      • asyncHook.enable()
      • asyncHook.disable()

      • Hook Callbacks

        • init(asyncId, type, triggerAsyncId, resource)

          • type
          • triggerAsyncId
          • resource
          • Asynchronous context example
        • before(asyncId)
        • after(asyncId)
        • destroy(asyncId)
        • promiseResolve(asyncId)
      • async_hooks.executionAsyncId()
      • async_hooks.triggerAsyncId()
  • Promise execution tracking

  • JavaScript Embedder API

    • Class: AsyncResource

      • new AsyncResource(type[, options])
      • asyncResource.runInAsyncScope(fn[, thisArg, ...args])
      • asyncResource.emitDestroy()
      • asyncResource.asyncId()
      • asyncResource.triggerAsyncId()
    • Using AsyncResource for a Worker thread pool

• Buffer

  • Buffers and Character Encodings
  • Buffers and TypedArrays
  • Buffers and iteration

  • Class: Buffer

    • Class Method: Buffer.alloc(size[, fill[, encoding]])
    • Class Method: Buffer.allocUnsafe(size)
    • Class Method: Buffer.allocUnsafeSlow(size)
    • Class Method: Buffer.byteLength(string[, encoding])
    • Class Method: Buffer.compare(buf1, buf2)
    • Class Method: Buffer.concat(list[, totalLength])
    • Class Method: Buffer.from(array)
    • Class Method: Buffer.from(arrayBuffer[, byteOffset[, length]])
    • Class Method: Buffer.from(buffer)
    • Class Method: Buffer.from(object[, offsetOrEncoding[, length]])
    • Class Method: Buffer.from(string[, encoding])
    • Class Method: Buffer.isBuffer(obj)
    • Class Method: Buffer.isEncoding(encoding)
    • Class Property: Buffer.poolSize
    • buf[index]
    • buf.buffer
    • buf.byteOffset
    • buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
    • buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
    • buf.entries()
    • buf.equals(otherBuffer)
    • buf.fill(value[, offset[, end]][, encoding])
    • buf.includes(value[, byteOffset][, encoding])
    • buf.indexOf(value[, byteOffset][, encoding])
    • buf.keys()
    • buf.lastIndexOf(value[, byteOffset][, encoding])
    • buf.length
    • buf.parent
    • buf.readBigInt64BE([offset])
    • buf.readBigInt64LE([offset])
    • buf.readBigUInt64BE([offset])
    • buf.readBigUInt64LE([offset])
    • buf.readDoubleBE([offset])
    • buf.readDoubleLE([offset])
    • buf.readFloatBE([offset])
    • buf.readFloatLE([offset])
    • buf.readInt8([offset])
    • buf.readInt16BE([offset])
    • buf.readInt16LE([offset])
    • buf.readInt32BE([offset])
    • buf.readInt32LE([offset])
    • buf.readIntBE(offset, byteLength)
    • buf.readIntLE(offset, byteLength)
    • buf.readUInt8([offset])
    • buf.readUInt16BE([offset])
    • buf.readUInt16LE([offset])
    • buf.readUInt32BE([offset])
    • buf.readUInt32LE([offset])
    • buf.readUIntBE(offset, byteLength)
    • buf.readUIntLE(offset, byteLength)
    • buf.subarray([start[, end]])
    • buf.slice([start[, end]])
    • buf.swap16()
    • buf.swap32()
    • buf.swap64()
    • buf.toJSON()
    • buf.toString([encoding[, start[, end]]])
    • buf.values()
    • buf.write(string[, offset[, length]][, encoding])
    • buf.writeBigInt64BE(value[, offset])
    • buf.writeBigInt64LE(value[, offset])
    • buf.writeBigUInt64BE(value[, offset])
    • buf.writeBigUInt64LE(value[, offset])
    • buf.writeDoubleBE(value[, offset])
    • buf.writeDoubleLE(value[, offset])
    • buf.writeFloatBE(value[, offset])
    • buf.writeFloatLE(value[, offset])
    • buf.writeInt8(value[, offset])
    • buf.writeInt16BE(value[, offset])
    • buf.writeInt16LE(value[, offset])
    • buf.writeInt32BE(value[, offset])
    • buf.writeInt32LE(value[, offset])
    • buf.writeIntBE(value, offset, byteLength)
    • buf.writeIntLE(value, offset, byteLength)
    • buf.writeUInt8(value[, offset])
    • buf.writeUInt16BE(value[, offset])
    • buf.writeUInt16LE(value[, offset])
    • buf.writeUInt32BE(value[, offset])
    • buf.writeUInt32LE(value[, offset])
    • buf.writeUIntBE(value, offset, byteLength)
    • buf.writeUIntLE(value, offset, byteLength)
    • new Buffer(array)
    • new Buffer(arrayBuffer[, byteOffset[, length]])
    • new Buffer(buffer)
    • new Buffer(size)
    • new Buffer(string[, encoding])
  • buffer.INSPECT_MAX_BYTES
  • buffer.kMaxLength
  • buffer.transcode(source, fromEnc, toEnc)

  • Class: SlowBuffer

    • new SlowBuffer(size)

  • Buffer Constants

    • buffer.constants.MAX_LENGTH
    • buffer.constants.MAX_STRING_LENGTH

  • Buffer.from(), Buffer.alloc(), and Buffer.allocUnsafe()

    • The --zero-fill-buffers command line option
    • What makes Buffer.allocUnsafe() and Buffer.allocUnsafeSlow() "unsafe"?

• C++ Addons

  • Hello world

    • Context-aware addons

      • Worker support
    • Building
    • Linking to libraries included with Node.js
    • Loading Addons using require()
  • Native Abstractions for Node.js
  • N-API

  • Addon examples

    • Function arguments
    • Callbacks
    • Object factory
    • Function factory
    • Wrapping C++ objects
    • Factory of wrapped objects
    • Passing wrapped objects around

• N-API

  • Implications of ABI Stability

  • Building

    • Build tools

      • node-gyp
      • CMake.js

    • Uploading precompiled binaries

      • node-pre-gyp
      • prebuild
      • prebuildify
  • Usage
  • N-API Version Matrix

  • Environment Life Cycle APIs

    • napi_set_instance_data
    • napi_get_instance_data

  • Basic N-API Data Types

    • napi_status
    • napi_extended_error_info
    • napi_env
    • napi_value
    • napi_threadsafe_function
    • napi_threadsafe_function_release_mode
    • napi_threadsafe_function_call_mode

    • N-API Memory Management types

      • napi_handle_scope
      • napi_escapable_handle_scope
      • napi_ref

    • N-API Callback types

      • napi_callback_info
      • napi_callback
      • napi_finalize
      • napi_async_execute_callback
      • napi_async_complete_callback
      • napi_threadsafe_function_call_js

  • Error Handling

    • Return values

      • napi_get_last_error_info

    • Exceptions

      • napi_throw
      • napi_throw_error
      • napi_throw_type_error
      • napi_throw_range_error
      • napi_is_error
      • napi_create_error
      • napi_create_type_error
      • napi_create_range_error
      • napi_get_and_clear_last_exception
      • napi_is_exception_pending
      • napi_fatal_exception

    • Fatal Errors

      • napi_fatal_error

  • Object Lifetime management

    • Making handle lifespan shorter than that of the native method

      • napi_open_handle_scope
      • napi_close_handle_scope
      • napi_open_escapable_handle_scope
      • napi_close_escapable_handle_scope
      • napi_escape_handle

    • References to objects with a lifespan longer than that of the native method

      • napi_create_reference
      • napi_delete_reference
      • napi_reference_ref
      • napi_reference_unref
      • napi_get_reference_value

    • Cleanup on exit of the current Node.js instance

      • napi_add_env_cleanup_hook
      • napi_remove_env_cleanup_hook
  • Module registration

  • Working with JavaScript Values

    • Enum types

      • napi_valuetype
      • napi_typedarray_type

    • Object Creation Functions

      • napi_create_array
      • napi_create_array_with_length
      • napi_create_arraybuffer
      • napi_create_buffer
      • napi_create_buffer_copy
      • napi_create_date
      • napi_create_external
      • napi_create_external_arraybuffer
      • napi_create_external_buffer
      • napi_create_object
      • napi_create_symbol
      • napi_create_typedarray
      • napi_create_dataview

    • Functions to convert from C types to N-API

      • napi_create_int32
      • napi_create_uint32
      • napi_create_int64
      • napi_create_double
      • napi_create_bigint_int64
      • napi_create_bigint_uint64
      • napi_create_bigint_words
      • napi_create_string_latin1
      • napi_create_string_utf16
      • napi_create_string_utf8

    • Functions to convert from N-API to C types

      • napi_get_array_length
      • napi_get_arraybuffer_info
      • napi_get_buffer_info
      • napi_get_prototype
      • napi_get_typedarray_info
      • napi_get_dataview_info
      • napi_get_date_value
      • napi_get_value_bool
      • napi_get_value_double
      • napi_get_value_bigint_int64
      • napi_get_value_bigint_uint64
      • napi_get_value_bigint_words
      • napi_get_value_external
      • napi_get_value_int32
      • napi_get_value_int64
      • napi_get_value_string_latin1
      • napi_get_value_string_utf8
      • napi_get_value_string_utf16
      • napi_get_value_uint32

    • Functions to get global instances

      • napi_get_boolean
      • napi_get_global
      • napi_get_null
      • napi_get_undefined

  • Working with JavaScript Values and Abstract Operations

    • napi_coerce_to_bool
    • napi_coerce_to_number
    • napi_coerce_to_object
    • napi_coerce_to_string
    • napi_typeof
    • napi_instanceof
    • napi_is_array
    • napi_is_arraybuffer
    • napi_is_buffer
    • napi_is_date
    • napi_is_error
    • napi_is_typedarray
    • napi_is_dataview
    • napi_strict_equals
    • napi_detach_arraybuffer
    • napi_is_detached_arraybuffer

  • Working with JavaScript Properties

    • Structures

      • napi_property_attributes
      • napi_property_descriptor

    • Functions

      • napi_get_property_names
      • napi_set_property
      • napi_get_property
      • napi_has_property
      • napi_delete_property
      • napi_has_own_property
      • napi_set_named_property
      • napi_get_named_property
      • napi_has_named_property
      • napi_set_element
      • napi_get_element
      • napi_has_element
      • napi_delete_element
      • napi_define_properties

  • Working with JavaScript Functions

    • napi_call_function
    • napi_create_function
    • napi_get_cb_info
    • napi_get_new_target
    • napi_new_instance

  • Object Wrap

    • napi_define_class
    • napi_wrap
    • napi_unwrap
    • napi_remove_wrap
    • napi_add_finalizer

  • Simple Asynchronous Operations

    • napi_create_async_work
    • napi_delete_async_work
    • napi_queue_async_work
    • napi_cancel_async_work

  • Custom Asynchronous Operations

    • napi_async_init
    • napi_async_destroy
    • napi_make_callback
    • napi_open_callback_scope
    • napi_close_callback_scope

  • Version Management

    • napi_get_node_version
    • napi_get_version

  • Memory Management

    • napi_adjust_external_memory

  • Promises

    • napi_create_promise
    • napi_resolve_deferred
    • napi_reject_deferred
    • napi_is_promise

  • Script execution

    • napi_run_script

  • libuv event loop

    • napi_get_uv_event_loop

  • Asynchronous Thread-safe Function Calls

    • napi_create_threadsafe_function
    • napi_get_threadsafe_function_context
    • napi_call_threadsafe_function
    • napi_acquire_threadsafe_function
    • napi_release_threadsafe_function
    • napi_ref_threadsafe_function
    • napi_unref_threadsafe_function

• Child Process

  • Asynchronous Process Creation

    • Spawning .bat and .cmd files on Windows
    • child_process.exec(command[, options][, callback])
    • child_process.execFile(file[, args][, options][, callback])
    • child_process.fork(modulePath[, args][, options])

    • child_process.spawn(command[, args][, options])

      • options.detached
      • options.stdio

  • Synchronous Process Creation

    • child_process.execFileSync(file[, args][, options])
    • child_process.execSync(command[, options])
    • child_process.spawnSync(command[, args][, options])

  • Class: ChildProcess

    • Event: 'close'
    • Event: 'disconnect'
    • Event: 'error'
    • Event: 'exit'
    • Event: 'message'
    • subprocess.channel
    • subprocess.connected
    • subprocess.disconnect()
    • subprocess.exitCode
    • subprocess.kill([signal])
    • subprocess.killed
    • subprocess.pid
    • subprocess.ref()

    • subprocess.send(message[, sendHandle[, options]][, callback])

      • Example: sending a server object
      • Example: sending a socket object
    • subprocess.signalCode
    • subprocess.spawnargs
    • subprocess.spawnfile
    • subprocess.stderr
    • subprocess.stdin
    • subprocess.stdio
    • subprocess.stdout
    • subprocess.unref()
  • maxBuffer and Unicode
  • Shell Requirements
  • Default Windows Shell
  • Advanced Serialization

• Cluster

  • How It Works

  • Class: Worker

    • Event: 'disconnect'
    • Event: 'error'
    • Event: 'exit'
    • Event: 'listening'
    • Event: 'message'
    • Event: 'online'
    • worker.disconnect()
    • worker.exitedAfterDisconnect
    • worker.id
    • worker.isConnected()
    • worker.isDead()
    • worker.kill([signal='SIGTERM'])
    • worker.process
    • worker.send(message[, sendHandle[, options]][, callback])
  • Event: 'disconnect'
  • Event: 'exit'
  • Event: 'fork'
  • Event: 'listening'
  • Event: 'message'
  • Event: 'online'
  • Event: 'setup'
  • cluster.disconnect([callback])
  • cluster.fork([env])
  • cluster.isMaster
  • cluster.isWorker
  • cluster.schedulingPolicy
  • cluster.settings
  • cluster.setupMaster([settings])
  • cluster.worker
  • cluster.workers

• Command Line Options

  • Synopsis

  • Options

    • -
    • --
    • --abort-on-uncaught-exception
    • --completion-bash
    • --cpu-prof
    • --cpu-prof-dir
    • --cpu-prof-interval
    • --cpu-prof-name
    • --disallow-code-generation-from-strings
    • --enable-fips
    • --enable-source-maps
    • --experimental-import-meta-resolve
    • --experimental-json-modules
    • --experimental-loader=module
    • --experimental-modules
    • --experimental-policy
    • --experimental-repl-await
    • --experimental-report
    • --experimental-specifier-resolution=mode
    • --experimental-vm-modules
    • --experimental-wasi-unstable-preview1
    • --experimental-wasm-modules
    • --force-fips
    • --frozen-intrinsics
    • --heapsnapshot-signal=signal
    • --heap-prof
    • --heap-prof-dir
    • --heap-prof-interval
    • --heap-prof-name
    • --http-parser=library
    • --http-server-default-timeout=milliseconds
    • --icu-data-dir=file
    • --input-type=type
    • --inspect-brk[=[host:]port]
    • --inspect-port=[host:]port

    • --inspect[=[host:]port]

      • Warning: binding inspector to a public IP:port combination is insecure
    • --inspect-publish-uid=stderr,http
    • --insecure-http-parser
    • --jitless
    • --max-http-header-size=size
    • --napi-modules
    • --no-deprecation
    • --no-force-async-hooks-checks
    • --no-warnings
    • --force-context-aware
    • --openssl-config=file
    • --pending-deprecation
    • --policy-integrity=sri
    • --preserve-symlinks
    • --preserve-symlinks-main
    • --prof
    • --prof-process
    • --redirect-warnings=file
    • --report-directory=directory
    • --report-filename=filename
    • --report-on-fatalerror
    • --report-on-signal
    • --report-signal=signal
    • --report-uncaught-exception
    • --throw-deprecation
    • --title=title
    • --tls-cipher-list=list
    • --tls-keylog=file
    • --tls-max-v1.2
    • --tls-max-v1.3
    • --tls-min-v1.0
    • --tls-min-v1.1
    • --tls-min-v1.2
    • --tls-min-v1.3
    • --trace-deprecation
    • --trace-event-categories
    • --trace-event-file-pattern
    • --trace-events-enabled
    • --trace-exit
    • --trace-sync-io
    • --trace-tls
    • --trace-uncaught
    • --trace-warnings
    • --track-heap-objects
    • --unhandled-rejections=mode
    • --use-bundled-ca, --use-openssl-ca
    • --v8-options
    • --v8-pool-size=num
    • --zero-fill-buffers
    • -c, --check
    • -e, --eval "script"
    • -h, --help
    • -i, --interactive
    • -p, --print "script"
    • -r, --require module
    • -v, --version

  • Environment Variables

    • NODE_DEBUG=module[,…]
    • NODE_DEBUG_NATIVE=module[,…]
    • NODE_DISABLE_COLORS=1
    • NODE_EXTRA_CA_CERTS=file
    • NODE_ICU_DATA=file
    • NODE_NO_WARNINGS=1
    • NODE_OPTIONS=options...
    • NODE_PATH=path[:…]
    • NODE_PENDING_DEPRECATION=1
    • NODE_PENDING_PIPE_INSTANCES=instances
    • NODE_PRESERVE_SYMLINKS=1
    • NODE_REDIRECT_WARNINGS=file
    • NODE_REPL_HISTORY=file
    • NODE_REPL_EXTERNAL_MODULE=file
    • NODE_TLS_REJECT_UNAUTHORIZED=value

    • NODE_V8_COVERAGE=dir

      • Coverage Output
      • Source Map Cache
    • OPENSSL_CONF=file
    • SSL_CERT_DIR=dir
    • SSL_CERT_FILE=file
    • UV_THREADPOOL_SIZE=size

  • Useful V8 options

    • --max-old-space-size=SIZE (in Mbytes)

• Console

  • Class: Console

    • new Console(stdout[, stderr][, ignoreErrors])
    • new Console(options)
    • console.assert(value[, ...message])
    • console.clear()
    • console.count([label])
    • console.countReset([label])
    • console.debug(data[, ...args])
    • console.dir(obj[, options])
    • console.dirxml(...data)
    • console.error([data][, ...args])
    • console.group([...label])
    • console.groupCollapsed()
    • console.groupEnd()
    • console.info([data][, ...args])
    • console.log([data][, ...args])
    • console.table(tabularData[, properties])
    • console.time([label])
    • console.timeEnd([label])
    • console.timeLog([label][, ...data])
    • console.trace([message][, ...args])
    • console.warn([data][, ...args])

  • Inspector only methods

    • console.profile([label])
    • console.profileEnd([label])
    • console.timeStamp([label])

• Crypto

  • Determining if crypto support is unavailable

  • Class: Certificate

    • Certificate.exportChallenge(spkac)
    • Certificate.exportPublicKey(spkac[, encoding])
    • Certificate.verifySpkac(spkac)

    • Legacy API

      • new crypto.Certificate()
      • certificate.exportChallenge(spkac)
      • certificate.exportPublicKey(spkac)
      • certificate.verifySpkac(spkac)

  • Class: Cipher

    • cipher.final([outputEncoding])
    • cipher.setAAD(buffer[, options])
    • cipher.getAuthTag()
    • cipher.setAutoPadding([autoPadding])
    • cipher.update(data[, inputEncoding][, outputEncoding])

  • Class: Decipher

    • decipher.final([outputEncoding])
    • decipher.setAAD(buffer[, options])
    • decipher.setAuthTag(buffer)
    • decipher.setAutoPadding([autoPadding])
    • decipher.update(data[, inputEncoding][, outputEncoding])

  • Class: DiffieHellman

    • diffieHellman.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])
    • diffieHellman.generateKeys([encoding])
    • diffieHellman.getGenerator([encoding])
    • diffieHellman.getPrime([encoding])
    • diffieHellman.getPrivateKey([encoding])
    • diffieHellman.getPublicKey([encoding])
    • diffieHellman.setPrivateKey(privateKey[, encoding])
    • diffieHellman.setPublicKey(publicKey[, encoding])
    • diffieHellman.verifyError
  • Class: DiffieHellmanGroup

  • Class: ECDH

    • Class Method: ECDH.convertKey(key, curve[, inputEncoding[, outputEncoding[, format]]])
    • ecdh.computeSecret(otherPublicKey[, inputEncoding][, outputEncoding])
    • ecdh.generateKeys([encoding[, format]])
    • ecdh.getPrivateKey([encoding])
    • ecdh.getPublicKey([encoding][, format])
    • ecdh.setPrivateKey(privateKey[, encoding])
    • ecdh.setPublicKey(publicKey[, encoding])

  • Class: Hash

    • hash.copy([options])
    • hash.digest([encoding])
    • hash.update(data[, inputEncoding])

  • Class: Hmac

    • hmac.digest([encoding])
    • hmac.update(data[, inputEncoding])

  • Class: KeyObject

    • keyObject.asymmetricKeyType
    • keyObject.export([options])
    • keyObject.symmetricKeySize
    • keyObject.type

  • Class: Sign

    • sign.sign(privateKey[, outputEncoding])
    • sign.update(data[, inputEncoding])

  • Class: Verify

    • verify.update(data[, inputEncoding])
    • verify.verify(object, signature[, signatureEncoding])

  • crypto module methods and properties

    • crypto.constants
    • crypto.DEFAULT_ENCODING
    • crypto.fips
    • crypto.createCipher(algorithm, password[, options])
    • crypto.createCipheriv(algorithm, key, iv[, options])
    • crypto.createDecipher(algorithm, password[, options])
    • crypto.createDecipheriv(algorithm, key, iv[, options])
    • crypto.createDiffieHellman(prime[, primeEncoding][, generator][, generatorEncoding])
    • crypto.createDiffieHellman(primeLength[, generator])
    • crypto.createDiffieHellmanGroup(name)
    • crypto.createECDH(curveName)
    • crypto.createHash(algorithm[, options])
    • crypto.createHmac(algorithm, key[, options])
    • crypto.createPrivateKey(key)
    • crypto.createPublicKey(key)
    • crypto.createSecretKey(key)
    • crypto.createSign(algorithm[, options])
    • crypto.createVerify(algorithm[, options])
    • crypto.generateKeyPair(type, options, callback)
    • crypto.generateKeyPairSync(type, options)
    • crypto.getCiphers()
    • crypto.getCurves()
    • crypto.getDiffieHellman(groupName)
    • crypto.getFips()
    • crypto.getHashes()
    • crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)
    • crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)
    • crypto.privateDecrypt(privateKey, buffer)
    • crypto.privateEncrypt(privateKey, buffer)
    • crypto.publicDecrypt(key, buffer)
    • crypto.publicEncrypt(key, buffer)
    • crypto.randomBytes(size[, callback])
    • crypto.randomFillSync(buffer[, offset][, size])
    • crypto.randomFill(buffer[, offset][, size], callback)
    • crypto.scrypt(password, salt, keylen[, options], callback)
    • crypto.scryptSync(password, salt, keylen[, options])
    • crypto.setEngine(engine[, flags])
    • crypto.setFips(bool)
    • crypto.sign(algorithm, data, key)
    • crypto.timingSafeEqual(a, b)
    • crypto.verify(algorithm, data, key, signature)

  • Notes

    • Legacy Streams API (pre Node.js v0.10)
    • Recent ECDH Changes
    • Support for weak or compromised algorithms
    • CCM mode

  • Crypto Constants

    • OpenSSL Options
    • OpenSSL Engine Constants
    • Other OpenSSL Constants
    • Node.js Crypto Constants

• Debugger

  • Watchers

  • Command reference

    • Stepping
    • Breakpoints
    • Information
    • Execution control
    • Various

  • Advanced Usage

    • V8 Inspector Integration for Node.js

• Deprecated APIs

  • Revoking deprecations

  • List of Deprecated APIs

    • DEP0001: http.OutgoingMessage.prototype.flush
    • DEP0002: require('_linklist')
    • DEP0003: _writableState.buffer
    • DEP0004: CryptoStream.prototype.readyState
    • DEP0005: Buffer() constructor
    • DEP0006: child_process options.customFds
    • DEP0007: Replace cluster worker.suicide with worker.exitedAfterDisconnect
    • DEP0008: require('constants')
    • DEP0009: crypto.pbkdf2 without digest
    • DEP0010: crypto.createCredentials
    • DEP0011: crypto.Credentials
    • DEP0012: Domain.dispose
    • DEP0013: fs asynchronous function without callback
    • DEP0014: fs.read legacy String interface
    • DEP0015: fs.readSync legacy String interface
    • DEP0016: GLOBAL/root
    • DEP0017: Intl.v8BreakIterator
    • DEP0018: Unhandled promise rejections
    • DEP0019: require('.') resolved outside directory
    • DEP0020: Server.connections
    • DEP0021: Server.listenFD
    • DEP0022: os.tmpDir()
    • DEP0023: os.getNetworkInterfaces()
    • DEP0024: REPLServer.prototype.convertToContext()
    • DEP0025: require('sys')
    • DEP0026: util.print()
    • DEP0027: util.puts()
    • DEP0028: util.debug()
    • DEP0029: util.error()
    • DEP0030: SlowBuffer
    • DEP0031: ecdh.setPublicKey()
    • DEP0032: domain module
    • DEP0033: EventEmitter.listenerCount()
    • DEP0034: fs.exists(path, callback)
    • DEP0035: fs.lchmod(path, mode, callback)
    • DEP0036: fs.lchmodSync(path, mode)
    • DEP0037: fs.lchown(path, uid, gid, callback)
    • DEP0038: fs.lchownSync(path, uid, gid)
    • DEP0039: require.extensions
    • DEP0040: punycode module
    • DEP0041: NODE_REPL_HISTORY_FILE environment variable
    • DEP0042: tls.CryptoStream
    • DEP0043: tls.SecurePair
    • DEP0044: util.isArray()
    • DEP0045: util.isBoolean()
    • DEP0046: util.isBuffer()
    • DEP0047: util.isDate()
    • DEP0048: util.isError()
    • DEP0049: util.isFunction()
    • DEP0050: util.isNull()
    • DEP0051: util.isNullOrUndefined()
    • DEP0052: util.isNumber()
    • DEP0053 util.isObject()
    • DEP0054: util.isPrimitive()
    • DEP0055: util.isRegExp()
    • DEP0056: util.isString()
    • DEP0057: util.isSymbol()
    • DEP0058: util.isUndefined()
    • DEP0059: util.log()
    • DEP0060: util._extend()
    • DEP0061: fs.SyncWriteStream
    • DEP0062: node --debug
    • DEP0063: ServerResponse.prototype.writeHeader()
    • DEP0064: tls.createSecurePair()
    • DEP0065: repl.REPL_MODE_MAGIC and NODE_REPL_MODE=magic
    • DEP0066: OutgoingMessage.prototype._headers, OutgoingMessage.prototype._headerNames
    • DEP0067: OutgoingMessage.prototype._renderHeaders
    • DEP0068: node debug
    • DEP0069: vm.runInDebugContext(string)
    • DEP0070: async_hooks.currentId()
    • DEP0071: async_hooks.triggerId()
    • DEP0072: async_hooks.AsyncResource.triggerId()
    • DEP0073: Several internal properties of net.Server
    • DEP0074: REPLServer.bufferedCommand
    • DEP0075: REPLServer.parseREPLKeyword()
    • DEP0076: tls.parseCertString()
    • DEP0077: Module._debug()
    • DEP0078: REPLServer.turnOffEditorMode()
    • DEP0079: Custom inspection function on Objects via .inspect()
    • DEP0080: path._makeLong()
    • DEP0081: fs.truncate() using a file descriptor
    • DEP0082: REPLServer.prototype.memory()
    • DEP0083: Disabling ECDH by setting ecdhCurve to false
    • DEP0084: requiring bundled internal dependencies
    • DEP0085: AsyncHooks Sensitive API
    • DEP0086: Remove runInAsyncIdScope
    • DEP0089: require('assert')
    • DEP0090: Invalid GCM authentication tag lengths
    • DEP0091: crypto.DEFAULT_ENCODING
    • DEP0092: Top-level this bound to module.exports
    • DEP0093: crypto.fips is deprecated and replaced.
    • DEP0094: Using assert.fail() with more than one argument.
    • DEP0095: timers.enroll()
    • DEP0096: timers.unenroll()
    • DEP0097: MakeCallback with domain property
    • DEP0098: AsyncHooks Embedder AsyncResource.emitBefore and AsyncResource.emitAfter APIs
    • DEP0099: async context-unaware node::MakeCallback C++ APIs
    • DEP0100: process.assert()
    • DEP0101: --with-lttng
    • DEP0102: Using noAssert in Buffer#(read|write) operations.
    • DEP0103: process.binding('util').is[...] typechecks
    • DEP0104: process.env string coercion
    • DEP0105: decipher.finaltol
    • DEP0106: crypto.createCipher and crypto.createDecipher
    • DEP0107: tls.convertNPNProtocols()
    • DEP0108: zlib.bytesRead
    • DEP0109: http, https, and tls support for invalid URLs
    • DEP0110: vm.Script cached data
    • DEP0111: process.binding()
    • DEP0112: dgram private APIs
    • DEP0113: Cipher.setAuthTag(), Decipher.getAuthTag()
    • DEP0114: crypto._toBuf()
    • DEP0115: crypto.prng(), crypto.pseudoRandomBytes(), crypto.rng()
    • DEP0116: Legacy URL API
    • DEP0117: Native crypto handles
    • DEP0118: dns.lookup() support for a falsy host name
    • DEP0119: process.binding('uv').errname() private API
    • DEP0120: Windows Performance Counter Support
    • DEP0121: net._setSimultaneousAccepts()
    • DEP0122: tls Server.prototype.setOptions()
    • DEP0123: setting the TLS ServerName to an IP address
    • DEP0124: using REPLServer.rli
    • DEP0125: require('_stream_wrap')
    • DEP0126: timers.active()
    • DEP0127: timers._unrefActive()
    • DEP0128: modules with an invalid main entry and an index.js file
    • DEP0129: ChildProcess._channel
    • DEP0130: Module.createRequireFromPath()
    • DEP0131: Legacy HTTP parser
    • DEP0132: worker.terminate() with callback
    • DEP0133: http connection
    • DEP0134: process._tickCallback
    • DEP0136: http finished

• DNS

  • Class: dns.Resolver

    • resolver.cancel()
  • dns.getServers()

  • dns.lookup(hostname[, options], callback)

    • Supported getaddrinfo flags
  • dns.lookupService(address, port, callback)
  • dns.resolve(hostname[, rrtype], callback)
  • dns.resolve4(hostname[, options], callback)
  • dns.resolve6(hostname[, options], callback)
  • dns.resolveAny(hostname, callback)
  • dns.resolveCname(hostname, callback)
  • dns.resolveMx(hostname, callback)
  • dns.resolveNaptr(hostname, callback)
  • dns.resolveNs(hostname, callback)
  • dns.resolvePtr(hostname, callback)
  • dns.resolveSoa(hostname, callback)
  • dns.resolveSrv(hostname, callback)
  • dns.resolveTxt(hostname, callback)
  • dns.reverse(ip, callback)
  • dns.setServers(servers)

  • DNS Promises API

    • Class: dnsPromises.Resolver
    • dnsPromises.getServers()
    • dnsPromises.lookup(hostname[, options])
    • dnsPromises.lookupService(address, port)
    • dnsPromises.resolve(hostname[, rrtype])
    • dnsPromises.resolve4(hostname[, options])
    • dnsPromises.resolve6(hostname[, options])
    • dnsPromises.resolveAny(hostname)
    • dnsPromises.resolveCname(hostname)
    • dnsPromises.resolveMx(hostname)
    • dnsPromises.resolveNaptr(hostname)
    • dnsPromises.resolveNs(hostname)
    • dnsPromises.resolvePtr(hostname)
    • dnsPromises.resolveSoa(hostname)
    • dnsPromises.resolveSrv(hostname)
    • dnsPromises.resolveTxt(hostname)
    • dnsPromises.reverse(ip)
    • dnsPromises.setServers(servers)
  • Error codes

  • Implementation considerations

    • dns.lookup()
    • dns.resolve(), dns.resolve*() and dns.reverse()

• Domain

  • Warning: Don't Ignore Errors!
  • Additions to Error objects
  • Implicit Binding
  • Explicit Binding
  • domain.create()

  • Class: Domain

    • domain.members
    • domain.add(emitter)
    • domain.bind(callback)
    • domain.enter()
    • domain.exit()
    • domain.intercept(callback)
    • domain.remove(emitter)
    • domain.run(fn[, ...args])
  • Domains and Promises

• ECMAScript Modules

  • Introduction

  • Enabling

    • package.json "type" field
    • Package Scope and File Extensions
    • --input-type flag

  • Packages

    • Package Entry Points

      • Main Entry Point Export
      • Subpath Exports
      • Package Exports Fallbacks
      • Exports Sugar
      • Conditional Exports
      • Nested conditions
      • Self-referencing a package using its name

    • Dual CommonJS/ES Module Packages

      • Dual Package Hazard

      • Writing Dual Packages While Avoiding or Minimizing Hazards

        • Approach #1: Use an ES Module Wrapper
        • Approach #2: Isolate State

  • import Specifiers

    • Terminology

      • data: Imports
  • import.meta

  • Differences Between ES Modules and CommonJS

    • Mandatory file extensions
    • No NODE_PATH
    • No require, exports, module.exports, __filename, __dirname
    • No require.resolve
    • No require.extensions
    • No require.cache
    • URL-based paths

  • Interoperability with CommonJS

    • require
    • import statements
    • import() expressions
  • CommonJS, JSON, and Native Modules
  • Builtin modules
  • Experimental JSON Modules
  • Experimental Wasm Modules

  • Experimental Loaders

    • Hooks

      • resolve hook
      • getFormat hook
      • getSource hook
      • transformSource hook
      • getGlobalPreloadCode hook
      • dynamicInstantiate hook

    • Examples

      • HTTPS loader
      • Transpiler loader

  • Resolution Algorithm

    • Features
    • Resolver Algorithm
    • Customizing ESM specifier resolution algorithm

• Errors

  • Error Propagation and Interception

    • Error-first callbacks

  • Class: Error

    • new Error(message)
    • Error.captureStackTrace(targetObject[, constructorOpt])
    • Error.stackTraceLimit
    • error.code
    • error.message
    • error.stack
  • Class: AssertionError
  • Class: RangeError
  • Class: ReferenceError
  • Class: SyntaxError

  • Class: SystemError

    • error.address
    • error.code
    • error.dest
    • error.errno
    • error.info
    • error.message
    • error.path
    • error.port
    • error.syscall
    • Common System Errors
  • Class: TypeError
  • Exceptions vs. Errors

  • OpenSSL Errors

    • error.opensslErrorStack
    • error.function
    • error.library
    • error.reason

  • Node.js Error Codes

    • ERR_AMBIGUOUS_ARGUMENT
    • ERR_ARG_NOT_ITERABLE
    • ERR_ASSERTION
    • ERR_ASYNC_CALLBACK
    • ERR_ASYNC_TYPE
    • ERR_BROTLI_COMPRESSION_FAILED
    • ERR_BROTLI_INVALID_PARAM
    • ERR_BUFFER_CONTEXT_NOT_AVAILABLE
    • ERR_BUFFER_OUT_OF_BOUNDS
    • ERR_BUFFER_TOO_LARGE
    • ERR_CANNOT_WATCH_SIGINT
    • ERR_CHILD_CLOSED_BEFORE_REPLY
    • ERR_CHILD_PROCESS_IPC_REQUIRED
    • ERR_CHILD_PROCESS_STDIO_MAXBUFFER
    • ERR_CONSOLE_WRITABLE_STREAM
    • ERR_CONSTRUCT_CALL_REQUIRED
    • ERR_CONSTRUCT_CALL_INVALID
    • ERR_CPU_USAGE
    • ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED
    • ERR_CRYPTO_ECDH_INVALID_FORMAT
    • ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY
    • ERR_CRYPTO_ENGINE_UNKNOWN
    • ERR_CRYPTO_FIPS_FORCED
    • ERR_CRYPTO_FIPS_UNAVAILABLE
    • ERR_CRYPTO_HASH_FINALIZED
    • ERR_CRYPTO_HASH_UPDATE_FAILED
    • ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS
    • ERR_CRYPTO_INVALID_DIGEST
    • ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE
    • ERR_CRYPTO_INVALID_STATE
    • ERR_CRYPTO_PBKDF2_ERROR
    • ERR_CRYPTO_SCRYPT_INVALID_PARAMETER
    • ERR_CRYPTO_SCRYPT_NOT_SUPPORTED
    • ERR_CRYPTO_SIGN_KEY_REQUIRED
    • ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH
    • ERR_DIR_CLOSED
    • ERR_DNS_SET_SERVERS_FAILED
    • ERR_DOMAIN_CALLBACK_NOT_AVAILABLE
    • ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE
    • ERR_ENCODING_INVALID_ENCODED_DATA
    • ERR_ENCODING_NOT_SUPPORTED
    • ERR_FALSY_VALUE_REJECTION
    • ERR_FS_FILE_TOO_LARGE
    • ERR_FS_INVALID_SYMLINK_TYPE
    • ERR_HTTP_HEADERS_SENT
    • ERR_HTTP_INVALID_HEADER_VALUE
    • ERR_HTTP_INVALID_STATUS_CODE
    • ERR_HTTP_TRAILER_INVALID
    • ERR_HTTP2_ALTSVC_INVALID_ORIGIN
    • ERR_HTTP2_ALTSVC_LENGTH
    • ERR_HTTP2_CONNECT_AUTHORITY
    • ERR_HTTP2_CONNECT_PATH
    • ERR_HTTP2_CONNECT_SCHEME
    • ERR_HTTP2_ERROR
    • ERR_HTTP2_GOAWAY_SESSION
    • ERR_HTTP2_HEADERS_AFTER_RESPOND
    • ERR_HTTP2_HEADERS_SENT
    • ERR_HTTP2_HEADER_SINGLE_VALUE
    • ERR_HTTP2_INFO_STATUS_NOT_ALLOWED
    • ERR_HTTP2_INVALID_CONNECTION_HEADERS
    • ERR_HTTP2_INVALID_HEADER_VALUE
    • ERR_HTTP2_INVALID_INFO_STATUS
    • ERR_HTTP2_INVALID_ORIGIN
    • ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH
    • ERR_HTTP2_INVALID_PSEUDOHEADER
    • ERR_HTTP2_INVALID_SESSION
    • ERR_HTTP2_INVALID_SETTING_VALUE
    • ERR_HTTP2_INVALID_STREAM
    • ERR_HTTP2_MAX_PENDING_SETTINGS_ACK
    • ERR_HTTP2_NESTED_PUSH
    • ERR_HTTP2_NO_SOCKET_MANIPULATION
    • ERR_HTTP2_ORIGIN_LENGTH
    • ERR_HTTP2_OUT_OF_STREAMS
    • ERR_HTTP2_PAYLOAD_FORBIDDEN
    • ERR_HTTP2_PING_CANCEL
    • ERR_HTTP2_PING_LENGTH
    • ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED
    • ERR_HTTP2_PUSH_DISABLED
    • ERR_HTTP2_SEND_FILE
    • ERR_HTTP2_SEND_FILE_NOSEEK
    • ERR_HTTP2_SESSION_ERROR
    • ERR_HTTP2_SETTINGS_CANCEL
    • ERR_HTTP2_SOCKET_BOUND
    • ERR_HTTP2_SOCKET_UNBOUND
    • ERR_HTTP2_STATUS_101
    • ERR_HTTP2_STATUS_INVALID
    • ERR_HTTP2_STREAM_CANCEL
    • ERR_HTTP2_STREAM_ERROR
    • ERR_HTTP2_STREAM_SELF_DEPENDENCY
    • ERR_HTTP2_TRAILERS_ALREADY_SENT
    • ERR_HTTP2_TRAILERS_NOT_READY
    • ERR_HTTP2_UNSUPPORTED_PROTOCOL
    • ERR_INTERNAL_ASSERTION
    • ERR_INCOMPATIBLE_OPTION_PAIR
    • ERR_INPUT_TYPE_NOT_ALLOWED
    • ERR_INSPECTOR_ALREADY_CONNECTED
    • ERR_INSPECTOR_CLOSED
    • ERR_INSPECTOR_COMMAND
    • ERR_INSPECTOR_NOT_ACTIVE
    • ERR_INSPECTOR_NOT_AVAILABLE
    • ERR_INSPECTOR_NOT_CONNECTED
    • ERR_INSPECTOR_NOT_WORKER
    • ERR_INVALID_ADDRESS_FAMILY
    • ERR_INVALID_ARG_TYPE
    • ERR_INVALID_ARG_VALUE
    • ERR_INVALID_ASYNC_ID
    • ERR_INVALID_BUFFER_SIZE
    • ERR_INVALID_CALLBACK
    • ERR_INVALID_CHAR
    • ERR_INVALID_CURSOR_POS
    • ERR_INVALID_FD
    • ERR_INVALID_FD_TYPE
    • ERR_INVALID_FILE_URL_HOST
    • ERR_INVALID_FILE_URL_PATH
    • ERR_INVALID_HANDLE_TYPE
    • ERR_INVALID_HTTP_TOKEN
    • ERR_INVALID_IP_ADDRESS
    • ERR_INVALID_MODULE_SPECIFIER
    • ERR_INVALID_OPT_VALUE
    • ERR_INVALID_OPT_VALUE_ENCODING
    • ERR_INVALID_PACKAGE_CONFIG
    • ERR_INVALID_PACKAGE_TARGET
    • ERR_INVALID_PERFORMANCE_MARK
    • ERR_INVALID_PROTOCOL
    • ERR_INVALID_REPL_EVAL_CONFIG
    • ERR_INVALID_REPL_INPUT
    • ERR_INVALID_RETURN_PROPERTY
    • ERR_INVALID_RETURN_PROPERTY_VALUE
    • ERR_INVALID_RETURN_VALUE
    • ERR_INVALID_SYNC_FORK_INPUT
    • ERR_INVALID_THIS
    • ERR_INVALID_TRANSFER_OBJECT
    • ERR_INVALID_TUPLE
    • ERR_INVALID_URI
    • ERR_INVALID_URL
    • ERR_INVALID_URL_SCHEME
    • ERR_IPC_CHANNEL_CLOSED
    • ERR_IPC_DISCONNECTED
    • ERR_IPC_ONE_PIPE
    • ERR_IPC_SYNC_FORK
    • ERR_MANIFEST_ASSERT_INTEGRITY
    • ERR_MANIFEST_DEPENDENCY_MISSING
    • ERR_MANIFEST_INTEGRITY_MISMATCH
    • ERR_MANIFEST_INVALID_RESOURCE_FIELD
    • ERR_MANIFEST_PARSE_POLICY
    • ERR_MANIFEST_TDZ
    • ERR_MANIFEST_UNKNOWN_ONERROR
    • ERR_MEMORY_ALLOCATION_FAILED
    • ERR_METHOD_NOT_IMPLEMENTED
    • ERR_MISSING_ARGS
    • ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK
    • ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST
    • ERR_MISSING_PASSPHRASE
    • ERR_MISSING_PLATFORM_FOR_WORKER
    • ERR_MODULE_NOT_FOUND
    • ERR_MULTIPLE_CALLBACK
    • ERR_NAPI_CONS_FUNCTION
    • ERR_NAPI_INVALID_DATAVIEW_ARGS
    • ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT
    • ERR_NAPI_INVALID_TYPEDARRAY_LENGTH
    • ERR_NAPI_TSFN_CALL_JS
    • ERR_NAPI_TSFN_GET_UNDEFINED
    • ERR_NAPI_TSFN_START_IDLE_LOOP
    • ERR_NAPI_TSFN_STOP_IDLE_LOOP
    • ERR_NO_CRYPTO
    • ERR_NO_ICU
    • ERR_NON_CONTEXT_AWARE_DISABLED
    • ERR_OUT_OF_RANGE
    • ERR_PACKAGE_PATH_NOT_EXPORTED
    • ERR_REQUIRE_ESM
    • ERR_SCRIPT_EXECUTION_INTERRUPTED
    • ERR_SCRIPT_EXECUTION_TIMEOUT
    • ERR_SERVER_ALREADY_LISTEN
    • ERR_SERVER_NOT_RUNNING
    • ERR_SOCKET_ALREADY_BOUND
    • ERR_SOCKET_BAD_BUFFER_SIZE
    • ERR_SOCKET_BAD_PORT
    • ERR_SOCKET_BAD_TYPE
    • ERR_SOCKET_BUFFER_SIZE
    • ERR_SOCKET_CANNOT_SEND
    • ERR_SOCKET_CLOSED
    • ERR_SOCKET_DGRAM_IS_CONNECTED
    • ERR_SOCKET_DGRAM_NOT_CONNECTED
    • ERR_SOCKET_DGRAM_NOT_RUNNING
    • ERR_SRI_PARSE
    • ERR_STREAM_CANNOT_PIPE
    • ERR_STREAM_DESTROYED
    • ERR_STREAM_NULL_VALUES
    • ERR_STREAM_PREMATURE_CLOSE
    • ERR_STREAM_PUSH_AFTER_EOF
    • ERR_STREAM_UNSHIFT_AFTER_END_EVENT
    • ERR_STREAM_WRAP
    • ERR_STREAM_WRITE_AFTER_END
    • ERR_STRING_TOO_LONG
    • ERR_SYNTHETIC
    • ERR_SYSTEM_ERROR
    • ERR_TLS_CERT_ALTNAME_INVALID
    • ERR_TLS_DH_PARAM_SIZE
    • ERR_TLS_HANDSHAKE_TIMEOUT
    • ERR_TLS_INVALID_CONTEXT
    • ERR_TLS_INVALID_PROTOCOL_METHOD
    • ERR_TLS_INVALID_PROTOCOL_VERSION
    • ERR_TLS_PROTOCOL_VERSION_CONFLICT
    • ERR_TLS_RENEGOTIATION_DISABLED
    • ERR_TLS_REQUIRED_SERVER_NAME
    • ERR_TLS_SESSION_ATTACK
    • ERR_TLS_SNI_FROM_SERVER
    • ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED
    • ERR_TRACE_EVENTS_CATEGORY_REQUIRED
    • ERR_TRACE_EVENTS_UNAVAILABLE
    • ERR_TRANSFERRING_EXTERNALIZED_SHAREDARRAYBUFFER
    • ERR_TRANSFORM_ALREADY_TRANSFORMING
    • ERR_TRANSFORM_WITH_LENGTH_0
    • ERR_TTY_INIT_FAILED
    • ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET
    • ERR_UNESCAPED_CHARACTERS
    • ERR_UNHANDLED_ERROR
    • ERR_UNKNOWN_BUILTIN_MODULE
    • ERR_UNKNOWN_CREDENTIAL
    • ERR_UNKNOWN_ENCODING
    • ERR_UNKNOWN_FILE_EXTENSION
    • ERR_UNKNOWN_MODULE_FORMAT
    • ERR_UNKNOWN_SIGNAL
    • ERR_UNSUPPORTED_ESM_URL_SCHEME
    • ERR_V8BREAKITERATOR
    • ERR_VALID_PERFORMANCE_ENTRY_TYPE
    • ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING
    • ERR_VM_MODULE_ALREADY_LINKED
    • ERR_VM_MODULE_DIFFERENT_CONTEXT
    • ERR_VM_MODULE_LINKING_ERRORED
    • ERR_VM_MODULE_NOT_MODULE
    • ERR_VM_MODULE_STATUS
    • ERR_WASI_ALREADY_STARTED
    • ERR_WORKER_INIT_FAILED
    • ERR_WORKER_INVALID_EXEC_ARGV
    • ERR_WORKER_OUT_OF_MEMORY
    • ERR_WORKER_PATH
    • ERR_WORKER_UNSERIALIZABLE_ERROR
    • ERR_WORKER_UNSUPPORTED_EXTENSION
    • ERR_WORKER_UNSUPPORTED_OPERATION
    • ERR_ZLIB_INITIALIZATION_FAILED
    • HPE_HEADER_OVERFLOW
    • MODULE_NOT_FOUND

  • Legacy Node.js Error Codes

    • ERR_CANNOT_TRANSFER_OBJECT
    • ERR_CLOSED_MESSAGE_PORT
    • ERR_CRYPTO_HASH_DIGEST_NO_UTF16
    • ERR_HTTP2_FRAME_ERROR
    • ERR_HTTP2_HEADERS_OBJECT
    • ERR_HTTP2_HEADER_REQUIRED
    • ERR_HTTP2_INFO_HEADERS_AFTER_RESPOND
    • ERR_HTTP2_STREAM_CLOSED
    • ERR_HTTP_INVALID_CHAR
    • ERR_INDEX_OUT_OF_RANGE
    • ERR_NAPI_CONS_PROTOTYPE_OBJECT
    • ERR_NO_LONGER_SUPPORTED
    • ERR_OUTOFMEMORY
    • ERR_PARSE_HISTORY_DATA
    • ERR_STDERR_CLOSE
    • ERR_STDOUT_CLOSE
    • ERR_STREAM_READ_NOT_IMPLEMENTED
    • ERR_TLS_RENEGOTIATION_FAILED
    • ERR_UNKNOWN_BUILTIN_MODULE
    • ERR_UNKNOWN_STDIN_TYPE
    • ERR_UNKNOWN_STREAM_TYPE
    • ERR_VALUE_OUT_OF_RANGE
    • ERR_VM_MODULE_NOT_LINKED
    • ERR_ZLIB_BINDING_CLOSED

    • Other error codes

      • ERR_ENTRY_TYPE_MISMATCH
      • ERR_FS_WATCHER_ALREADY_STARTED
      • ERR_FS_WATCHER_NOT_STARTED
      • ERR_HTTP2_ALREADY_SHUTDOWN
      • ERR_HTTP2_ERROR
      • ERR_INVALID_REPL_HISTORY
      • ERR_INVALID_REPL_TYPE
      • ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK
      • ERR_STREAM_HAS_STRINGDECODER
      • ERR_STRING_TOO_LARGE
      • ERR_TTY_WRITABLE_NOT_READABLE

• Events

  • Passing arguments and this to listeners
  • Asynchronous vs. Synchronous
  • Handling events only once
  • Error events
  • Capture Rejections of Promises

  • Class: EventEmitter

    • Event: 'newListener'
    • Event: 'removeListener'
    • EventEmitter.listenerCount(emitter, eventName)
    • EventEmitter.defaultMaxListeners
    • emitter.addListener(eventName, listener)
    • emitter.emit(eventName[, ...args])
    • emitter.eventNames()
    • emitter.getMaxListeners()
    • emitter.listenerCount(eventName)
    • emitter.listeners(eventName)
    • emitter.off(eventName, listener)
    • emitter.on(eventName, listener)
    • emitter.once(eventName, listener)
    • emitter.prependListener(eventName, listener)
    • emitter.prependOnceListener(eventName, listener)
    • emitter.removeAllListeners([eventName])
    • emitter.removeListener(eventName, listener)
    • emitter.setMaxListeners(n)
    • emitter.rawListeners(eventName)
    • emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])
  • events.once(emitter, name)
  • events.captureRejections
  • events.captureRejectionSymbol
  • events.on(emitter, eventName)

• File System

  • File paths

    • URL object support
  • File Descriptors
  • Threadpool Usage

  • Class fs.Dir

    • dir.close()
    • dir.close(callback)
    • dir.closeSync()
    • dir.path
    • dir.read()
    • dir.read(callback)
    • dir.readSync()
    • dir[Symbol.asyncIterator]()

  • Class: fs.Dirent

    • dirent.isBlockDevice()
    • dirent.isCharacterDevice()
    • dirent.isDirectory()
    • dirent.isFIFO()
    • dirent.isFile()
    • dirent.isSocket()
    • dirent.isSymbolicLink()
    • dirent.name

  • Class: fs.FSWatcher

    • Event: 'change'
    • Event: 'close'
    • Event: 'error'
    • watcher.close()

  • Class: fs.ReadStream

    • Event: 'close'
    • Event: 'open'
    • Event: 'ready'
    • readStream.bytesRead
    • readStream.path
    • readStream.pending

  • Class: fs.Stats

    • stats.isBlockDevice()
    • stats.isCharacterDevice()
    • stats.isDirectory()
    • stats.isFIFO()
    • stats.isFile()
    • stats.isSocket()
    • stats.isSymbolicLink()
    • stats.dev
    • stats.ino
    • stats.mode
    • stats.nlink
    • stats.uid
    • stats.gid
    • stats.rdev
    • stats.size
    • stats.blksize
    • stats.blocks
    • stats.atimeMs
    • stats.mtimeMs
    • stats.ctimeMs
    • stats.birthtimeMs
    • stats.atimeNs
    • stats.mtimeNs
    • stats.ctimeNs
    • stats.birthtimeNs
    • stats.atime
    • stats.mtime
    • stats.ctime
    • stats.birthtime
    • Stat Time Values

  • Class: fs.WriteStream

    • Event: 'close'
    • Event: 'open'
    • Event: 'ready'
    • writeStream.bytesWritten
    • writeStream.path
    • writeStream.pending
  • fs.access(path[, mode], callback)
  • fs.accessSync(path[, mode])
  • fs.appendFile(path, data[, options], callback)
  • fs.appendFileSync(path, data[, options])

  • fs.chmod(path, mode, callback)

    • File modes
  • fs.chmodSync(path, mode)
  • fs.chown(path, uid, gid, callback)
  • fs.chownSync(path, uid, gid)
  • fs.close(fd, callback)
  • fs.closeSync(fd)
  • fs.constants
  • fs.copyFile(src, dest[, flags], callback)
  • fs.copyFileSync(src, dest[, flags])
  • fs.createReadStream(path[, options])
  • fs.createWriteStream(path[, options])
  • fs.exists(path, callback)
  • fs.existsSync(path)
  • fs.fchmod(fd, mode, callback)
  • fs.fchmodSync(fd, mode)
  • fs.fchown(fd, uid, gid, callback)
  • fs.fchownSync(fd, uid, gid)
  • fs.fdatasync(fd, callback)
  • fs.fdatasyncSync(fd)
  • fs.fstat(fd[, options], callback)
  • fs.fstatSync(fd[, options])
  • fs.fsync(fd, callback)
  • fs.fsyncSync(fd)
  • fs.ftruncate(fd[, len], callback)
  • fs.ftruncateSync(fd[, len])
  • fs.futimes(fd, atime, mtime, callback)
  • fs.futimesSync(fd, atime, mtime)
  • fs.lchmod(path, mode, callback)
  • fs.lchmodSync(path, mode)
  • fs.lchown(path, uid, gid, callback)
  • fs.lchownSync(path, uid, gid)
  • fs.link(existingPath, newPath, callback)
  • fs.linkSync(existingPath, newPath)
  • fs.lstat(path[, options], callback)
  • fs.lstatSync(path[, options])
  • fs.mkdir(path[, options], callback)
  • fs.mkdirSync(path[, options])
  • fs.mkdtemp(prefix[, options], callback)
  • fs.mkdtempSync(prefix[, options])
  • fs.open(path[, flags[, mode]], callback)
  • fs.opendir(path[, options], callback)
  • fs.opendirSync(path[, options])
  • fs.openSync(path[, flags, mode])
  • fs.read(fd, buffer, offset, length, position, callback)
  • fs.readdir(path[, options], callback)
  • fs.readdirSync(path[, options])

  • fs.readFile(path[, options], callback)

    • File Descriptors
  • fs.readFileSync(path[, options])
  • fs.readlink(path[, options], callback)
  • fs.readlinkSync(path[, options])
  • fs.readSync(fd, buffer, offset, length, position)
  • fs.realpath(path[, options], callback)
  • fs.realpath.native(path[, options], callback)
  • fs.realpathSync(path[, options])
  • fs.realpathSync.native(path[, options])
  • fs.rename(oldPath, newPath, callback)
  • fs.renameSync(oldPath, newPath)
  • fs.rmdir(path[, options], callback)
  • fs.rmdirSync(path[, options])
  • fs.stat(path[, options], callback)
  • fs.statSync(path[, options])
  • fs.symlink(target, path[, type], callback)
  • fs.symlinkSync(target, path[, type])
  • fs.truncate(path[, len], callback)
  • fs.truncateSync(path[, len])
  • fs.unlink(path, callback)
  • fs.unlinkSync(path)
  • fs.unwatchFile(filename[, listener])
  • fs.utimes(path, atime, mtime, callback)
  • fs.utimesSync(path, atime, mtime)

  • fs.watch(filename[, options][, listener])

    • Caveats

      • Availability
      • Inodes
      • Filename Argument
  • fs.watchFile(filename[, options], listener)
  • fs.write(fd, buffer[, offset[, length[, position]]], callback)
  • fs.write(fd, string[, position[, encoding]], callback)

  • fs.writeFile(file, data[, options], callback)

    • Using fs.writeFile() with File Descriptors
  • fs.writeFileSync(file, data[, options])
  • fs.writeSync(fd, buffer[, offset[, length[, position]]])
  • fs.writeSync(fd, string[, position[, encoding]])
  • fs.writev(fd, buffers[, position], callback)
  • fs.writevSync(fd, buffers[, position])

  • fs Promises API

    • class: FileHandle

      • filehandle.appendFile(data, options)
      • filehandle.chmod(mode)
      • filehandle.chown(uid, gid)
      • filehandle.close()
      • filehandle.datasync()
      • filehandle.fd
      • filehandle.read(buffer, offset, length, position)
      • filehandle.readFile(options)
      • filehandle.stat([options])
      • filehandle.sync()
      • filehandle.truncate(len)
      • filehandle.utimes(atime, mtime)
      • filehandle.write(buffer[, offset[, length[, position]]])
      • filehandle.write(string[, position[, encoding]])
      • filehandle.writeFile(data, options)
      • filehandle.writev(buffers[, position])
    • fsPromises.access(path[, mode])
    • fsPromises.appendFile(path, data[, options])
    • fsPromises.chmod(path, mode)
    • fsPromises.chown(path, uid, gid)
    • fsPromises.copyFile(src, dest[, flags])
    • fsPromises.lchmod(path, mode)
    • fsPromises.lchown(path, uid, gid)
    • fsPromises.link(existingPath, newPath)
    • fsPromises.lstat(path[, options])
    • fsPromises.mkdir(path[, options])
    • fsPromises.mkdtemp(prefix[, options])
    • fsPromises.open(path, flags[, mode])
    • fsPromises.opendir(path[, options])
    • fsPromises.readdir(path[, options])
    • fsPromises.readFile(path[, options])
    • fsPromises.readlink(path[, options])
    • fsPromises.realpath(path[, options])
    • fsPromises.rename(oldPath, newPath)
    • fsPromises.rmdir(path[, options])
    • fsPromises.stat(path[, options])
    • fsPromises.symlink(target, path[, type])
    • fsPromises.truncate(path[, len])
    • fsPromises.unlink(path)
    • fsPromises.utimes(path, atime, mtime)
    • fsPromises.writeFile(file, data[, options])

  • FS Constants

    • File Access Constants
    • File Copy Constants
    • File Open Constants
    • File Type Constants
    • File Mode Constants
  • File System Flags

• Global Objects

  • Class: Buffer
  • __dirname
  • __filename
  • clearImmediate(immediateObject)
  • clearInterval(intervalObject)
  • clearTimeout(timeoutObject)
  • console
  • exports
  • global
  • module
  • process
  • queueMicrotask(callback)
  • require()
  • setImmediate(callback[, ...args])
  • setInterval(callback, delay[, ...args])
  • setTimeout(callback, delay[, ...args])
  • TextDecoder
  • TextEncoder
  • URL
  • URLSearchParams
  • WebAssembly

• HTTP

  • Class: http.Agent

    • new Agent([options])
    • agent.createConnection(options[, callback])
    • agent.keepSocketAlive(socket)
    • agent.reuseSocket(socket, request)
    • agent.destroy()
    • agent.freeSockets
    • agent.getName(options)
    • agent.maxFreeSockets
    • agent.maxSockets
    • agent.requests
    • agent.sockets

  • Class: http.ClientRequest

    • Event: 'abort'
    • Event: 'connect'
    • Event: 'continue'
    • Event: 'information'
    • Event: 'response'
    • Event: 'socket'
    • Event: 'timeout'
    • Event: 'upgrade'
    • request.abort()
    • request.aborted
    • request.connection
    • request.end([data[, encoding]][, callback])
    • request.finished
    • request.flushHeaders()
    • request.getHeader(name)
    • request.maxHeadersCount
    • request.path
    • request.removeHeader(name)
    • request.reusedSocket
    • request.setHeader(name, value)
    • request.setNoDelay([noDelay])
    • request.setSocketKeepAlive([enable][, initialDelay])
    • request.setTimeout(timeout[, callback])
    • request.socket
    • request.writableEnded
    • request.writableFinished
    • request.write(chunk[, encoding][, callback])

  • Class: http.Server

    • Event: 'checkContinue'
    • Event: 'checkExpectation'
    • Event: 'clientError'
    • Event: 'close'
    • Event: 'connect'
    • Event: 'connection'
    • Event: 'request'
    • Event: 'upgrade'
    • server.close([callback])
    • server.headersTimeout
    • server.listen()
    • server.listening
    • server.maxHeadersCount
    • server.setTimeout([msecs][, callback])
    • server.timeout
    • server.keepAliveTimeout

  • Class: http.ServerResponse

    • Event: 'close'
    • Event: 'finish'
    • response.addTrailers(headers)
    • response.connection
    • response.cork()
    • response.end([data[, encoding]][, callback])
    • response.finished
    • response.flushHeaders()
    • response.getHeader(name)
    • response.getHeaderNames()
    • response.getHeaders()
    • response.hasHeader(name)
    • response.headersSent
    • response.removeHeader(name)
    • response.sendDate
    • response.setHeader(name, value)
    • response.setTimeout(msecs[, callback])
    • response.socket
    • response.statusCode
    • response.statusMessage
    • response.uncork()
    • response.writableEnded
    • response.writableFinished
    • response.write(chunk[, encoding][, callback])
    • response.writeContinue()
    • response.writeHead(statusCode[, statusMessage][, headers])
    • response.writeProcessing()

  • Class: http.IncomingMessage

    • Event: 'aborted'
    • Event: 'close'
    • message.aborted
    • message.complete
    • message.destroy([error])
    • message.headers
    • message.httpVersion
    • message.method
    • message.rawHeaders
    • message.rawTrailers
    • message.setTimeout(msecs[, callback])
    • message.socket
    • message.statusCode
    • message.statusMessage
    • message.trailers
    • message.url
  • http.METHODS
  • http.STATUS_CODES
  • http.createServer([options][, requestListener])
  • http.get(options[, callback])
  • http.get(url[, options][, callback])
  • http.globalAgent
  • http.maxHeaderSize
  • http.request(options[, callback])
  • http.request(url[, options][, callback])

• HTTP/2

  • Core API

    • Server-side example
    • Client-side example

    • Class: Http2Session

      • Http2Session and Sockets
      • Event: 'close'
      • Event: 'connect'
      • Event: 'error'
      • Event: 'frameError'
      • Event: 'goaway'
      • Event: 'localSettings'
      • Event: 'ping'
      • Event: 'remoteSettings'
      • Event: 'stream'
      • Event: 'timeout'
      • http2session.alpnProtocol
      • http2session.close([callback])
      • http2session.closed
      • http2session.connecting
      • http2session.destroy([error][, code])
      • http2session.destroyed
      • http2session.encrypted
      • http2session.goaway([code[, lastStreamID[, opaqueData]]])
      • http2session.localSettings
      • http2session.originSet
      • http2session.pendingSettingsAck
      • http2session.ping([payload, ]callback)
      • http2session.ref()
      • http2session.remoteSettings
      • http2session.setTimeout(msecs, callback)
      • http2session.socket
      • http2session.state
      • http2session.settings([settings][, callback])
      • http2session.type
      • http2session.unref()

    • Class: ServerHttp2Session

      • serverhttp2session.altsvc(alt, originOrStream)
      • Specifying alternative services
      • serverhttp2session.origin(...origins)

    • Class: ClientHttp2Session

      • Event: 'altsvc'
      • Event: 'origin'
      • clienthttp2session.request(headers[, options])

    • Class: Http2Stream

      • Http2Stream Lifecycle

        • Creation
        • Destruction
      • Event: 'aborted'
      • Event: 'close'
      • Event: 'error'
      • Event: 'frameError'
      • Event: 'timeout'
      • Event: 'trailers'
      • Event: 'wantTrailers'
      • http2stream.aborted
      • http2stream.bufferSize
      • http2stream.close(code[, callback])
      • http2stream.closed
      • http2stream.destroyed
      • http2stream.endAfterHeaders
      • http2stream.id
      • http2stream.pending
      • http2stream.priority(options)
      • http2stream.rstCode
      • http2stream.sentHeaders
      • http2stream.sentInfoHeaders
      • http2stream.sentTrailers
      • http2stream.session
      • http2stream.setTimeout(msecs, callback)
      • http2stream.state
      • http2stream.sendTrailers(headers)

    • Class: ClientHttp2Stream

      • Event: 'continue'
      • Event: 'headers'
      • Event: 'push'
      • Event: 'response'

    • Class: ServerHttp2Stream

      • http2stream.additionalHeaders(headers)
      • http2stream.headersSent
      • http2stream.pushAllowed
      • http2stream.pushStream(headers[, options], callback)
      • http2stream.respond([headers[, options]])
      • http2stream.respondWithFD(fd[, headers[, options]])
      • http2stream.respondWithFile(path[, headers[, options]])

    • Class: Http2Server

      • Event: 'checkContinue'
      • Event: 'request'
      • Event: 'session'
      • Event: 'sessionError'
      • Event: 'stream'
      • Event: 'timeout'
      • server.close([callback])
      • server.setTimeout([msecs][, callback])

    • Class: Http2SecureServer

      • Event: 'checkContinue'
      • Event: 'request'
      • Event: 'session'
      • Event: 'sessionError'
      • Event: 'stream'
      • Event: 'timeout'
      • Event: 'unknownProtocol'
      • server.close([callback])
      • server.setTimeout([msecs][, callback])
    • http2.createServer(options[, onRequestHandler])
    • http2.createSecureServer(options[, onRequestHandler])
    • http2.connect(authority[, options][, listener])

    • http2.constants

      • Error Codes for RST_STREAM and GOAWAY
    • http2.getDefaultSettings()
    • http2.getPackedSettings([settings])
    • http2.getUnpackedSettings(buf)
    • Headers Object
    • Settings Object
    • Using options.selectPadding()
    • Error Handling
    • Invalid character handling in header names and values
    • Push streams on the client
    • Supporting the CONNECT method
    • The Extended CONNECT Protocol

  • Compatibility API

    • ALPN negotiation

    • Class: http2.Http2ServerRequest

      • Event: 'aborted'
      • Event: 'close'
      • request.aborted
      • request.authority
      • request.complete
      • request.destroy([error])
      • request.headers
      • request.httpVersion
      • request.method
      • request.rawHeaders
      • request.rawTrailers
      • request.scheme
      • request.setTimeout(msecs, callback)
      • request.socket
      • request.stream
      • request.trailers
      • request.url

    • Class: http2.Http2ServerResponse

      • Event: 'close'
      • Event: 'finish'
      • response.addTrailers(headers)
      • response.connection
      • response.end([data[, encoding]][, callback])
      • response.finished
      • response.getHeader(name)
      • response.getHeaderNames()
      • response.getHeaders()
      • response.hasHeader(name)
      • response.headersSent
      • response.removeHeader(name)
      • response.sendDate
      • response.setHeader(name, value)
      • response.setTimeout(msecs[, callback])
      • response.socket
      • response.statusCode
      • response.statusMessage
      • response.stream
      • response.writableEnded
      • response.write(chunk[, encoding][, callback])
      • response.writeContinue()
      • response.writeHead(statusCode[, statusMessage][, headers])
      • response.createPushResponse(headers, callback)
  • Collecting HTTP/2 Performance Metrics

• HTTPS

  • Class: https.Agent

    • new Agent([options])

      • Event: 'keylog'

  • Class: https.Server

    • server.close([callback])
    • server.headersTimeout
    • server.listen()
    • server.maxHeadersCount
    • server.setTimeout([msecs][, callback])
    • server.timeout
    • server.keepAliveTimeout
  • https.createServer([options][, requestListener])
  • https.get(options[, callback])
  • https.get(url[, options][, callback])
  • https.globalAgent
  • https.request(options[, callback])
  • https.request(url[, options][, callback])

• Inspector

  • inspector.close()
  • inspector.console
  • inspector.open([port[, host[, wait]]])
  • inspector.url()
  • inspector.waitForDebugger()

  • Class: inspector.Session

    • Constructor: new inspector.Session()
    • Event: 'inspectorNotification'
    • Event: <inspector-protocol-method>;
    • session.connect()
    • session.connectToMainThread()
    • session.disconnect()
    • session.post(method[, params][, callback])

  • Example usage

    • CPU Profiler
    • Heap Profiler

• Internationalization Support

  • Options for building Node.js

    • Disable all internationalization features (none)
    • Build with a pre-installed ICU (system-icu)

    • Embed a limited set of ICU data (small-icu)

      • Providing ICU data at runtime
    • Embed the entire ICU (full-icu)
  • Detecting internationalization support

• Modules

  • Accessing the main module
  • Addenda: Package Manager Tips
  • Addenda: The .mjs extension
  • All Together...

  • Caching

    • Module Caching Caveats
  • Core Modules
  • Cycles
  • File Modules
  • Folders as Modules
  • Loading from node_modules Folders
  • Loading from the global folders
  • The module wrapper

  • The module scope

    • __dirname
    • __filename
    • exports
    • module

    • require(id)

      • require.cache
      • require.extensions
      • require.main

      • require.resolve(request[, options])

        • require.resolve.paths(request)

  • The module Object

    • module.children

    • module.exports

      • exports shortcut
    • module.filename
    • module.id
    • module.loaded
    • module.parent
    • module.paths
    • module.require(id)

  • The Module Object

    • module.builtinModules
    • module.createRequire(filename)
    • module.createRequireFromPath(filename)
    • module.syncBuiltinESMExports()

• Net

  • IPC Support

    • Identifying paths for IPC connections

  • Class: net.Server

    • new net.Server([options][, connectionListener])
    • Event: 'close'
    • Event: 'connection'
    • Event: 'error'
    • Event: 'listening'
    • server.address()
    • server.close([callback])
    • server.connections
    • server.getConnections(callback)

    • server.listen()

      • server.listen(handle[, backlog][, callback])
      • server.listen(options[, callback])
      • server.listen(path[, backlog][, callback])
      • server.listen([port[, host[, backlog]]][, callback])
    • server.listening
    • server.maxConnections
    • server.ref()
    • server.unref()

  • Class: net.Socket

    • new net.Socket([options])
    • Event: 'close'
    • Event: 'connect'
    • Event: 'data'
    • Event: 'drain'
    • Event: 'end'
    • Event: 'error'
    • Event: 'lookup'
    • Event: 'ready'
    • Event: 'timeout'
    • socket.address()
    • socket.bufferSize
    • socket.bytesRead
    • socket.bytesWritten

    • socket.connect()

      • socket.connect(options[, connectListener])
      • socket.connect(path[, connectListener])
      • socket.connect(port[, host][, connectListener])
    • socket.connecting
    • socket.destroy([exception])
    • socket.destroyed
    • socket.end([data[, encoding]][, callback])
    • socket.localAddress
    • socket.localPort
    • socket.pause()
    • socket.pending
    • socket.ref()
    • socket.remoteAddress
    • socket.remoteFamily
    • socket.remotePort
    • socket.resume()
    • socket.setEncoding([encoding])
    • socket.setKeepAlive([enable][, initialDelay])
    • socket.setNoDelay([noDelay])
    • socket.setTimeout(timeout[, callback])
    • socket.unref()
    • socket.write(data[, encoding][, callback])

  • net.connect()

    • net.connect(options[, connectListener])
    • net.connect(path[, connectListener])
    • net.connect(port[, host][, connectListener])

  • net.createConnection()

    • net.createConnection(options[, connectListener])
    • net.createConnection(path[, connectListener])
    • net.createConnection(port[, host][, connectListener])
  • net.createServer([options][, connectionListener])
  • net.isIP(input)
  • net.isIPv4(input)
  • net.isIPv6(input)

• OS

  • os.EOL
  • os.arch()
  • os.constants
  • os.cpus()
  • os.endianness()
  • os.freemem()
  • os.getPriority([pid])
  • os.homedir()
  • os.hostname()
  • os.loadavg()
  • os.networkInterfaces()
  • os.platform()
  • os.release()
  • os.setPriority([pid, ]priority)
  • os.tmpdir()
  • os.totalmem()
  • os.type()
  • os.uptime()
  • os.userInfo([options])

  • OS Constants

    • Signal Constants

    • Error Constants

      • POSIX Error Constants
      • Windows Specific Error Constants
    • dlopen Constants
    • Priority Constants
    • libuv Constants

• Path

  • Windows vs. POSIX
  • path.basename(path[, ext])
  • path.delimiter
  • path.dirname(path)
  • path.extname(path)
  • path.format(pathObject)
  • path.isAbsolute(path)
  • path.join([...paths])
  • path.normalize(path)
  • path.parse(path)
  • path.posix
  • path.relative(from, to)
  • path.resolve([...paths])
  • path.sep
  • path.toNamespacedPath(path)
  • path.win32

• Performance Timing API

  • Class: Performance

    • performance.clearMarks([name])
    • performance.mark([name])
    • performance.measure(name[, startMark[, endMark]])
    • performance.nodeTiming
    • performance.now()
    • performance.timeOrigin
    • performance.timerify(fn)

  • Class: PerformanceEntry

    • performanceEntry.duration
    • performanceEntry.name
    • performanceEntry.startTime
    • performanceEntry.entryType
    • performanceEntry.kind

  • Class: PerformanceNodeTiming extends PerformanceEntry

    • performanceNodeTiming.bootstrapComplete
    • performanceNodeTiming.environment
    • performanceNodeTiming.loopExit
    • performanceNodeTiming.loopStart
    • performanceNodeTiming.nodeStart
    • performanceNodeTiming.v8Start

  • Class: PerformanceObserver

    • new PerformanceObserver(callback)
    • performanceObserver.disconnect()
    • performanceObserver.observe(options)

  • Class: PerformanceObserverEntryList

    • performanceObserverEntryList.getEntries()
    • performanceObserverEntryList.getEntriesByName(name[, type])
    • performanceObserverEntryList.getEntriesByType(type)

  • perf_hooks.monitorEventLoopDelay([options])

    • Class: Histogram

      • histogram.disable()
      • histogram.enable()
      • histogram.exceeds
      • histogram.max
      • histogram.mean
      • histogram.min
      • histogram.percentile(percentile)
      • histogram.percentiles
      • histogram.reset()
      • histogram.stddev

  • Examples

    • Measuring the duration of async operations
    • Measuring how long it takes to load dependencies

• Policies

  • Enabling

  • Features

    • Error Behavior
    • Integrity Checks

    • Dependency Redirection

      • Example: Patched Dependency

• Process

  • Process Events

    • Event: 'beforeExit'
    • Event: 'disconnect'
    • Event: 'exit'
    • Event: 'message'
    • Event: 'multipleResolves'
    • Event: 'rejectionHandled'

    • Event: 'uncaughtException'

      • Warning: Using 'uncaughtException' correctly
    • Event: 'unhandledRejection'

    • Event: 'warning'

      • Emitting custom warnings
    • Signal Events
  • process.abort()
  • process.allowedNodeEnvironmentFlags
  • process.arch
  • process.argv
  • process.argv0
  • process.channel
  • process.chdir(directory)
  • process.config
  • process.connected
  • process.cpuUsage([previousValue])
  • process.cwd()
  • process.debugPort
  • process.disconnect()
  • process.dlopen(module, filename[, flags])
  • process.emitWarning(warning[, options])

  • process.emitWarning(warning[, type[, code]][, ctor])

    • Avoiding duplicate warnings
  • process.env
  • process.execArgv
  • process.execPath
  • process.exit([code])
  • process.exitCode
  • process.getegid()
  • process.geteuid()
  • process.getgid()
  • process.getgroups()
  • process.getuid()
  • process.hasUncaughtExceptionCaptureCallback()
  • process.hrtime([time])
  • process.hrtime.bigint()
  • process.initgroups(user, extraGroup)
  • process.kill(pid[, signal])
  • process.mainModule
  • process.memoryUsage()
  • process.nextTick(callback[, ...args])
  • process.noDeprecation
  • process.pid
  • process.platform
  • process.ppid
  • process.release

  • process.report

    • process.report.directory
    • process.report.filename
    • process.report.getReport([err])
    • process.report.reportOnFatalError
    • process.report.reportOnSignal
    • process.report.reportOnUncaughtException
    • process.report.signal
    • process.report.writeReport([filename][, err])
  • process.resourceUsage()
  • process.send(message[, sendHandle[, options]][, callback])
  • process.setegid(id)
  • process.seteuid(id)
  • process.setgid(id)
  • process.setgroups(groups)
  • process.setuid(id)
  • process.setUncaughtExceptionCaptureCallback(fn)

  • process.stderr

    • process.stderr.fd

  • process.stdin

    • process.stdin.fd

  • process.stdout

    • process.stdout.fd
    • A note on process I/O
  • process.throwDeprecation
  • process.title
  • process.traceDeprecation
  • process.umask([mask])
  • process.uptime()
  • process.version
  • process.versions
  • Exit Codes

• Punycode

  • punycode.decode(string)
  • punycode.encode(string)
  • punycode.toASCII(domain)
  • punycode.toUnicode(domain)

  • punycode.ucs2

    • punycode.ucs2.decode(string)
    • punycode.ucs2.encode(codePoints)
  • punycode.version

• Query String

  • querystring.decode()
  • querystring.encode()
  • querystring.escape(str)
  • querystring.parse(str[, sep[, eq[, options]]])
  • querystring.stringify(obj[, sep[, eq[, options]]])
  • querystring.unescape(str)

• Readline

  • Class: Interface

    • Event: 'close'
    • Event: 'line'
    • Event: 'pause'
    • Event: 'resume'
    • Event: 'SIGCONT'
    • Event: 'SIGINT'
    • Event: 'SIGTSTP'
    • rl.close()
    • rl.pause()
    • rl.prompt([preserveCursor])
    • rl.question(query, callback)
    • rl.resume()
    • rl.setPrompt(prompt)
    • rl.write(data[, key])
    • rl[Symbol.asyncIterator]()
    • rl.line
    • rl.cursor
    • rl.getCursorPos()
  • readline.clearLine(stream, dir[, callback])
  • readline.clearScreenDown(stream[, callback])

  • readline.createInterface(options)

    • Use of the completer Function
  • readline.cursorTo(stream, x[, y][, callback])
  • readline.emitKeypressEvents(stream[, interface])
  • readline.moveCursor(stream, dx, dy[, callback])
  • Example: Tiny CLI
  • Example: Read File Stream Line-by-Line

• REPL

  • Design and Features

    • Commands and Special Keys

    • Default Evaluation

      • JavaScript Expressions
      • Global and Local Scope
      • Accessing Core Node.js Modules
      • Global Uncaught Exceptions
      • Assignment of the _ (underscore) variable
      • await keyword

    • Custom Evaluation Functions

      • Recoverable Errors
    • Customizing REPL Output

  • Class: REPLServer

    • Event: 'exit'
    • Event: 'reset'
    • replServer.defineCommand(keyword, cmd)
    • replServer.displayPrompt([preserveCursor])
    • replServer.clearBufferedCommand()
    • replServer.parseREPLKeyword(keyword[, rest])
    • replServer.setupHistory(historyPath, callback)
  • repl.start([options])

  • The Node.js REPL

    • Environment Variable Options
    • Persistent History
    • Using the Node.js REPL with advanced line-editors
    • Starting multiple REPL instances against a single running instance

• Diagnostic Report

  • Usage
  • Configuration
  • Interaction with Workers

• Stream

  • Organization of this Document

  • Types of Streams

    • Object Mode
    • Buffering

  • API for Stream Consumers

    • Writable Streams

      • Class: stream.Writable

        • Event: 'close'
        • Event: 'drain'
        • Event: 'error'
        • Event: 'finish'
        • Event: 'pipe'
        • Event: 'unpipe'
        • writable.cork()
        • writable.destroy([error])
        • writable.destroyed
        • writable.end([chunk[, encoding]][, callback])
        • writable.setDefaultEncoding(encoding)
        • writable.uncork()
        • writable.writable
        • writable.writableEnded
        • writable.writableCorked
        • writable.writableFinished
        • writable.writableHighWaterMark
        • writable.writableLength
        • writable.writableObjectMode
        • writable.write(chunk[, encoding][, callback])

    • Readable Streams

      • Two Reading Modes
      • Three States
      • Choose One API Style

      • Class: stream.Readable

        • Event: 'close'
        • Event: 'data'
        • Event: 'end'
        • Event: 'error'
        • Event: 'pause'
        • Event: 'readable'
        • Event: 'resume'
        • readable.destroy([error])
        • readable.destroyed
        • readable.isPaused()
        • readable.pause()
        • readable.pipe(destination[, options])
        • readable.read([size])
        • readable.readable
        • readable.readableEncoding
        • readable.readableEnded
        • readable.readableFlowing
        • readable.readableHighWaterMark
        • readable.readableLength
        • readable.readableObjectMode
        • readable.resume()
        • readable.setEncoding(encoding)
        • readable.unpipe([destination])
        • readable.unshift(chunk[, encoding])
        • readable.wrap(stream)
        • readable[Symbol.asyncIterator]()

    • Duplex and Transform Streams

      • Class: stream.Duplex

      • Class: stream.Transform

        • transform.destroy([error])
    • stream.finished(stream[, options], callback)
    • stream.pipeline(...streams, callback)
    • stream.Readable.from(iterable, [options])

  • API for Stream Implementers

    • Simplified Construction

    • Implementing a Writable Stream

      • Constructor: new stream.Writable([options])
      • writable._write(chunk, encoding, callback)
      • writable._writev(chunks, callback)
      • writable._destroy(err, callback)
      • writable._final(callback)
      • Errors While Writing
      • An Example Writable Stream
      • Decoding buffers in a Writable Stream

    • Implementing a Readable Stream

      • new stream.Readable([options])
      • readable._read(size)
      • readable._destroy(err, callback)
      • readable.push(chunk[, encoding])
      • Errors While Reading
      • An Example Counting Stream

    • Implementing a Duplex Stream

      • new stream.Duplex(options)
      • An Example Duplex Stream
      • Object Mode Duplex Streams

    • Implementing a Transform Stream

      • new stream.Transform([options])
      • Events: 'finish' and 'end'
      • transform._flush(callback)
      • transform._transform(chunk, encoding, callback)
      • Class: stream.PassThrough

  • Additional Notes

    • Streams Compatibility with Async Generators and Async Iterators

      • Consuming Readable Streams with Async Iterators
      • Creating Readable Streams with Async Generators
      • Piping to Writable Streams from Async Iterators
    • Compatibility with Older Node.js Versions
    • readable.read(0)
    • readable.push('')
    • highWaterMark discrepancy after calling readable.setEncoding()

• String Decoder

  • Class: StringDecoder

    • new StringDecoder([encoding])
    • stringDecoder.end([buffer])
    • stringDecoder.write(buffer)

• Timers

  • Class: Immediate

    • immediate.hasRef()
    • immediate.ref()
    • immediate.unref()

  • Class: Timeout

    • timeout.hasRef()
    • timeout.ref()
    • timeout.refresh()
    • timeout.unref()

  • Scheduling Timers

    • setImmediate(callback[, ...args])
    • setInterval(callback, delay[, ...args])
    • setTimeout(callback, delay[, ...args])

  • Cancelling Timers

    • clearImmediate(immediate)
    • clearInterval(timeout)
    • clearTimeout(timeout)

• TLS (SSL)

  • TLS/SSL Concepts

    • Perfect Forward Secrecy
    • ALPN and SNI
    • Pre-shared keys
    • Client-initiated renegotiation attack mitigation
    • Session Resumption
  • Modifying the Default TLS Cipher suite

  • Class: tls.Server

    • Event: 'keylog'
    • Event: 'newSession'
    • Event: 'OCSPRequest'
    • Event: 'resumeSession'
    • Event: 'secureConnection'
    • Event: 'tlsClientError'
    • server.addContext(hostname, context)
    • server.address()
    • server.close([callback])
    • server.connections
    • server.getTicketKeys()
    • server.listen()
    • server.setSecureContext(options)
    • server.setTicketKeys(keys)

  • Class: tls.TLSSocket

    • new tls.TLSSocket(socket[, options])
    • Event: 'keylog'
    • Event: 'OCSPResponse'
    • Event: 'secureConnect'
    • Event: 'session'
    • tlsSocket.address()
    • tlsSocket.authorizationError
    • tlsSocket.authorized
    • tlsSocket.disableRenegotiation()
    • tlsSocket.enableTrace()
    • tlsSocket.encrypted
    • tlsSocket.getCertificate()
    • tlsSocket.getCipher()
    • tlsSocket.getEphemeralKeyInfo()
    • tlsSocket.getFinished()

    • tlsSocket.getPeerCertificate([detailed])

      • Certificate Object
    • tlsSocket.getPeerFinished()
    • tlsSocket.getProtocol()
    • tlsSocket.getSession()
    • tlsSocket.getSharedSigalgs()
    • tlsSocket.getTLSTicket()
    • tlsSocket.isSessionReused()
    • tlsSocket.localAddress
    • tlsSocket.localPort
    • tlsSocket.remoteAddress
    • tlsSocket.remoteFamily
    • tlsSocket.remotePort
    • tlsSocket.renegotiate(options, callback)
    • tlsSocket.setMaxSendFragment(size)
  • tls.checkServerIdentity(hostname, cert)
  • tls.connect(options[, callback])
  • tls.connect(path[, options][, callback])
  • tls.connect(port[, host][, options][, callback])
  • tls.createSecureContext([options])
  • tls.createServer([options][, secureConnectionListener])
  • tls.getCiphers()
  • tls.rootCertificates
  • tls.DEFAULT_ECDH_CURVE
  • tls.DEFAULT_MAX_VERSION
  • tls.DEFAULT_MIN_VERSION

  • Deprecated APIs

    • Class: CryptoStream

      • cryptoStream.bytesWritten

    • Class: SecurePair

      • Event: 'secure'
    • tls.createSecurePair([context][, isServer][, requestCert][, rejectUnauthorized][, options])

• Trace Events

  • The trace_events module

    • Tracing object

      • tracing.categories
      • tracing.disable()
      • tracing.enable()
      • tracing.enabled
    • trace_events.createTracing(options)
    • trace_events.getEnabledCategories()

• TTY

  • Class: tty.ReadStream

    • readStream.isRaw
    • readStream.isTTY
    • readStream.setRawMode(mode)

  • Class: tty.WriteStream

    • Event: 'resize'
    • writeStream.clearLine(dir[, callback])
    • writeStream.clearScreenDown([callback])
    • writeStream.columns
    • writeStream.cursorTo(x[, y][, callback])
    • writeStream.getColorDepth([env])
    • writeStream.getWindowSize()
    • writeStream.hasColors([count][, env])
    • writeStream.isTTY
    • writeStream.moveCursor(dx, dy[, callback])
    • writeStream.rows
  • tty.isatty(fd)

• UDP/Datagram Sockets

  • Class: dgram.Socket

    • Event: 'close'
    • Event: 'connect'
    • Event: 'error'
    • Event: 'listening'
    • Event: 'message'
    • socket.addMembership(multicastAddress[, multicastInterface])
    • socket.addSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])
    • socket.address()
    • socket.bind([port][, address][, callback])
    • socket.bind(options[, callback])
    • socket.close([callback])
    • socket.connect(port[, address][, callback])
    • socket.disconnect()
    • socket.dropMembership(multicastAddress[, multicastInterface])
    • socket.dropSourceSpecificMembership(sourceAddress, groupAddress[, multicastInterface])
    • socket.getRecvBufferSize()
    • socket.getSendBufferSize()
    • socket.ref()
    • socket.remoteAddress()

    • socket.send(msg[, offset, length][, port][, address][, callback])

      • Note about UDP datagram size
    • socket.setBroadcast(flag)

    • socket.setMulticastInterface(multicastInterface)

      • Examples: IPv6 Outgoing Multicast Interface
      • Example: IPv4 Outgoing Multicast Interface
      • Call Results
    • socket.setMulticastLoopback(flag)
    • socket.setMulticastTTL(ttl)
    • socket.setRecvBufferSize(size)
    • socket.setSendBufferSize(size)
    • socket.setTTL(ttl)
    • socket.unref()

  • dgram module functions

    • dgram.createSocket(options[, callback])
    • dgram.createSocket(type[, callback])

• URL

  • URL Strings and URL Objects

  • The WHATWG URL API

    • Class: URL

      • Constructor: new URL(input[, base])
      • url.hash
      • url.host
      • url.hostname
      • url.href
      • url.origin
      • url.password
      • url.pathname
      • url.port

      • url.protocol

        • Special Schemes
      • url.search
      • url.searchParams
      • url.username
      • url.toString()
      • url.toJSON()

    • Class: URLSearchParams

      • Constructor: new URLSearchParams()
      • Constructor: new URLSearchParams(string)
      • Constructor: new URLSearchParams(obj)
      • Constructor: new URLSearchParams(iterable)
      • urlSearchParams.append(name, value)
      • urlSearchParams.delete(name)
      • urlSearchParams.entries()
      • urlSearchParams.forEach(fn[, thisArg])
      • urlSearchParams.get(name)
      • urlSearchParams.getAll(name)
      • urlSearchParams.has(name)
      • urlSearchParams.keys()
      • urlSearchParams.set(name, value)
      • urlSearchParams.sort()
      • urlSearchParams.toString()
      • urlSearchParams.values()
      • urlSearchParams[Symbol.iterator]()
    • url.domainToASCII(domain)
    • url.domainToUnicode(domain)
    • url.fileURLToPath(url)
    • url.format(URL[, options])
    • url.pathToFileURL(path)

  • Legacy URL API

    • Legacy urlObject

      • urlObject.auth
      • urlObject.hash
      • urlObject.host
      • urlObject.hostname
      • urlObject.href
      • urlObject.path
      • urlObject.pathname
      • urlObject.port
      • urlObject.protocol
      • urlObject.query
      • urlObject.search
      • urlObject.slashes
    • url.format(urlObject)
    • url.parse(urlString[, parseQueryString[, slashesDenoteHost]])
    • url.resolve(from, to)

  • Percent-Encoding in URLs

    • Legacy API
    • WHATWG API

• Util

  • util.callbackify(original)
  • util.debuglog(section)
  • util.deprecate(fn, msg[, code])
  • util.format(format[, ...args])
  • util.formatWithOptions(inspectOptions, format[, ...args])
  • util.getSystemErrorName(err)
  • util.inherits(constructor, superConstructor)
  • util.inspect(object[, options])

  • util.inspect(object[, showHidden[, depth[, colors]]])

    • Customizing util.inspect colors

      • Modifiers
      • Foreground colors
      • Background colors
    • Custom inspection functions on Objects
    • util.inspect.custom
    • util.inspect.defaultOptions
  • util.isDeepStrictEqual(val1, val2)

  • util.promisify(original)

    • Custom promisified functions
    • util.promisify.custom

  • Class: util.TextDecoder

    • WHATWG Supported Encodings

      • Encodings Supported Without ICU
      • Encodings Supported by Default (With ICU)
      • Encodings Requiring Full ICU Data
    • new TextDecoder([encoding[, options]])
    • textDecoder.decode([input[, options]])
    • textDecoder.encoding
    • textDecoder.fatal
    • textDecoder.ignoreBOM

  • Class: util.TextEncoder

    • textEncoder.encode([input])
    • textEncoder.encodeInto(src, dest)
    • textEncoder.encoding

  • util.types

    • util.types.isAnyArrayBuffer(value)
    • util.types.isArgumentsObject(value)
    • util.types.isArrayBuffer(value)
    • util.types.isAsyncFunction(value)
    • util.types.isBigInt64Array(value)
    • util.types.isBigUint64Array(value)
    • util.types.isBooleanObject(value)
    • util.types.isBoxedPrimitive(value)
    • util.types.isDataView(value)
    • util.types.isDate(value)
    • util.types.isExternal(value)
    • util.types.isFloat32Array(value)
    • util.types.isFloat64Array(value)
    • util.types.isGeneratorFunction(value)
    • util.types.isGeneratorObject(value)
    • util.types.isInt8Array(value)
    • util.types.isInt16Array(value)
    • util.types.isInt32Array(value)
    • util.types.isMap(value)
    • util.types.isMapIterator(value)
    • util.types.isModuleNamespaceObject(value)
    • util.types.isNativeError(value)
    • util.types.isNumberObject(value)
    • util.types.isPromise(value)
    • util.types.isProxy(value)
    • util.types.isRegExp(value)
    • util.types.isSet(value)
    • util.types.isSetIterator(value)
    • util.types.isSharedArrayBuffer(value)