Tukukkk

I still don't know the difference between these end points, and the end they are all routes but I don't know when or where should I use it? In what scenario?

app.use('/user/:id', function (req, res, next) {

  console.log('Request Type:', req.method)

  next()

});

app.get('/user/:id', function (req, res, next) {

  res.send('USER')

});



router.get('/user/:id', function (req, res, next) {

  res.send('USER')

});



router.use('/user/:id', function (req, res, next) {

  res.send('USER')

});

I you guys can help me out with this.

.use() and .get() difference is .use() will listen any type of request and .get() will listen only GET request like .post() .put() etc.

For routers you can think it as a sub route.

For example you can do something like this.

router.get('/:id', (req, res, next) => {res.send('user')})

router.post('/', (req, res, next) => {/* some create user logic */})



app.use('/user', router) // if you do this routers will match '/user/:id' and '/user' path

and of course you can have multiple routers in same app. So your code can be more structured.

By default, .use() has two main differences with .get().

1. 
   .get() will only match GET requests, .use() will match any type of request (POST, PUT, GET, etc...)


2. If you supply a path to .use(), it is more liberal in its matching and it will match if the path "starts" with the path you pass to .use(). It is done this way so you can set up a middleware handler that will fire for a broad set of URLs, not just a single URL. .get() is more often used with constrained URLs like one specific URL.

app.get() is pretty much the same as router.get(). The app object is a router that also has some other properties and methods on it. So, most any method from a router object is also on the app object, but not vice versa.

You might use a router instead of the app object for a variety of reasons:

1. Code modularity. A module creates it's own router, sets up a bunch of routes on it and then exports the single router which the caller can then add to the current app.


2. You have a bunch of routes all with the same prefix and find it cleaner to set up a router for that common prefix and then just put the routes on that router without having to specify the prefix in every one of them.


3. To create a set of routes that share the same middleware processing, but other routes in your app do not share that middleware processing. In this case, you create the router, put some middleware on it and then define routes on that router. The middleware will only fire for routes that are routed to this router.

Some examples:

// matches /hello and /hello/hi and /hello/goodbye for GET, POST or PUT

app.use('/hello', ...);



// matches only a GET request for /hello

app.get('/hello', ...);

An example of using a router to help with modularity.

A module with some routes defined in it:

// some_routes.js

const router = require('express').Router();



router.use(someMiddlewareForWholeRouter);



router.get('/hello', ...);

router.get('/goodbye', ...);

router.get('/callme', ...);



module.exports = router;

Using that module in your app:

// app.js

const some_routes = require('./some_routes.js');



// hook up all routes from some_routes with the path prefix of /greeting

app.use('/greetings', some_routes);