# node.js – NodeJS / Express: what is “app.use”?

## The Question :

365 people think this question is useful

In the docs for the NodeJS express module, the example code has app.use(...).

What is the use function and where is it defined?

• possible duplicate: stackoverflow.com/questions/7337572/…
• the documentation is a bit cryptic for a beginner
• Possible duplicate above is referencing each other
• The documentation is completely unclear
• @KansaiRobot I’m a beginner and its nice to see someone actually thinks its not straightforward!

396 people think this answer is useful

The app object is instantiated on creation of the Express server. It has a middleware stack that can be customized in app.configure()(this is now deprecated in version 4.x).

To setup your middleware, you can invoke app.use(<specific_middleware_layer_here>) for every middleware layer that you want to add (it can be generic to all paths, or triggered only on specific path(s) your server handles), and it will add onto your Express middleware stack. Middleware layers can be added one by one in multiple invocations of use, or even all at once in series with one invocation. See use documentation for more details.

To give an example for conceptual understanding of Express Middleware, here is what my app middleware stack (app.stack) looks like when logging my app object to the console as JSON:

stack:
[ { route: '', handle: [Function] },
{ route: '', handle: [Function: static] },
{ route: '', handle: [Function: bodyParser] },
{ route: '', handle: [Function: cookieParser] },
{ route: '', handle: [Function: session] },
{ route: '', handle: [Function: methodOverride] },
{ route: '', handle: [Function] },
{ route: '', handle: [Function] } ]



As you might be able to deduce, I called app.use(express.bodyParser()), app.use(express.cookieParser()), etc, which added these express middleware ‘layers’ to the middleware stack. Notice that the routes are blank, meaning that when I added those middleware layers I specified that they be triggered on any route. If I added a custom middleware layer that only triggered on the path /user/:id that would be reflected as a string in the route field of that middleware layer object in the stack printout above.

Each layer is essentially adding a function that specifically handles something to your flow through the middleware.

E.g. by adding bodyParser, you’re ensuring your server handles incoming requests through the express middleware. So, now parsing the body of incoming requests is part of the procedure that your middleware takes when handling incoming requests — all because you called app.use(bodyParser).

53 people think this answer is useful

use is a method to configure the middleware used by the routes of the Express HTTP server object. The method is defined as part of Connect that Express is based upon.

Update Starting with version 4.x, Express no longer depends on Connect.

The middleware functions that were previously included with Express are now in separate modules; see the list of middleware functions.

48 people think this answer is useful

Each app.use(middleware) is called every time a request is sent to the server.

18 people think this answer is useful

app.use() used to Mounts the middleware function or mount to a specified path,the middleware function is executed when the base path matches.

For example: if you are using app.use() in indexRouter.js , like this:

//indexRouter.js

module.exports = function(app) {
}



In the above code app.use() mount the path on ‘/ads’ to adsRouter.js.

// adsRouter.js

var router = require('express').Router();
var controllerIndex = require('../controller/index');
module.exports = router;



app.use([path],callback,[callback]) : we can add a callback on the same.

app.use('/test', function(req, res, next) {

// write your callback code here.

});



17 people think this answer is useful

app.use() acts as a middleware in express apps. Unlike app.get() and app.post() or so, you actually can use app.use() without specifying the request URL. In such a case what it does is, it gets executed every time no matter what URL’s been hit.

8 people think this answer is useful

app.use() works like that:

1. Request event trigered on node http server instance.
2. express does some of its inner manipulation with req object.
3. This is when express starts doing things you specified with app.use

which very simple.

And only then express will do the rest of the stuff like routing.

8 people think this answer is useful
app.use(function middleware1(req, res, next){
// middleware1 logic
}, function middleware1(req, res, next){
// middleware2 logic
}, ... middlewareN);



app.use is a way to register middleware or chain of middlewares (or multiple middlewares) before executing any end route logic or intermediary route logic depending upon order of middleware registration sequence.

Middleware: forms chain of functions/middleware-functions with 3 parameters req, res, and next. next is callback which refer to next middleware-function in chain and in case of last middleware-function of chain next points to first-middleware-function of next registered middlerare-chain.

3 people think this answer is useful

In express if we import express from “express” and use app = express(); then app having all functionality of express

if we use app.use()

with any module/middleware function to use in whole express project

3 people think this answer is useful

app.use is a function requires middleware. For example:

 app.use('/user/:id', function (req, res, next) {
console.log('Request Type:', req.method);
next();
});



This example shows the middleware function installed in the /user/:id path. This function is executed for any type of HTTP request in the /user/:id path.

It is similar to the REST Web Server, just use different /xx to represent different actions.

3 people think this answer is useful

app.use is woks as middleware for app request. syntax

app.use('pass request format',function which contain request response onject)



example

app.use('/',funtion(req,res){
console.log(all request pass through it);
// here u can check your authentication and other activities.
})



also you can use it in case of routing your request.

app.use('/', roting_object);



3 people think this answer is useful

app.use() handles all the middleware functions.
What is middleware?
Middlewares are the functions which work like a door between two all the routes.

For instance:

app.use((req, res, next) => {
console.log("middleware ran");
next();
});

app.get("/", (req, res) => {
console.log("Home route");
});



When you visit / route in your console the two message will be printed. The first message will be from middleware function. If there is no next() function passed then only middleware function runs and other routes are blocked.

2 people think this answer is useful

Middleware is a general term for software that serves to “glue together” so app.use is a method to configure the middleware, for example: to parse and handle the body of request: app.use(bodyParser.urlencoded({ extended: true })); app.use(bodyParser.json()); there are many middlewares you can use in your express application just read the doc : http://expressjs.com/en/guide/using-middleware.html

2 people think this answer is useful

app.use applies the specified middleware to the main app middleware stack. When attaching middleware to the main app stack, the order of attachment matters; if you attach middleware A before middleware B, middleware A will always execute first. You can specify a path for which a particular middleware is applicable. In the below example, “hello world” will always be logged before “happy holidays.”

const express = require('express')
const app = express()

app.use(function(req, res, next) {
console.log('hello world')
next()
})

app.use(function(req, res, next) {
console.log('happy holidays')
next()
})



2 people think this answer is useful

It enables you to use any middleware (read more) like body_parser,CORS etc. Middleware can make changes to request and response objects. It can also execute a piece of code.

2 people think this answer is useful

You can also create your own middleware function like

app.use( function(req, res, next) {
next();
})



It contains three parameters req, res, next
You can also use it for authentication and validation of input params to keep your controller clean.

next() is used for go to next middleware or route.
You can send the response from middleware

2 people think this answer is useful

app.use() is an middleware method.

Middleware method is like a interceptor in java, this method always executes for all request.

Purpose and use of middleware:-

1. To check if session expired or not
2. for user authentication and authorization
3. check for cookie (expire date)
4. parse data before response

1 people think this answer is useful

Bind application-level middleware to an instance of the app object by using the app.use() and app.METHOD() functions, where METHOD is the HTTP method of the request that the middleware function handles (such as GET, PUT, or POST) in lowercase.

1 people think this answer is useful

In short app.use() supports all type of requests [eg:get,post,…] so its mostly used to setup middelware. or can be used for when the routes and functions seperated

example:

app.use("/test",functionName)



and functionName is located in different file

1 people think this answer is useful

app.use is Application level middleware

Bind application-level middleware to an instance of the app object by using the app.use() and app.METHOD() functions, where METHOD is the HTTP method of the request that the middleware function handles (such as GET, PUT, or POST) in lowercase.

you can use to check all requests, for example, you want to check token/access token you need to write a middleware by using app.use to check the token in the request.

This example shows a middleware function with no mount path. The function is executed every time the app receives a request.

var app = express()

app.use(function (req, res, next) {
console.log('Time:', Date.now())
next()
})



reference from https://expressjs.com/en/guide/using-middleware.html

1 people think this answer is useful

app.use
is created by express(nodejs middleware framework )
app.use is use to execute any specific query at intilization process
server.js(node)
var app = require(‘express’);
app.use(bodyparser.json())
so the basically app.use function called every time when server up

1 people think this answer is useful

app.use(path, middleware) is used to call middleware function that needs to be called before the route is hit for the corresponding path. Multiple middleware functions can be invoked via an app.use.

app.use(‘/fetch’, enforceAuthentication) -> enforceAuthentication middleware fn will be called when a request starting with ‘/fetch’ is received. It can be /fetch/users, /fetch/ids/{id}, etc

Some middleware functions might have to be called irrespective of the request. For such cases, a path is not specified, and since the the path defaults to / and every request starts with /, this middleware function will be called for all requests.

app.use(() => { // Initialize a common service })

next() fn needs to be called within each middleware function when multiple middleware functions are passed to app.use, else the next middleware function won’t be called.

reference : http://expressjs.com/en/api.html#app.use

Note: The documentation says we can bypass middleware functions following the current one by calling next(‘route’) within the current middleware function, but this technique didn’t work for me within app.use but did work with app.METHOD like below. So, fn1 and fn2 were called but not fn3.

app.get('/fetch', function fn1(req, res, next)  {
console.log("First middleware function called");
next();
},
function fn2(req, res, next) {
console.log("Second middleware function called");
next("route");
},
function fn3(req, res, next) {
console.log("Third middleware function will not be called");
next();
})



0 people think this answer is useful

As the name suggests, it acts as a middleware in your routing.

Let’s say for any single route, you want to call multiple url or perform multiple functions internally before sending the response. you can use this middleware and pass your route and perform all internal operations.

syntax:
app.use( function(req, res, next) {
// code
next();
})



next is optional, you can use to pass the result using this parameter to the next function.

0 people think this answer is useful

You can use app.use('/apis/test', () => {...}) for writing middleware for your api, to handle one or some action (authentication, validation data, validation tokens, etc) before it can go any further or response with specific status code when the condition that you gave was not qualified.

Example:

var express = require('express')
var app = express()

app.use(function (req, res, next) {
// Your code to handle data here
next()
})



More detail is, this part actually an anonymous function for you to write the logic on runtime

function (req, res, next) {
// Your code to handle data here
next()
}



You can split it into another function from another file and using module.export to use

next() here for the logic that if you handle everything is fine then you can use then for the program to continue the logic that its used to.