Difference between app.all('*') and app.use('/')

Is there a useful difference between app.all("*", … ) and app.use("/", … ) in Express.js running on Node.js?

In most cases they would work equivalently. The biggest difference is the order in which middleware would be applied:

• app.all() attaches to the application's router, so it's used whenever the app.router middleware is reached (which handles all the method routes... GET, POST, etc).

> NOTICE: app.router has been deprecated in express 4.x

• app.use() attaches to the application's main middleware stack, so it's used in the order specified by middleware, e.g., if you put it first, it will be the first thing to run. If you put it last, (after the router), it usually won't be run at all.

Usually, if you want to do something globally to all routes, app.use() is the better option. Also, it has less chance of future bugs, since express 0.4 will probably drop the implicit router (meaning, the position of the router in middleware will be more important than it is right now, since you technically don't even have to use it right now).

app.use takes only one callback function and it's meant for Middleware. Middleware usually doesn't handle request and response, (technically they can) they just process input data, and hand over it to next handler in queue.

app.use([path], function)

app.all takes multiple callbacks, and meant for routing. with multiple callbacks you can filter requests and send responses. Its explained in https://stackoverflow.com/questions/8763504/filters-on-express-js

app.all(path, [callback...], callback)

app.use only sees whether url starts with the specified path

app.use( "/product" , mymiddleware);
// will match /product
// will match /product/cool
// will match /product/foo

app.all will match complete path

app.all( "/product" , handler);
// will match /product
// won't match /product/cool   <-- important
// won't match /product/foo    <-- important

app.all( "/product/*" , handler);
// won't match /product        <-- Important
// will match /product/
// will match /product/cool
// will match /product/foo

• app.use:

  1. inject middlware to your front controller configuring for instance: header, cookies, sessions, etc.
  2. must be written before app[http_method] otherwise there will be not executed.
  3. several calls are processed in the order of writing

• app.all:

  1. (like app[http_method]) is used for configuring routes' controllers
  2. "all" means it applies on all http methods.
  3. several calls are processed in the order of writing

Look at this expressJs code sample:

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

app.use(function frontControllerMiddlewareExecuted(req, res, next){
  console.log('(1) this frontControllerMiddlewareExecuted is executed');
  next();
});

app.all('*', function(req, res, next){
  console.log('(2) route middleware for all method and path pattern "*", executed first and can do stuff before going next');
  next();
});

app.all('/hello', function(req, res, next){
  console.log('(3) route middleware for all method and path pattern "/hello", executed second and can do stuff before going next');
  next();
});

app.use(function frontControllerMiddlewareNotExecuted(req, res, next){
  console.log('(4) this frontControllerMiddlewareNotExecuted is not executed');
  next();
});

app.get('/hello', function(req, res){
  console.log('(5) route middleware for method GET and path patter "/hello", executed last and I do my stuff sending response');
  res.send('Hello World');
});

app.listen(80);

Here is the log when accessing route '/hello':

(1) this frontControllerMiddlewareExecuted is executed
(2) route middleware for all method and path pattern "*", executed first and can do stuff before going next
(3) route middleware for all method and path pattern "/hello", executed second and can do stuff before going next
(5) route middleware for method GET and path patter "/hello", executed last and I do my stuff sending response

With app.use(), the "mount" path is stripped and is not visible to the middleware function:

app.use('/static', express.static(__dirname + '/public'));

Mounted middleware functions(express.static) are not invoked unless the req.url contains this prefix (/static), at which point it is stripped when the function is invoked.

With app.all(), there is no that behavior.

Yes, app.all() gets called when a particular URI is requested with any type of request method (POST, GET, PUT, or DELETE)

On other hand app.use() is used for any middleware you might have and it mounts onto a path prefix, and will be called anytime a URI under that route is requested.

Here is the documentation for app.all & app.use.

Two differences all above answers don't mention.

The first one:
app.all accepts a regex as its path parameter. app.use does NOT accept a regex.

The second one:
app.all(path, handler) or app[method](path, handler) handlers' path must be same to all path. This is, app[method] path is complete.

app.use(path, handler), if use's path is complete, the handler's path must be /. If the use's path is the start of the complete path, the handler path must be the rest of the complete path.

app.use("/users", users);

//users.js: the handler will be called when matchs `/user/` path
router.get("/", function (req, res, next) {
	res.send("respond with a resource");
});

// others.js: the handler will be called when matches `/users/users` path
router.get("/users", function (req, res, next) {
	res.send("respond with a resource");
});

app.all("/users", users);

//others.js: the handler will be called when matches `/`path
router.get("/", function (req, res, next) {
	res.send("respond with a resource");
});
//users.js: the handler will be called when matches `/users` path
router.get("/users", function (req, res, next) {
	res.send("respond with a resource");
});

There are two main differences:

1. pattern matching (answer given by Palani)
   
2. next(route) won't work inside the function body of middleware loaded using app.use . This is stated in the link from the docs:
   

NOTE: next('route') will work only in middleware functions that were loaded by using the app.METHOD() or router.METHOD() functions.

Link: http://expressjs.com/en/guide/using-middleware.html

The working effect of next('route') can be seen from the following example:

app.get('/',
(req,res,next)=>{console.log("1");
next(route); //The code here skips ALL the following middlewares
}
(req,res,next)=>{next();}, //skipped
(req,res,next)=>{next();}  //skipped
);

//Not skipped
app.get('/',function(req,res,next){console.log("2");next();});