查找

• Node.js Manual & Documentation
• About these Docs
• About this Documentation
• Stability Index
• JSON Output
• Synopsis
• Synopsis
• Assertion Testing
• Assert
• assert.fail(actual, expected, message, operator)
• assert(value, message), assert.ok(value, [message])
• assert.equal(actual, expected, [message])
• assert.notEqual(actual, expected, [message])
• assert.deepEqual(actual, expected, [message])
• assert.notDeepEqual(actual, expected, [message])
• assert.strictEqual(actual, expected, [message])
• assert.notStrictEqual(actual, expected, [message])
• assert.throws(block, [error], [message])
• assert.doesNotThrow(block, [message])
• assert.ifError(value)
• Buffer
• 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
• C/C++ Addons
• Addons
• Hello world
• Addon patterns
• Function arguments
• Callbacks
• Object factory
• Function factory
• Wrapping C++ objects
• Factory of wrapped objects
• Passing wrapped objects around
• Child Processes
• Child Process
• Class: ChildProcess
• Event: 'error'
• Event: 'exit'
• Event: 'close'
• Event: 'disconnect'
• Event: 'message'
• child.stdin
• child.stdout
• child.stderr
• child.pid
• child.kill([signal])
• child.send(message, [sendHandle])
• Example: sending server object
• Example: sending socket object
• child.disconnect()
• child_process.spawn(command, [args], [options])
• child_process.exec(command, [options], callback)
• child_process.execFile(file, args, options, callback)
• child_process.fork(modulePath, [args], [options])
• Cluster
• Cluster
• How It Works
• cluster.settings
• cluster.isMaster
• cluster.isWorker
• Event: 'fork'
• Event: 'online'
• Event: 'listening'
• Event: 'disconnect'
• Event: 'exit'
• Event: 'setup'
• cluster.setupMaster([settings])
• cluster.fork([env])
• cluster.disconnect([callback])
• cluster.worker
• cluster.workers
• Class: Worker
• worker.id
• worker.process
• worker.suicide
• worker.send(message, [sendHandle])
• worker.kill([signal='SIGTERM'])
• worker.disconnect()
• Event: 'message'
• Event: 'online'
• Event: 'listening'
• Event: 'disconnect'
• Event: 'exit'
• Console
• console
• console.log([data], [...])
• console.info([data], [...])
• console.error([data], [...])
• console.warn([data], [...])
• console.dir(obj)
• console.time(label)
• console.timeEnd(label)
• console.trace(label)
• console.assert(expression, [message])
• Crypto
• 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
• Debugger
• Debugger
• Watchers
• Commands reference
• Stepping
• Breakpoints
• Info
• Execution control
• Various
• Advanced Usage
• DNS
• DNS
• dns.lookup(domain, [family], callback)
• dns.resolve(domain, [rrtype], callback)
• dns.resolve4(domain, callback)
• dns.resolve6(domain, callback)
• dns.resolveMx(domain, callback)
• dns.resolveTxt(domain, callback)
• dns.resolveSrv(domain, callback)
• dns.resolveNs(domain, callback)
• dns.resolveCname(domain, callback)
• dns.reverse(ip, callback)
• Error codes
• Domain
• 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.dispose()
• Events
• 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'
• File System
• 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'
• Globals
• 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)
• HTTP
• HTTP
• http.STATUS_CODES
• http.createServer([requestListener])
• http.createClient([port], [host])
• Class: http.Server
• Event: 'request'
• Event: 'connection'
• Event: 'close'
• Event: 'checkContinue'
• Event: 'connect'
• Event: 'upgrade'
• Event: 'clientError'
• server.listen(port, [hostname], [backlog], [callback])
• server.listen(path, [callback])
• server.listen(handle, [callback])
• server.close([callback])
• server.maxHeadersCount
• server.setTimeout(msecs, callback)
• server.timeout
• Class: http.ServerResponse
• Event: 'close'
• response.writeContinue()
• response.writeHead(statusCode, [reasonPhrase], [headers])
• response.setTimeout(msecs, callback)
• response.statusCode
• response.setHeader(name, value)
• response.headersSent
• response.sendDate
• response.getHeader(name)
• response.removeHeader(name)
• response.write(chunk, [encoding])
• response.addTrailers(headers)
• response.end([data], [encoding])
• http.request(options, callback)
• http.get(options, callback)
• Class: http.Agent
• agent.maxSockets
• agent.sockets
• agent.requests
• http.globalAgent
• Class: http.ClientRequest
• Event 'response'
• Event: 'socket'
• Event: 'connect'
• Event: 'upgrade'
• Event: 'continue'
• request.write(chunk, [encoding])
• request.end([data], [encoding])
• request.abort()
• request.setTimeout(timeout, [callback])
• request.setNoDelay([noDelay])
• request.setSocketKeepAlive([enable], [initialDelay])
• http.IncomingMessage
• Event: 'close'
• message.httpVersion
• message.headers
• message.trailers
• message.setTimeout(msecs, callback)
• message.method
• message.url
• message.statusCode
• message.socket
• HTTPS
• HTTPS
• Class: https.Server
• https.createServer(options, [requestListener])
• server.listen(port, [host], [backlog], [callback])
• server.listen(path, [callback])
• server.listen(handle, [callback])
• server.close([callback])
• https.request(options, callback)
• https.get(options, callback)
• Class: https.Agent
• https.globalAgent
• Modules
• Modules
• Cycles
• Core Modules
• File Modules
• Loading from node_modules Folders
• Folders as Modules
• Caching
• Module Caching Caveats
• The module Object
• module.exports
• 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
• Net
• 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)
• OS
• os
• os.tmpdir()
• os.endianness()
• os.hostname()
• os.type()
• os.platform()
• os.arch()
• os.release()
• os.uptime()
• os.loadavg()
• os.totalmem()
• os.freemem()
• os.cpus()
• os.networkInterfaces()
• os.EOL
• Path
• 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
• Process
• process
• Event: 'exit'
• Event: 'uncaughtException'
• Signal Events
• process.stdout
• process.stderr
• process.stdin
• process.argv
• process.execPath
• 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()
• Punycode
• punycode
• punycode.decode(string)
• punycode.encode(string)
• punycode.toUnicode(domain)
• punycode.toASCII(domain)
• punycode.ucs2
• punycode.ucs2.decode(string)
• punycode.ucs2.encode(codePoints)
• punycode.version
• Query Strings
• Query String
• querystring.stringify(obj, [sep], [eq])
• querystring.parse(str, [sep], [eq], [options])
• querystring.escape
• querystring.unescape
• Readline
• Readline
• readline.createInterface(options)
• Class: Interface
• rl.setPrompt(prompt, length)
• rl.prompt([preserveCursor])
• rl.question(query, callback)
• rl.pause()
• rl.resume()
• rl.close()
• rl.write(data, [key])
• Events
• Event: 'line'
• Event: 'pause'
• Event: 'resume'
• Event: 'close'
• Event: 'SIGINT'
• Event: 'SIGTSTP'
• Event: 'SIGCONT'
• Example: Tiny CLI
• REPL
• REPL
• repl.start(options)
• Event: 'exit'
• REPL Features
• Stream
• 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'
• 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)
• 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
• String Decoder
• StringDecoder
• Class: StringDecoder
• decoder.write(buffer)
• decoder.end()
• Timers
• Timers
• setTimeout(callback, delay, [arg], [...])
• clearTimeout(timeoutId)
• setInterval(callback, delay, [arg], [...])
• clearInterval(intervalId)
• unref()
• ref()
• setImmediate(callback, [arg], [...])
• clearImmediate(immediateId)
• TLS/SSL
• TLS (SSL)
• 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
• TTY
• TTY
• tty.isatty(fd)
• tty.setRawMode(mode)
• Class: ReadStream
• rs.isRaw
• rs.setRawMode(mode)
• Class: WriteStream
• ws.columns
• ws.rows
• Event: 'resize'
• UDP/Datagram
• 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()
• URL
• URL
• url.parse(urlStr, [parseQueryString], [slashesDenoteHost])
• url.format(urlObj)
• url.resolve(from, to)
• Utilities
• 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)
• VM
• Executing JavaScript
• Caveats
• Sandboxes
• Globals
• vm.runInThisContext(code, [filename])
• vm.runInNewContext(code, [sandbox], [filename])
• vm.runInContext(code, context, [filename])
• vm.createContext([initSandbox])
• vm.createScript(code, [filename])
• Class: Script
• script.runInThisContext()
• script.runInNewContext([sandbox])
• ZLIB
• Zlib
• Examples
• zlib.createGzip([options])
• zlib.createGunzip([options])
• zlib.createDeflate([options])
• zlib.createInflate([options])
• zlib.createDeflateRaw([options])
• zlib.createInflateRaw([options])
• zlib.createUnzip([options])
• Class: zlib.Zlib
• zlib.flush(callback)
• zlib.reset()
• Class: zlib.Gzip
• Class: zlib.Gunzip
• Class: zlib.Deflate
• Class: zlib.Inflate
• Class: zlib.DeflateRaw
• Class: zlib.InflateRaw
• Class: zlib.Unzip
• Convenience Methods
• zlib.deflate(buf, callback)
• zlib.deflateRaw(buf, callback)
• zlib.gzip(buf, callback)
• zlib.gunzip(buf, callback)
• zlib.inflate(buf, callback)
• zlib.inflateRaw(buf, callback)
• zlib.unzip(buf, callback)
• Options
• Memory Usage Tuning
• Constants
• Check Update