Please enable JavaScript.

Coggle requires JavaScript to display documents.

NodeJS (Console (new Console(stdout[, stderr]), assert(value[, message][, …

- - - - "close"
      - "connection"
      - "error"
      - "listening"
    - - address()
      - close([callback])
      - getConnections(callback)
        
        (err, count)
      - listen(options[, callback])
        
        options
        
        port
        
        host
        
        backlog
        
        path
        
        exclusive
      - listen([port][, hostname][, backlog][, callback])
  - - - "close"
      - "connect"
      - "data"
      - "drain"
      - "end"
      - "error"
      - "lookup"
      - "timeout"
    - - address()
      - connect(options[, connectListener])
      - connect(port[, host][, connectListener])
      - end([data][, encoding])
      - pause() / resume()
      - setKeepAlive([enable][, initialDelay])
      - setTimeout(timeout[, callback])
      - write(data[, encoding][, callback])
- - - - fs.watchFile(filename[, options], listener)
        
        listener: (curr, prev)
      - fs.watch(filename[, options][, listener])
        
        listener: (eventType, filename)
      - fs.stat(path, callback)
      - fs.rename(oldPath, newPath, callback)
      - fs.open(path, flags[, mode], callback) -> fd (fild descriptor)
      - fs.close(fd, callback)
      - fs.access(path[, mode], callback) : do not use access before open/read a file, since other processes may change it.
    - - fs.createReadStream(path[, options])
      - fs.readFile(file[, options], callback)
      - fs.read(fd, buffer, offset, length, position, callback)
    - - fs.writeFile(file, data[, options], callback)
      - fs.write(fd, string[, position[, encoding]], callback)
      - fs.write(fd, buffer[, offset[, length[, position]]], callback)
      - fs.createWriteStream(path[, options])
      - fs.appendFile(file, data[, options], callback)
- - - - "close" : the stream and any underlying resources have been closed
      - "drain" : it is appropriate to resume writing data to the stream
      - "error"
      - "finish" : after call stream.end(), and all data has been flushed
      - "pipe" : when the stream.pipe() method is called on a readable stream, adding this writable to its set of destinations.
      - "unpipe" : call stream.unpipe()
    - - cork() : forces all written data to be buffered in memory.
      - end([chunk][, encoding][, callback])
      - setDefaultEncoding(encoding)
      - uncork() : flushes all data buffered since stream.cork() was called.
      - write(chunk[, encoding][, callback]) -> <boolean>
  - - - flowing mode
        
        Adding a 'data' event handler.
        
        Calling the stream.resume() method.
        
        Calling the stream.pipe() method
      - paused mode
        
        calling the stream.pause() method
        
        removing any 'data' event handlers
        
        calling the stream.unpipe()
    - - "close" : when the stream and any of its underlying resources (a file descriptor, for example) have been closed
      - "data" -> chunk
      - "end"
      - "error"
      - "readable"
        
        new data is available -> data
        
        the end of the stream -> null
    - - pause() : cause a stream in flowing mode switching out of flowing mode. Any data that becomes available will remain in the internal buffer.
      - pipe(destination[, options])
      - read([size]) : pulls some data out of the internal buffer and returns it, should work with "readable" event.
      - resume()
      - setEncoding(encoding)
      - unpipe([destination])
      - unshift(chunk) : pushes a chunk of data back into the internal buffer
- - - - options
        
        input: the Readable stream to listen to.
        
        output: the Writable stream to write readline data to.
        
        completer: an optional function used for Tab autocompletion.
        
        prompt: the prompt string to use. Default: '> '
- - - - href -> protocol + // + auth + @ + host + path + # + hash
      - protocol
      - auth
      - host -> hostname + port
      - path -> pathname + search -> ? + query
      - hash
- - - - emit(eventName[,...args])
      - addListener(eventName, listener)
      - on(eventName, listener)
      - once(eventName, listener)
      - prependListener(eventName, listener)
      - prependOnceListener(eventName, listener)
      - removeAllListeners([eventName])
      - removeListener(eventName, listener)
      - setMaxListeners(n)
      - eventNames()
      - getMaxListeners()
      - listenerCount(eventName)
      - listeners(eventName)
    - - "error"
        
        process.on('uncaughtException', listener)
        
        emitter.on('error', listener)
      - "newListener"
      - "removeListener"
    - - defaultMaxListeners
    - - Dog.prototype.__proto__ = EventEmitter.prototype;
        Dog.prototype = Object.create(EventEmitter.prototype);
- - - - require(X) from module at path Y
        
        If X is a core module,
        a. return the core module
        b. STOP
        
        If X begins with '/'
        a. set Y to be the filesystem root
        
        If X begins with './' or '/' or '../'
        a. LOAD_AS_FILE(Y + X)
        b. LOAD_AS_DIRECTORY(Y + X)
        
        LOAD_NODE_MODULES(X, dirname(Y))
        
        THROW "not found"
      - Caching -> cached based on their resolved filename.
      - Cycles -> unfinished copy
    - - children
      - exports
      - filename
      - id
      - parent