Options
All
  • Public
  • Public/Protected
  • All
Menu

Hierarchy

Callable

Index

Properties

_router

_router: any

Used to get all registered routes in Express Application

all

Special-cased "all" method, applying the given route path, middleware, and callback to every HTTP method.

checkout

checkout: IRouterMatcher<Application, any>

connect

copy

delete

delete: IRouterMatcher<Application, "delete">

get

get: (name: string) => any & IRouterMatcher<Application, any>

head

locals

locals: Record<string, any>

lock

m-search

m-search: IRouterMatcher<Application, any>

map

map: any

merge

mkactivity

mkactivity: IRouterMatcher<Application, any>

mkcol

mountpath

mountpath: string | string[]

The app.mountpath property contains one or more path patterns on which a sub-app was mounted.

move

notify

options

options: IRouterMatcher<Application, "options">

patch

patch: IRouterMatcher<Application, "patch">

post

propfind

propfind: IRouterMatcher<Application, any>

proppatch

proppatch: IRouterMatcher<Application, any>

purge

put

report

resource

resource: any

router

router: string

routes

routes: any

The app.routes object houses all of the routes defined mapped by the associated HTTP verb. This object may be used for introspection capabilities, for example Express uses this internally not only for routing but to provide default OPTIONS behaviour unless app.options() is used. Your application or framework may also remove routes by simply by removing them from this object.

search

settings

settings: any

stack

stack: any[]

Stack of configured routes

subscribe

subscribe: IRouterMatcher<Application, any>

trace

unlock

unsubscribe

unsubscribe: IRouterMatcher<Application, any>

use

Methods

addListener

  • addListener(eventName: string | symbol, listener: (...args: any[]) => void): Application
  • Alias for emitter.on(eventName, listener).

    since

    v0.1.26

    Parameters

    • eventName: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns Application

defaultConfiguration

  • defaultConfiguration(): void
  • Initialize application configuration.

    Returns void

disable

  • Disable setting.

    Parameters

    • setting: string

    Returns Application

disabled

  • disabled(setting: string): boolean
  • Check if setting is disabled.

    app.disabled('foo') // => true

    app.enable('foo') app.disabled('foo') // => false

    Parameters

    • setting: string

    Returns boolean

emit

  • emit(eventName: string | symbol, ...args: any[]): boolean
  • Synchronously calls each of the listeners registered for the event namedeventName, in the order they were registered, passing the supplied arguments to each.

    Returns true if the event had listeners, false otherwise.

    const EventEmitter = require('events');
    const myEmitter = new EventEmitter();
    
    // First listener
    myEmitter.on('event', function firstListener() {
      console.log('Helloooo! first listener');
    });
    // Second listener
    myEmitter.on('event', function secondListener(arg1, arg2) {
      console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
    });
    // Third listener
    myEmitter.on('event', function thirdListener(...args) {
      const parameters = args.join(', ');
      console.log(`event with parameters ${parameters} in third listener`);
    });
    
    console.log(myEmitter.listeners('event'));
    
    myEmitter.emit('event', 1, 2, 3, 4, 5);
    
    // Prints:
    // [
    //   [Function: firstListener],
    //   [Function: secondListener],
    //   [Function: thirdListener]
    // ]
    // Helloooo! first listener
    // event with parameters 1, 2 in second listener
    // event with parameters 1, 2, 3, 4, 5 in third listener
    
    since

    v0.1.26

    Parameters

    • eventName: string | symbol
    • Rest ...args: any[]

    Returns boolean

enable

  • Enable setting.

    Parameters

    • setting: string

    Returns Application

enabled

  • enabled(setting: string): boolean
  • Check if setting is enabled (truthy).

    app.enabled('foo') // => false

    app.enable('foo') app.enabled('foo') // => true

    Parameters

    • setting: string

    Returns boolean

engine

  • engine(ext: string, fn: (path: string, options: object, callback: (e: any, rendered?: string) => void) => void): Application
  • Register the given template engine callback fn as ext.

    By default will require() the engine based on the file extension. For example if you try to render a "foo.jade" file Express will invoke the following internally:

    app.engine('jade', require('jade').__express);
    

    For engines that do not provide .__express out of the box, or if you wish to "map" a different extension to the template engine you may use this method. For example mapping the EJS template engine to ".html" files:

    app.engine('html', require('ejs').renderFile);
    

    In this case EJS provides a .renderFile() method with the same signature that Express expects: (path, options, callback), though note that it aliases this method as ejs.__express internally so if you're using ".ejs" extensions you dont need to do anything.

    Some template engines do not follow this convention, the Consolidate.js library was created to map all of node's popular template engines to follow this convention, thus allowing them to work seamlessly within Express.

    Parameters

    • ext: string
    • fn: (path: string, options: object, callback: (e: any, rendered?: string) => void) => void
        • (path: string, options: object, callback: (e: any, rendered?: string) => void): void
        • Parameters

          • path: string
          • options: object
          • callback: (e: any, rendered?: string) => void
              • (e: any, rendered?: string): void
              • Parameters

                • e: any
                • Optional rendered: string

                Returns void

          Returns void

    Returns Application

eventNames

  • eventNames(): (string | symbol)[]
  • Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or Symbols.

    const EventEmitter = require('events');
    const myEE = new EventEmitter();
    myEE.on('foo', () => {});
    myEE.on('bar', () => {});
    
    const sym = Symbol('symbol');
    myEE.on(sym, () => {});
    
    console.log(myEE.eventNames());
    // Prints: [ 'foo', 'bar', Symbol(symbol) ]
    
    since

    v6.0.0

    Returns (string | symbol)[]

getMaxListeners

  • getMaxListeners(): number
  • Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to defaultMaxListeners.

    since

    v1.0.0

    Returns number

init

  • init(): void
  • Initialize the server.

    • setup default configuration
    • setup default middleware
    • setup route reflection methods

    Returns void

listen

  • listen(port: number, hostname: string, backlog: number, callback?: () => void): Server
  • listen(port: number, hostname: string, callback?: () => void): Server
  • listen(port: number, callback?: () => void): Server
  • listen(callback?: () => void): Server
  • listen(path: string, callback?: () => void): Server
  • listen(handle: any, listeningListener?: () => void): Server
  • Listen for connections.

    A node http.Server is returned, with this application (which is a Function) as its callback. If you wish to create both an HTTP and HTTPS server you may do so with the "http" and "https" modules as shown here:

    var http = require('http') , https = require('https') , express = require('express') , app = express();

    http.createServer(app).listen(80); https.createServer({ ... }, app).listen(443);

    Parameters

    • port: number
    • hostname: string
    • backlog: number
    • Optional callback: () => void
        • (): void
        • Returns void

    Returns Server

  • Parameters

    • port: number
    • hostname: string
    • Optional callback: () => void
        • (): void
        • Returns void

    Returns Server

  • Parameters

    • port: number
    • Optional callback: () => void
        • (): void
        • Returns void

    Returns Server

  • Parameters

    • Optional callback: () => void
        • (): void
        • Returns void

    Returns Server

  • Parameters

    • path: string
    • Optional callback: () => void
        • (): void
        • Returns void

    Returns Server

  • Parameters

    • handle: any
    • Optional listeningListener: () => void
        • (): void
        • Returns void

    Returns Server

listenerCount

  • listenerCount(eventName: string | symbol): number
  • Returns the number of listeners listening to the event named eventName.

    since

    v3.2.0

    Parameters

    • eventName: string | symbol

      The name of the event being listened for

    Returns number

listeners

  • listeners(eventName: string | symbol): Function[]
  • Returns a copy of the array of listeners for the event named eventName.

    server.on('connection', (stream) => {
      console.log('someone connected!');
    });
    console.log(util.inspect(server.listeners('connection')));
    // Prints: [ [Function] ]
    
    since

    v0.1.26

    Parameters

    • eventName: string | symbol

    Returns Function[]

off

  • off(eventName: string | symbol, listener: (...args: any[]) => void): Application
  • Alias for emitter.removeListener().

    since

    v10.0.0

    Parameters

    • eventName: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns Application

on

  • on(event: string, callback: (parent: Application<Record<string, any>>) => void): this
  • The mount event is fired on a sub-app, when it is mounted on a parent app. The parent app is passed to the callback function.

    NOTE: Sub-apps will:

    • Not inherit the value of settings that have a default value. You must set the value in the sub-app.
    • Inherit the value of settings with no default value.

    Parameters

    Returns this

once

  • once(eventName: string | symbol, listener: (...args: any[]) => void): Application
  • Adds a one-timelistener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
      console.log('Ah, we have our first user!');
    });
    

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. Theemitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    //   b
    //   a
    
    since

    v0.3.0

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: (...args: any[]) => void

      The callback function

        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns Application

param

  • Map the given param placeholder name(s) to the given callback(s).

    Parameter mapping is used to provide pre-conditions to routes which use normalized placeholders. For example a :user_id parameter could automatically load a user's information from the database without any additional code,

    The callback uses the samesignature as middleware, the only differencing being that the value of the placeholder is passed, in this case the id of the user. Once the next() function is invoked, just like middleware it will continue on to execute the route, or subsequent parameter functions.

     app.param('user_id', function(req, res, next, id){
       User.find(id, function(err, user){
         if (err) {
           next(err);
         } else if (user) {
           req.user = user;
           next();
         } else {
           next(new Error('failed to load user'));
         }
       });
     });
    

    Parameters

    Returns Application

  • Alternatively, you can pass only a callback, in which case you have the opportunity to alter the app.param()

    deprecated

    since version 4.11

    Parameters

    Returns Application

path

  • path(): string
  • Return the app's absolute pathname based on the parent(s) that have mounted it.

    For example if the application was mounted as "/admin", which itself was mounted as "/blog" then the return value would be "/blog/admin".

    Returns string

prependListener

  • prependListener(eventName: string | symbol, listener: (...args: any[]) => void): Application
  • Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventNameand listener will result in the listener being added, and called, multiple times.

    server.prependListener('connection', (stream) => {
      console.log('someone connected!');
    });
    

    Returns a reference to the EventEmitter, so that calls can be chained.

    since

    v6.0.0

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: (...args: any[]) => void

      The callback function

        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns Application

prependOnceListener

  • prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): Application
  • Adds a one-timelistener function for the event named eventName to the_beginning_ of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

    server.prependOnceListener('connection', (stream) => {
      console.log('Ah, we have our first user!');
    });
    

    Returns a reference to the EventEmitter, so that calls can be chained.

    since

    v6.0.0

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: (...args: any[]) => void

      The callback function

        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns Application

rawListeners

  • rawListeners(eventName: string | symbol): Function[]
  • Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

    const emitter = new EventEmitter();
    emitter.once('log', () => console.log('log once'));
    
    // Returns a new Array with a function `onceWrapper` which has a property
    // `listener` which contains the original listener bound above
    const listeners = emitter.rawListeners('log');
    const logFnWrapper = listeners[0];
    
    // Logs "log once" to the console and does not unbind the `once` event
    logFnWrapper.listener();
    
    // Logs "log once" to the console and removes the listener
    logFnWrapper();
    
    emitter.on('log', () => console.log('log persistently'));
    // Will return a new Array with a single function bound by `.on()` above
    const newListeners = emitter.rawListeners('log');
    
    // Logs "log persistently" twice
    newListeners[0]();
    emitter.emit('log');
    
    since

    v9.4.0

    Parameters

    • eventName: string | symbol

    Returns Function[]

removeAllListeners

  • removeAllListeners(event?: string | symbol): Application
  • Removes all listeners, or those of the specified eventName.

    It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

    Returns a reference to the EventEmitter, so that calls can be chained.

    since

    v0.1.26

    Parameters

    • Optional event: string | symbol

    Returns Application

removeListener

  • removeListener(eventName: string | symbol, listener: (...args: any[]) => void): Application
  • Removes the specified listener from the listener array for the event namedeventName.

    const callback = (stream) => {
      console.log('someone connected!');
    };
    server.on('connection', callback);
    // ...
    server.removeListener('connection', callback);
    

    removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

    Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that anyremoveListener() or removeAllListeners() calls after emitting and_before_ the last listener finishes execution will not remove them fromemit() in progress. Subsequent events behave as expected.

    const myEmitter = new MyEmitter();
    
    const callbackA = () => {
      console.log('A');
      myEmitter.removeListener('event', callbackB);
    };
    
    const callbackB = () => {
      console.log('B');
    };
    
    myEmitter.on('event', callbackA);
    
    myEmitter.on('event', callbackB);
    
    // callbackA removes listener callbackB but it will still be called.
    // Internal listener array at time of emit [callbackA, callbackB]
    myEmitter.emit('event');
    // Prints:
    //   A
    //   B
    
    // callbackB is now removed.
    // Internal listener array [callbackA]
    myEmitter.emit('event');
    // Prints:
    //   A
    

    Because listeners are managed using an internal array, calling this will change the position indices of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

    When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping')listener is removed:

    const ee = new EventEmitter();
    
    function pong() {
      console.log('pong');
    }
    
    ee.on('ping', pong);
    ee.once('ping', pong);
    ee.removeListener('ping', pong);
    
    ee.emit('ping');
    ee.emit('ping');
    

    Returns a reference to the EventEmitter, so that calls can be chained.

    since

    v0.1.26

    Parameters

    • eventName: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns Application

render

  • render(name: string, options?: object, callback?: (err: Error, html: string) => void): void
  • render(name: string, callback: (err: Error, html: string) => void): void
  • Render the given view name name with options and a callback accepting an error and the rendered template string.

    Example:

    app.render('email', { name: 'Tobi' }, function(err, html){ // ... })

    Parameters

    • name: string
    • Optional options: object
    • Optional callback: (err: Error, html: string) => void
        • (err: Error, html: string): void
        • Parameters

          • err: Error
          • html: string

          Returns void

    Returns void

  • Parameters

    • name: string
    • callback: (err: Error, html: string) => void
        • (err: Error, html: string): void
        • Parameters

          • err: Error
          • html: string

          Returns void

    Returns void

route

  • Type parameters

    • T: string

    Parameters

    • prefix: T

    Returns IRoute<T>

  • Parameters

    Returns IRoute<string>

set

  • Assign setting to val, or return setting's value.

    app.set('foo', 'bar'); app.get('foo'); // => "bar" app.set('foo', ['bar', 'baz']); app.get('foo'); // => ["bar", "baz"]

    Mounted servers inherit their parent server's settings.

    Parameters

    • setting: string
    • val: any

    Returns Application

setMaxListeners

  • By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set toInfinity (or 0) to indicate an unlimited number of listeners.

    Returns a reference to the EventEmitter, so that calls can be chained.

    since

    v0.3.5

    Parameters

    • n: number

    Returns Application