Node.js v7.7.2 Documentation

Table of Contents

• About this Documentation
  • Stability Index
  • JSON Output
  • Syscalls and man pages
• Usage
  • Example
• Assert
  • assert(value[, message])
  • assert.deepEqual(actual, expected[, message])
  • assert.deepStrictEqual(actual, expected[, message])
  • assert.doesNotThrow(block[, error][, message])
  • assert.equal(actual, expected[, message])
  • assert.fail(actual, expected, message, operator)
  • assert.ifError(value)
  • 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.strictEqual(actual, expected[, message])
  • assert.throws(block[, error][, message])
• Buffer
  • Buffer.from(), Buffer.alloc(), and Buffer.allocUnsafe()
    • The --zero-fill-buffers command line option
    • What makes Buffer.allocUnsafe() and Buffer.allocUnsafeSlow() "unsafe"?
  • Buffers and Character Encodings
  • Buffers and TypedArray
  • Buffers and ES6 iteration
  • Class: Buffer
    • new Buffer(array)
    • new Buffer(arrayBuffer[, byteOffset [, length]])
    • new Buffer(buffer)
    • new Buffer(size)
    • new Buffer(string[, encoding])
    • 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(string[, encoding])
    • Class Method: Buffer.isBuffer(obj)
    • Class Method: Buffer.isEncoding(encoding)
    • Class Property: Buffer.poolSize
    • buf[index]
    • 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.readDoubleBE(offset[, noAssert])
    • buf.readDoubleLE(offset[, noAssert])
    • buf.readFloatBE(offset[, noAssert])
    • buf.readFloatLE(offset[, noAssert])
    • buf.readInt8(offset[, noAssert])
    • buf.readInt16BE(offset[, noAssert])
    • buf.readInt16LE(offset[, noAssert])
    • buf.readInt32BE(offset[, noAssert])
    • buf.readInt32LE(offset[, noAssert])
    • buf.readIntBE(offset, byteLength[, noAssert])
    • buf.readIntLE(offset, byteLength[, noAssert])
    • buf.readUInt8(offset[, noAssert])
    • buf.readUInt16BE(offset[, noAssert])
    • buf.readUInt16LE(offset[, noAssert])
    • buf.readUInt32BE(offset[, noAssert])
    • buf.readUInt32LE(offset[, noAssert])
    • buf.readUIntBE(offset, byteLength[, noAssert])
    • buf.readUIntLE(offset, byteLength[, noAssert])
    • 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.writeDoubleBE(value, offset[, noAssert])
    • buf.writeDoubleLE(value, offset[, noAssert])
    • buf.writeFloatBE(value, offset[, noAssert])
    • buf.writeFloatLE(value, offset[, noAssert])
    • buf.writeInt8(value, offset[, noAssert])
    • buf.writeInt16BE(value, offset[, noAssert])
    • buf.writeInt16LE(value, offset[, noAssert])
    • buf.writeInt32BE(value, offset[, noAssert])
    • buf.writeInt32LE(value, offset[, noAssert])
    • buf.writeIntBE(value, offset, byteLength[, noAssert])
    • buf.writeIntLE(value, offset, byteLength[, noAssert])
    • buf.writeUInt8(value, offset[, noAssert])
    • buf.writeUInt16BE(value, offset[, noAssert])
    • buf.writeUInt16LE(value, offset[, noAssert])
    • buf.writeUInt32BE(value, offset[, noAssert])
    • buf.writeUInt32LE(value, offset[, noAssert])
    • buf.writeUIntBE(value, offset, byteLength[, noAssert])
    • buf.writeUIntLE(value, offset, byteLength[, noAssert])
  • buffer.INSPECT_MAX_BYTES
  • buffer.kMaxLength
  • buffer.transcode(source, fromEnc, toEnc)
  • Class: SlowBuffer
    • new SlowBuffer(size)
• C/C++ Addons
  • Hello world
    • Building
    • Linking to Node.js' own dependencies
    • Loading Addons using require()
  • Native Abstractions for Node.js
  • Addon examples
    • Function arguments
    • Callbacks
    • Object factory
    • Function factory
    • Wrapping C++ objects
    • Factory of wrapped objects
    • Passing wrapped objects around
    • AtExit hooks
      • void AtExit(callback, args)
• 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'
    • child.channel
    • child.connected
    • child.disconnect()
    • child.kill([signal])
    • child.pid
    • child.send(message[, sendHandle[, options]][, callback])
      • Example: sending a server object
      • Example: sending a socket object
    • child.stderr
    • child.stdin
    • child.stdio
    • child.stdout
  • maxBuffer and Unicode
• 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][, callback])
    • worker.suicide
  • 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
    • -v, --version
    • -h, --help
    • -e, --eval "script"
    • -p, --print "script"
    • -c, --check
    • -i, --interactive
    • -r, --require module
    • --no-deprecation
    • --trace-deprecation
    • --throw-deprecation
    • --no-warnings
    • --trace-warnings
    • --trace-sync-io
    • --trace-events-enabled
    • --trace-event-categories
    • --zero-fill-buffers
    • --preserve-symlinks
    • --track-heap-objects
    • --prof-process
    • --v8-options
    • --tls-cipher-list=list
    • --enable-fips
    • --force-fips
    • --openssl-config=file
    • --use-openssl-ca, --use-bundled-ca
    • --icu-data-dir=file
    • --
  • Environment Variables
    • NODE_DEBUG=module[,…]
    • NODE_PATH=path[:…]
    • NODE_DISABLE_COLORS=1
    • NODE_ICU_DATA=file
    • NODE_NO_WARNINGS=1
    • NODE_PRESERVE_SYMLINKS=1
    • NODE_REPL_HISTORY=file
    • NODE_TTY_UNSAFE_ASYNC=1
    • NODE_EXTRA_CA_CERTS=file
    • OPENSSL_CONF=file
    • SSL_CERT_DIR=dir
    • SSL_CERT_FILE=file
• Console
  • Class: Console
    • new Console(stdout[, stderr])
    • console.assert(value[, message][, ...args])
    • console.dir(obj[, options])
    • console.error([data][, ...args])
    • console.info([data][, ...args])
    • console.log([data][, ...args])
    • console.time(label)
    • console.timeEnd(label)
    • console.trace([message][, ...args])
    • console.warn([data][, ...args])
• Crypto
  • Determining if crypto support is unavailable
  • Class: Certificate
    • new crypto.Certificate()
    • certificate.exportChallenge(spkac)
    • certificate.exportPublicKey(spkac)
    • certificate.verifySpkac(spkac)
  • Class: Cipher
    • cipher.final([output_encoding])
    • cipher.setAAD(buffer)
    • cipher.getAuthTag()
    • cipher.setAutoPadding(auto_padding=true)
    • cipher.update(data[, input_encoding][, output_encoding])
  • Class: Decipher
    • decipher.final([output_encoding])
    • decipher.setAAD(buffer)
    • decipher.setAuthTag(buffer)
    • decipher.setAutoPadding(auto_padding=true)
    • decipher.update(data[, input_encoding][, output_encoding])
  • Class: DiffieHellman
    • diffieHellman.computeSecret(other_public_key[, input_encoding][, output_encoding])
    • diffieHellman.generateKeys([encoding])
    • diffieHellman.getGenerator([encoding])
    • diffieHellman.getPrime([encoding])
    • diffieHellman.getPrivateKey([encoding])
    • diffieHellman.getPublicKey([encoding])
    • diffieHellman.setPrivateKey(private_key[, encoding])
    • diffieHellman.setPublicKey(public_key[, encoding])
    • diffieHellman.verifyError
  • Class: ECDH
    • ecdh.computeSecret(other_public_key[, input_encoding][, output_encoding])
    • ecdh.generateKeys([encoding[, format]])
    • ecdh.getPrivateKey([encoding])
    • ecdh.getPublicKey([encoding[, format]])
    • ecdh.setPrivateKey(private_key[, encoding])
    • ecdh.setPublicKey(public_key[, encoding])
  • Class: Hash
    • hash.digest([encoding])
    • hash.update(data[, input_encoding])
  • Class: Hmac
    • hmac.digest([encoding])
    • hmac.update(data[, input_encoding])
  • Class: Sign
    • sign.sign(private_key[, output_format])
    • sign.update(data[, input_encoding])
  • Class: Verify
    • verifier.update(data[, input_encoding])
    • verifier.verify(object, signature[, signature_format])
  • crypto module methods and properties
    • crypto.constants
    • crypto.DEFAULT_ENCODING
    • crypto.fips
    • crypto.createCipher(algorithm, password)
    • crypto.createCipheriv(algorithm, key, iv)
    • crypto.createCredentials(details)
    • crypto.createDecipher(algorithm, password)
    • crypto.createDecipheriv(algorithm, key, iv)
    • crypto.createDiffieHellman(prime[, prime_encoding][, generator][, generator_encoding])
    • crypto.createDiffieHellman(prime_length[, generator])
    • crypto.createECDH(curve_name)
    • crypto.createHash(algorithm)
    • crypto.createHmac(algorithm, key)
    • crypto.createSign(algorithm)
    • crypto.createVerify(algorithm)
    • crypto.getCiphers()
    • crypto.getCurves()
    • crypto.getDiffieHellman(group_name)
    • crypto.getHashes()
    • crypto.pbkdf2(password, salt, iterations, keylen, digest, callback)
    • crypto.pbkdf2Sync(password, salt, iterations, keylen, digest)
    • crypto.privateDecrypt(private_key, buffer)
    • crypto.privateEncrypt(private_key, buffer)
    • crypto.publicDecrypt(public_key, buffer)
    • crypto.publicEncrypt(public_key, buffer)
    • crypto.randomBytes(size[, callback])
    • crypto.setEngine(engine[, flags])
    • crypto.timingSafeEqual(a, b)
  • Notes
    • Legacy Streams API (pre Node.js v0.10)
    • Recent ECDH Changes
    • Support for weak or compromised algorithms
  • 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
  • Un-deprecation
  • List of Deprecated APIs
    • DEP0062: node --debug
• DNS
  • 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.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)
  • 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)
      • Example
    • domain.dispose()
    • domain.enter()
    • domain.exit()
    • domain.intercept(callback)
      • Example
    • domain.remove(emitter)
    • domain.run(fn[, ...args])
• Errors
  • Error Propagation and Interception
    • Node.js style callbacks
  • Class: Error
    • new Error(message)
    • Error.captureStackTrace(targetObject[, constructorOpt])
    • Error.stackTraceLimit
    • error.message
    • error.stack
  • Class: RangeError
  • Class: ReferenceError
  • Class: SyntaxError
  • Class: TypeError
  • Exceptions vs. Errors
  • System Errors
    • Class: System Error
      • error.code
      • error.errno
      • error.syscall
      • error.path
      • error.address
      • error.port
    • Common System Errors
• Events
  • Passing arguments and this to listeners
  • Asynchronous vs. Synchronous
  • Handling events only once
  • Error events
  • 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.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)
• File System
  • Buffer API
  • Class: fs.FSWatcher
    • Event: 'change'
    • Event: 'error'
    • watcher.close()
  • Class: fs.ReadStream
    • Event: 'close'
    • Event: 'open'
    • readStream.bytesRead
    • readStream.path
  • Class: fs.Stats
    • Stat Time Values
  • Class: fs.WriteStream
    • Event: 'close'
    • Event: 'open'
    • writeStream.bytesWritten
    • writeStream.path
  • fs.access(path[, mode], callback)
  • fs.accessSync(path[, mode])
  • fs.appendFile(file, data[, options], callback)
  • fs.appendFileSync(file, data[, options])
  • fs.chmod(path, mode, callback)
  • 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.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, callback)
  • fs.fstatSync(fd)
  • 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, callback)
  • fs.lstatSync(path)
  • fs.mkdir(path[, mode], callback)
  • fs.mkdirSync(path[, mode])
  • fs.mkdtemp(prefix[, options], callback)
  • fs.mkdtempSync(prefix[, options])
  • fs.open(path, flags[, mode], callback)
  • fs.openSync(path, flags[, mode])
  • fs.read(fd, buffer, offset, length, position, callback)
  • fs.readdir(path[, options], callback)
  • fs.readdirSync(path[, options])
  • fs.readFile(file[, options], callback)
  • fs.readFileSync(file[, options])
  • fs.readlink(path[, options], callback)
  • fs.readlinkSync(path[, options])
  • fs.readSync(fd, buffer, offset, length, position)
  • fs.realpath(path[, options], callback)
  • fs.realpathSync(path[, options])
  • fs.rename(oldPath, newPath, callback)
  • fs.renameSync(oldPath, newPath)
  • fs.rmdir(path, callback)
  • fs.rmdirSync(path)
  • fs.stat(path, callback)
  • fs.statSync(path)
  • 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)
  • fs.writeFileSync(file, data[, options])
  • fs.writeSync(fd, buffer[, offset[, length[, position]]])
  • fs.writeSync(fd, string[, position[, encoding]])
  • FS Constants
    • File Access Constants
    • File Open Constants
    • File Type Constants