Node.js v0.10.48 Manual & Documentation

Table of Contents

• About this Documentation
  • Stability Index
  • JSON Output
• Synopsis
• Global Objects
  • global
  • process
  • console
  • Class: Buffer
  • require()
    • require.resolve()
    • require.cache
    • require.extensions
  • __filename
  • __dirname
  • module
  • exports
  • setTimeout(cb, ms)
  • clearTimeout(t)
  • setInterval(cb, ms)
  • clearInterval(t)
• console
  • console.log([data], [...])
  • console.info([data], [...])
  • console.error([data], [...])
  • console.warn([data], [...])
  • console.dir(obj)
  • console.time(label)
  • console.timeEnd(label)
  • console.trace(message, [...])
  • console.assert(value, [message], [...])
• Timers
  • setTimeout(callback, delay, [arg], [...])
  • clearTimeout(timeoutObject)
  • setInterval(callback, delay, [arg], [...])
  • clearInterval(intervalObject)
  • unref()
  • ref()
  • setImmediate(callback, [arg], [...])
  • clearImmediate(immediateObject)
• Modules
  • Cycles
  • Core Modules
  • File Modules
  • Loading from node_modules Folders
  • Folders as Modules
  • Caching
    • Module Caching Caveats
  • The module Object
    • module.exports
      • exports alias
    • module.require(id)
    • module.id
    • module.filename
    • module.loaded
    • module.parent
    • module.children
  • All Together...
  • Loading from the global folders
  • Accessing the main module
  • Addenda: Package Manager Tips
• Addons
  • Hello world
  • Addon patterns
    • Function arguments
    • Callbacks
    • Object factory
    • Function factory
    • Wrapping C++ objects
    • Factory of wrapped objects
    • Passing wrapped objects around
• process
  • Event: 'exit'
  • Event: 'uncaughtException'
  • Signal Events
  • process.stdout
  • process.stderr
  • process.stdin
  • process.argv
  • process.execPath
  • process.execArgv
  • process.abort()
  • process.chdir(directory)
  • process.cwd()
  • process.env
  • process.exit([code])
  • process.getgid()
  • process.setgid(id)
  • process.getuid()
  • process.setuid(id)
  • process.getgroups()
  • process.setgroups(groups)
  • process.initgroups(user, extra_group)
  • process.version
  • process.versions
  • process.config
  • process.kill(pid, [signal])
  • process.pid
  • process.title
  • process.arch
  • process.platform
  • process.memoryUsage()
  • process.nextTick(callback)
  • process.maxTickDepth
  • process.umask([mask])
  • process.uptime()
  • process.hrtime()
• util
  • util.format(format, [...])
  • util.debug(string)
  • util.error([...])
  • util.puts([...])
  • util.print([...])
  • util.log(string)
  • util.inspect(object, [options])
    • Customizing util.inspect colors
  • util.isArray(object)
  • util.isRegExp(object)
  • util.isDate(object)
  • util.isError(object)
  • util.pump(readableStream, writableStream, [callback])
  • util.inherits(constructor, superConstructor)
• Events
  • Class: events.EventEmitter
    • emitter.addListener(event, listener)
    • emitter.on(event, listener)
    • emitter.once(event, listener)
    • emitter.removeListener(event, listener)
    • emitter.removeAllListeners([event])
    • emitter.setMaxListeners(n)
    • emitter.listeners(event)
    • emitter.emit(event, [arg1], [arg2], [...])
    • Class Method: EventEmitter.listenerCount(emitter, event)
    • Event: 'newListener'
    • Event: 'removeListener'
• Domain
  • Warning: Don't Ignore Errors!
  • Additions to Error objects
  • Implicit Binding
  • Explicit Binding
  • domain.create()
  • Class: Domain
    • domain.run(fn)
    • domain.members
    • domain.add(emitter)
    • domain.remove(emitter)
    • domain.bind(callback)
      • Example
    • domain.intercept(callback)
      • Example
    • domain.enter()
    • domain.exit()
    • domain.dispose()
• Buffer
  • Class: Buffer
    • new Buffer(size)
    • new Buffer(array)
    • new Buffer(str, [encoding])
    • Class Method: Buffer.isEncoding(encoding)
    • buf.write(string, [offset], [length], [encoding])
    • buf.toString([encoding], [start], [end])
    • buf.toJSON()
    • buf[index]
    • Class Method: Buffer.isBuffer(obj)
    • Class Method: Buffer.byteLength(string, [encoding])
    • Class Method: Buffer.concat(list, [totalLength])
    • buf.length
    • buf.copy(targetBuffer, [targetStart], [sourceStart], [sourceEnd])
    • buf.slice([start], [end])
    • buf.readUInt8(offset, [noAssert])
    • buf.readUInt16LE(offset, [noAssert])
    • buf.readUInt16BE(offset, [noAssert])
    • buf.readUInt32LE(offset, [noAssert])
    • buf.readUInt32BE(offset, [noAssert])
    • buf.readInt8(offset, [noAssert])
    • buf.readInt16LE(offset, [noAssert])
    • buf.readInt16BE(offset, [noAssert])
    • buf.readInt32LE(offset, [noAssert])
    • buf.readInt32BE(offset, [noAssert])
    • buf.readFloatLE(offset, [noAssert])
    • buf.readFloatBE(offset, [noAssert])
    • buf.readDoubleLE(offset, [noAssert])
    • buf.readDoubleBE(offset, [noAssert])
    • buf.writeUInt8(value, offset, [noAssert])
    • buf.writeUInt16LE(value, offset, [noAssert])
    • buf.writeUInt16BE(value, offset, [noAssert])
    • buf.writeUInt32LE(value, offset, [noAssert])
    • buf.writeUInt32BE(value, offset, [noAssert])
    • buf.writeInt8(value, offset, [noAssert])
    • buf.writeInt16LE(value, offset, [noAssert])
    • buf.writeInt16BE(value, offset, [noAssert])
    • buf.writeInt32LE(value, offset, [noAssert])
    • buf.writeInt32BE(value, offset, [noAssert])
    • buf.writeFloatLE(value, offset, [noAssert])
    • buf.writeFloatBE(value, offset, [noAssert])
    • buf.writeDoubleLE(value, offset, [noAssert])
    • buf.writeDoubleBE(value, offset, [noAssert])
    • buf.fill(value, [offset], [end])
  • buffer.INSPECT_MAX_BYTES
  • Class: SlowBuffer
• Stream
  • API for Stream Consumers
    • Class: stream.Readable
      • Event: 'readable'
      • Event: 'data'
      • Event: 'end'
      • Event: 'close'
      • Event: 'error'
      • readable.read([size])
      • readable.setEncoding(encoding)
      • readable.resume()
      • readable.pause()
      • readable.pipe(destination, [options])
      • readable.unpipe([destination])
      • readable.unshift(chunk)
      • readable.wrap(stream)
    • Class: stream.Writable
      • writable.write(chunk, [encoding], [callback])
      • Event: 'drain'
      • writable.end([chunk], [encoding], [callback])
      • Event: 'finish'
      • Event: 'pipe'
      • Event: 'unpipe'
      • Event: 'error'
    • Class: stream.Duplex
    • Class: stream.Transform
  • API for Stream Implementors
    • Class: stream.Readable
      • Example: A Counting Stream
      • Example: SimpleProtocol v1 (Sub-optimal)
      • new stream.Readable([options])
      • readable._read(size)
      • readable.push(chunk, [encoding])
    • Class: stream.Writable
      • new stream.Writable([options])
      • writable._write(chunk, encoding, callback)
    • Class: stream.Duplex
      • new stream.Duplex(options)
    • Class: stream.Transform
      • new stream.Transform([options])
      • transform._transform(chunk, encoding, callback)
      • transform._flush(callback)
      • Events: 'finish' and 'end'
      • Example: SimpleProtocol parser v2
    • Class: stream.PassThrough
  • Streams: Under the Hood
    • Buffering
    • stream.read(0)
    • stream.push('')
    • Compatibility with Older Node Versions
    • Object Mode
    • State Objects
• Crypto
  • crypto.getCiphers()
  • crypto.getHashes()
  • crypto.createCredentials(details)
  • crypto.createHash(algorithm)
  • Class: Hash
    • hash.update(data, [input_encoding])
    • hash.digest([encoding])
  • crypto.createHmac(algorithm, key)
  • Class: Hmac
    • hmac.update(data)
    • hmac.digest([encoding])
  • crypto.createCipher(algorithm, password)
  • crypto.createCipheriv(algorithm, key, iv)
  • Class: Cipher
    • cipher.update(data, [input_encoding], [output_encoding])
    • cipher.final([output_encoding])
    • cipher.setAutoPadding(auto_padding=true)
  • crypto.createDecipher(algorithm, password)
  • crypto.createDecipheriv(algorithm, key, iv)
  • Class: Decipher
    • decipher.update(data, [input_encoding], [output_encoding])
    • decipher.final([output_encoding])
    • decipher.setAutoPadding(auto_padding=true)
  • crypto.createSign(algorithm)
  • Class: Sign
    • sign.update(data)
    • sign.sign(private_key, [output_format])
  • crypto.createVerify(algorithm)
  • Class: Verify
    • verifier.update(data)
    • verifier.verify(object, signature, [signature_format])
  • crypto.createDiffieHellman(prime_length)
  • crypto.createDiffieHellman(prime, [encoding])
  • Class: DiffieHellman
    • diffieHellman.generateKeys([encoding])
    • diffieHellman.computeSecret(other_public_key, [input_encoding], [output_encoding])
    • diffieHellman.getPrime([encoding])
    • diffieHellman.getGenerator([encoding])
    • diffieHellman.getPublicKey([encoding])
    • diffieHellman.getPrivateKey([encoding])
    • diffieHellman.setPublicKey(public_key, [encoding])
    • diffieHellman.setPrivateKey(private_key, [encoding])
  • crypto.getDiffieHellman(group_name)
  • crypto.pbkdf2(password, salt, iterations, keylen, callback)
  • crypto.pbkdf2Sync(password, salt, iterations, keylen)
  • crypto.randomBytes(size, [callback])
  • crypto.pseudoRandomBytes(size, [callback])
  • crypto.DEFAULT_ENCODING
  • Recent API Changes
• TLS (SSL)
  • Protocol support
  • Client-initiated renegotiation attack mitigation
  • NPN and SNI
  • tls.getCiphers()
  • tls.createServer(options, [secureConnectionListener])
  • tls.SLAB_BUFFER_SIZE
  • tls.connect(options, [callback])
  • tls.connect(port, [host], [options], [callback])
  • tls.createSecurePair([credentials], [isServer], [requestCert], [rejectUnauthorized])
  • Class: SecurePair
    • Event: 'secure'
  • Class: tls.Server
    • Event: 'secureConnection'
    • Event: 'clientError'
    • Event: 'newSession'
    • Event: 'resumeSession'
    • server.listen(port, [host], [callback])
    • server.close()
    • server.address()
    • server.addContext(hostname, credentials)
    • server.maxConnections
    • server.connections
  • Class: CryptoStream
    • cryptoStream.bytesWritten
  • Class: tls.CleartextStream
    • Event: 'secureConnect'
    • cleartextStream.authorized
    • cleartextStream.authorizationError
    • cleartextStream.getPeerCertificate()
    • cleartextStream.getCipher()
    • cleartextStream.address()
    • cleartextStream.remoteAddress
    • cleartextStream.remotePort
• StringDecoder
  • Class: StringDecoder
    • decoder.write(buffer)
    • decoder.end()
• File System
  • fs.rename(oldPath, newPath, callback)
  • fs.renameSync(oldPath, newPath)
  • fs.ftruncate(fd, len, callback)
  • fs.ftruncateSync(fd, len)
  • fs.truncate(path, len, callback)
  • fs.truncateSync(path, len)
  • fs.chown(path, uid, gid, callback)
  • fs.chownSync(path, uid, gid)
  • fs.fchown(fd, uid, gid, callback)
  • fs.fchownSync(fd, uid, gid)
  • fs.lchown(path, uid, gid, callback)
  • fs.lchownSync(path, uid, gid)
  • fs.chmod(path, mode, callback)
  • fs.chmodSync(path, mode)
  • fs.fchmod(fd, mode, callback)
  • fs.fchmodSync(fd, mode)
  • fs.lchmod(path, mode, callback)
  • fs.lchmodSync(path, mode)
  • fs.stat(path, callback)
  • fs.lstat(path, callback)
  • fs.fstat(fd, callback)
  • fs.statSync(path)
  • fs.lstatSync(path)
  • fs.fstatSync(fd)
  • fs.link(srcpath, dstpath, callback)
  • fs.linkSync(srcpath, dstpath)
  • fs.symlink(srcpath, dstpath, [type], callback)
  • fs.symlinkSync(srcpath, dstpath, [type])
  • fs.readlink(path, callback)
  • fs.readlinkSync(path)
  • fs.realpath(path, [cache], callback)
  • fs.realpathSync(path, [cache])
  • fs.unlink(path, callback)
  • fs.unlinkSync(path)
  • fs.rmdir(path, callback)
  • fs.rmdirSync(path)
  • fs.mkdir(path, [mode], callback)
  • fs.mkdirSync(path, [mode])
  • fs.readdir(path, callback)
  • fs.readdirSync(path)
  • fs.close(fd, callback)
  • fs.closeSync(fd)
  • fs.open(path, flags, [mode], callback)
  • fs.openSync(path, flags, [mode])
  • fs.utimes(path, atime, mtime, callback)
  • fs.utimesSync(path, atime, mtime)
  • fs.futimes(fd, atime, mtime, callback)
  • fs.futimesSync(fd, atime, mtime)
  • fs.fsync(fd, callback)
  • fs.fsyncSync(fd)
  • fs.write(fd, buffer, offset, length, position, callback)
  • fs.writeSync(fd, buffer, offset, length, position)
  • fs.read(fd, buffer, offset, length, position, callback)
  • fs.readSync(fd, buffer, offset, length, position)
  • fs.readFile(filename, [options], callback)
  • fs.readFileSync(filename, [options])
  • fs.writeFile(filename, data, [options], callback)
  • fs.writeFileSync(filename, data, [options])
  • fs.appendFile(filename, data, [options], callback)
  • fs.appendFileSync(filename, data, [options])
  • fs.watchFile(filename, [options], listener)
  • fs.unwatchFile(filename, [listener])
  • fs.watch(filename, [options], [listener])
    • Caveats
      • Availability
      • Filename Argument
  • fs.exists(path, callback)
  • fs.existsSync(path)
  • Class: fs.Stats
  • fs.createReadStream(path, [options])
  • Class: fs.ReadStream
    • Event: 'open'
  • fs.createWriteStream(path, [options])
  • Class: fs.WriteStream
    • Event: 'open'
    • file.bytesWritten
  • Class: fs.FSWatcher
    • watcher.close()
    • Event: 'change'
    • Event: 'error'
• Path
  • path.normalize(p)
  • path.join([path1], [path2], [...])
  • path.resolve([from ...], to)
  • path.relative(from, to)
  • path.dirname(p)
  • path.basename(p, [ext])
  • path.extname(p)
  • path.sep
  • path.delimiter
• net
  • net.createServer([options], [connectionListener])
  • net.connect(options, [connectionListener])
  • net.createConnection(options, [connectionListener])
  • net.connect(port, [host], [connectListener])
  • net.createConnection(port, [host], [connectListener])
  • net.connect(path, [connectListener])
  • net.createConnection(path, [connectListener])
  • Class: net.Server
    • server.listen(port, [host], [backlog], [callback])
    • server.listen(path, [callback])
    • server.listen(handle, [callback])
    • server.close([callback])
    • server.address()
    • server.unref()
    • server.ref()
    • server.maxConnections
    • server.connections
    • server.getConnections(callback)
    • Event: 'listening'
    • Event: 'connection'
    • Event: 'close'
    • Event: 'error'
  • Class: net.Socket
    • new net.Socket([options])
    • socket.connect(port, [host], [connectListener])
    • socket.connect(path, [connectListener])
    • socket.bufferSize
    • socket.setEncoding([encoding])
    • socket.write(data, [encoding], [callback])
    • socket.end([data], [encoding])
    • socket.destroy()
    • socket.pause()
    • socket.resume()
    • socket.setTimeout(timeout, [callback])
    • socket.setNoDelay([noDelay])
    • socket.setKeepAlive([enable], [initialDelay])
    • socket.address()
    • socket.unref()
    • socket.ref()
    • socket.remoteAddress
    • socket.remotePort
    • socket.localAddress
    • socket.localPort
    • socket.bytesRead
    • socket.bytesWritten
    • Event: 'connect'
    • Event: 'data'
    • Event: 'end'
    • Event: 'timeout'
    • Event: 'drain'
    • Event: 'error'
    • Event: 'close'
  • net.isIP(input)
  • net.isIPv4(input)
  • net.isIPv6(input)
• UDP / Datagram Sockets
  • dgram.createSocket(type, [callback])
  • Class: dgram.Socket
    • Event: 'message'
    • Event: 'listening'
    • Event: 'close'
    • Event: 'error'
    • socket.send(buf, offset, length, port, address, [callback])
    • socket.bind(port, [address], [callback])
    • socket.close()
    • socket.address()
    • socket.setBroadcast(flag)
    • socket.setTTL(ttl)
    • socket.setMulticastTTL(ttl)
    • socket.setMulticastLoopback(flag)
    • socket.addMembership(multicastAddress, [multicastInterface])
    • socket.dropMembership(multicastAddress, [multicastInterface])
    • socket.unref()
    • socket.ref()
• DNS
  • dns.lookup(domain, [family], callback)
  • dns.resolve(domain, [rrtype], callback)