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

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 same signature as middleware, the only difference 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.

Just like in middleware, you must either respond to the request or call next to avoid stalling the request.

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

Use the given middleware function, with optional path, defaulting to "/".

Use (like .all) will run for any http METHOD, but it will not add handlers for those methods so OPTIONS requests will not consider .use functions even if they could respond.

The other difference is that route path is stripped and not visible to the handler function. The main effect of this feature is that mounted handlers can operate without any code changes regardless of the "prefix" pathname.

Create a new Route for the given path.

Each route contains a separate middleware stack and VERB handlers.

See the Route api documentation for details on adding handlers and middleware to routes.

Return request header.

The Referrer header field is special-cased, both Referrer and Referer are interchangeable.

Examples:

req.get('Content-Type');
// => "text/plain"

req.get('content-type');
// => "text/plain"

req.get('Something');
// => undefined

Aliased as req.header().

To do: update docs.

Check if the given type(s) is acceptable, returning the best match when true, otherwise undefined, in which case you should respond with 406 "Not Acceptable".

The type value may be a single MIME type string such as "application/json", an extension name such as "json", a comma-delimited list such as "json, html, text/plain", an argument list such as "json", "html", "text/plain", or an array ["json", "html", "text/plain"]. When a list or array is given, the best match, if any is returned.

Examples:

// Accept: text/html
req.accepts('html');
// => "html"

// Accept: text/*, application/json
req.accepts('html');
// => "html"
req.accepts('text/html');
// => "text/html"
req.accepts('json, text');
// => "json"
req.accepts('application/json');
// => "application/json"

// Accept: text/*, application/json
req.accepts('image/png');
req.accepts('png');
// => undefined

// Accept: text/*;q=.5, application/json
req.accepts(['html', 'json']);
req.accepts('html', 'json');
req.accepts('html, json');
// => "json"

Check if the given encodings are accepted.

Check if the given charsets are acceptable, otherwise you should respond with 406 "Not Acceptable".

Check if the given langs are acceptable, otherwise you should respond with 406 "Not Acceptable".

Parse Range header field, capping to the given size.

Unspecified ranges such as "0-" require knowledge of your resource length. In the case of a byte range this is of course the total number of bytes. If the Range header field is not given undefined is returned, -1 when unsatisfiable, and -2 when syntactically invalid.

When ranges are returned, the array has a "type" property which is the type of range that is required (most commonly, "bytes"). Each array element is an object with a "start" and "end" property for the portion of the range.

The "combine" option can be set to true and overlapping & adjacent ranges will be combined into a single range.

NOTE: remember that ranges are inclusive, so for example "Range: users=0-3" should respond with 4 users when available, not 3.

Return the value of param name when present or defaultValue.

• Checks route placeholders, ex: /user/:id
• Checks body params, ex: id=12, {"id":12}
• Checks query string params, ex: ?id=12

To utilize request bodies, req.body should be an object. This can be done by using the bodyParser() middleware.

Check if the incoming request contains the "Content-Type" header field, and it contains the give mime type.

Examples:

 // With Content-Type: text/html; charset=utf-8
 req.is('html');
 req.is('text/html');
 req.is('text/*');
 // => true

 // When Content-Type is application/json
 req.is('json');
 req.is('application/json');
 req.is('application/*');
 // => true

 req.is('html');
 // => false

Set status code.

Set Link header field with the given links.

Examples:

res.links({ next: 'http://api.example.com/users?page=2', last: 'http://api.example.com/users?page=5' });

Send a response.

Examples:

res.send(Buffer.from('wahoo'));
res.send({ some: 'json' });
res.send('<p>some html</p>');

Send JSON response.

Examples:

res.json(null);
res.json({ user: 'tj' });

Send JSON response with JSONP callback support.

Examples:

res.jsonp(null);
res.jsonp({ user: 'tj' });

Send given HTTP status code.

Sets the response status to statusCode and the body of the response to the standard description from node's http.STATUS_CODES or the statusCode number if no description.

Examples:

res.sendStatus(200);

Transfer the file at the given path.

Automatically sets the Content-Type response header field. The callback callback(err) is invoked when the transfer is complete or when an error occurs. Be sure to check res.sentHeader if you wish to attempt responding, as the header and some data may have already been transferred.

Options:

• maxAge defaulting to 0 (can be string converted by ms)
• root root directory for relative filenames
• headers object of headers to serve with file
• dotfiles serve dotfiles, defaulting to false; can be "allow" to send them

Other options are passed along to send.

Examples:

The following example illustrates how res.sendFile() may be used as an alternative for the static() middleware for dynamic situations. The code backing res.sendFile() is actually the same code, so HTTP cache support etc is identical.

app.get('/user/:uid/photos/:file', function(req, res){
  var uid = req.params.uid
    , file = req.params.file;

  req.user.mayViewFilesFrom(uid, function(yes){
    if (yes) {
      res.sendFile('/uploads/' + uid + '/' + file);
    } else {
      res.send(403, 'Sorry! you cant see that.');
    }
  });
});

Transfer the file at the given path.

Automatically sets the Content-Type response header field. The callback callback(err) is invoked when the transfer is complete or when an error occurs. Be sure to check res.sentHeader if you wish to attempt responding, as the header and some data may have already been transferred.

Options:

• maxAge defaulting to 0 (can be string converted by ms)
• root root directory for relative filenames
• headers object of headers to serve with file
• dotfiles serve dotfiles, defaulting to false; can be "allow" to send them

Other options are passed along to send.

Examples:

The following example illustrates how res.sendfile() may be used as an alternative for the static() middleware for dynamic situations. The code backing res.sendfile() is actually the same code, so HTTP cache support etc is identical.

app.get('/user/:uid/photos/:file', function(req, res){
  var uid = req.params.uid
    , file = req.params.file;

  req.user.mayViewFilesFrom(uid, function(yes){
    if (yes) {
      res.sendfile('/uploads/' + uid + '/' + file);
    } else {
      res.send(403, 'Sorry! you cant see that.');
    }
  });
});

Transfer the file at the given path as an attachment.

Optionally providing an alternate attachment filename, and optional callback callback(err). The callback is invoked when the data transfer is complete, or when an error has ocurred. Be sure to check res.headersSent if you plan to respond.

Optionally providing an options object to use with res.sendFile(). This function will set the Content-Disposition header, overriding any Content-Disposition header passed as header options in order to set the attachment and filename.

This method uses res.sendFile().

Set Content-Type response header with type through mime.lookup() when it does not contain "/", or set the Content-Type to type otherwise.

Examples:

res.type('.html');
res.type('html');
res.type('json');
res.type('application/json');
res.type('png');

Respond to the Acceptable formats using an obj of mime-type callbacks.

This method uses req.accepted, an array of acceptable types ordered by their quality values. When "Accept" is not present the first callback is invoked, otherwise the first match is used. When no match is performed the server responds with 406 "Not Acceptable".

Content-Type is set for you, however if you choose you may alter this within the callback using res.type() or res.set('Content-Type', ...).

res.format({ 'text/plain': function(){ res.send('hey'); },

 'text/html': function(){
   res.send('<p>hey</p>');
 },

 'appliation/json': function(){
   res.send({ message: 'hey' });
 }

});

In addition to canonicalized MIME types you may also use extnames mapped to these types:

res.format({ text: function(){ res.send('hey'); },

 html: function(){
   res.send('<p>hey</p>');
 },

 json: function(){
   res.send({ message: 'hey' });
 }

});

By default Express passes an Error with a .status of 406 to next(err) if a match is not made. If you provide a .default callback it will be invoked instead.

Set Content-Disposition header to attachment with optional filename.

Append additional header field with value val.

Example:

res.append('Link', ['<http://localhost/>', '<http://localhost:3000/>']); res.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly'); res.append('Warning', '199 Miscellaneous warning');

Set header field to val, or pass an object of header fields.

Examples:

res.set('Foo', ['bar', 'baz']); res.set('Accept', 'application/json'); res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });

Aliased as res.header().

Get value for header field.

Clear cookie name.

Set cookie name to value, with the given options.

Options:

• maxAge max-age in milliseconds, converted to expires
• signed sign the cookie
• path defaults to "/"

Examples:

// "Remember Me" for 15 minutes res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });

// save as above res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })

Set the location header to url.

The given url can also be "back", which redirects to the Referrer or Referer headers or "/".

Examples:

res.location('/foo/bar').; res.location('http://example.com'); res.location('../login');

Redirect to the given url with optional response status defaulting to 302.

The resulting url is determined by res.location(), so it will play nicely with mounted apps, relative paths, "back" etc.

Examples:

res.redirect('/foo/bar'); res.redirect('http://example.com'); res.redirect(301, 'http://example.com'); res.redirect('../login'); // /blog/post/1 -> /blog/login

Add field to Vary. If already present in the Vary set, then this call is simply ignored.

Render view with the given options and optional callback fn. When a callback function is given a response will not be made automatically, otherwise a response of 200 and text/html is given.

Options:

• cache boolean hinting to the engine it should cache
• filename filename of the view being rendered