Supponiamo di voler avere endpoint REST che abbiano un aspetto simile a questo:

/user/
/user/user_id 

/user/user_id/items/
/user/user_id/items/item_id

CRUD su ciascuno se ha senso. Ad esempio, / user POST crea un nuovo utente, GET recupera tutti gli utenti. / user / user_id GET recupera solo quell'utente.

Gli elementi sono specifici dell'utente, quindi li inserisco in user_id , che è un utente specifico.

Ora per rendere modulare il routing Express ho creato alcune istanze del router. C'è un router per l'utente e un router per l'articolo.

var userRouter = require('express').Router();
userRouter.route('/')
  .get(function() {})
  .post(function() {})
userRouter.route('/:user_id')
  .get(function() {})

var itemRouter = require('express').Router();
itemRouter.route('/')
  .get(function() {})
  .post(function() {})
itemRouter.route('/:item_id')
  .get(function() {})

app.use('/users', userRouter);

// Now how to add the next router?
// app.use('/users/', itemRouter);

L'URL a itemè il discendente della gerarchia degli URL di user. Ora come posso ottenere l'URL con /usersqualunque cosa a userRouter ma il percorso più specifico di /user/*user_id*/items/itemRouter? E vorrei anche che user_id fosse accessibile anche a itemRouter, se possibile.

È possibile nidificare i router collegandoli come middleware su un altro router, con o senza params.

È necessario passare {mergeParams: true}al router figlio se si desidera accedere al paramsrouter principale.

mergeParamsè stato introdotto in Express4.5.0 (5 luglio 2014)

In questo esempio la itemRoutersi attacca alla userRoutersulla /:userId/itemsrotta

Ciò comporterà i seguenti percorsi possibili:

GET /user-> hello user
GET /user/5-> hello user 5
GET /user/5/items-> hello items from user 5
GET /user/5/items/6->hello item 6 from user 5

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

var userRouter = express.Router();
// you need to set mergeParams: true on the router,
// if you want to access params from the parent router
var itemRouter = express.Router({mergeParams: true});

// you can nest routers by attaching them as middleware:
userRouter.use('/:userId/items', itemRouter);

userRouter.route('/')
    .get(function (req, res) {
        res.status(200)
            .send('hello users');
    });

userRouter.route('/:userId')
    .get(function (req, res) {
        res.status(200)
            .send('hello user ' + req.params.userId);
    });

itemRouter.route('/')
    .get(function (req, res) {
        res.status(200)
            .send('hello items from user ' + req.params.userId);
    });

itemRouter.route('/:itemId')
    .get(function (req, res) {
        res.status(200)
            .send('hello item ' + req.params.itemId + ' from user ' + req.params.userId);
    });

app.use('/user', userRouter);

app.listen(3003);

percorsi nidificati gestibili ...

Volevo un esempio specifico di fare percorsi nidificati in modo molto gestibile in express 4 e questo era il risultato di ricerca principale per "percorsi nidificati in express". Ecco un'API che avrebbe molte rotte che dovrebbero essere spezzate per esempio.

./index.js:

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

// anything beginning with "/api" will go into this
app.use('/api', require('./routes/api'));

app.listen(3000);

./routes/api/index.js:

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

// split up route handling
router.use('/products', require('./products'));
router.use('/categories', require('./categories'));
// etc.

module.exports = router;

./routes/api/products.js:

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

// api/products
router.get('/', function(req, res) {
  res.json({ products: [] });
});

// api/products/:id
router.get('/:id', function(req, res) {
  res.json({ id: req.params.id });
});

module.exports = router;

Esempio di nidificazione nella struttura delle cartelle

Ho notato alcuni commenti su "annidamento della struttura delle cartelle". È implicito in questo tuttavia non ovvio, quindi ho aggiunto la sezione seguente. Ecco un esempio specifico di una struttura di cartelle nidificata per le route .

index.js
/api
  index.js
  /admin
    index.js
    /users
      index.js
      list.js
    /permissions
      index.js
      list.js

Questo è più un esempio generale di come funziona il nodo. Se si utilizza "index.js" in cartelle in modo simile al modo in cui "index.html" funziona nelle pagine Web per impostazione predefinita di una directory, sarà facile ridimensionare l'organizzazione in base alla ricorsione senza modificare i punti di ingresso in codice. "index.js" è il documento predefinito a cui si accede quando si utilizza un requisito in una directory.

contenuto di index.js

const express = require('express');
const router = express.Router();
router.use('/api', require('./api'));
module.exports = router;

contenuti di /api/index.js

const express = require('express');
const router = express.Router();
router.use('/admin', require('./admin'));
module.exports = router;

contenuti di /api/admin/index.js

const express = require('express');
const router = express.Router();
router.use('/users', require('./users'));
router.use('/permissions', require('./permissions'));
module.exports = router;

contenuti di /api/admin/users/index.js

const express = require('express');
const router = express.Router();
router.get('/', require('./list'));
module.exports = router;

Ci sono alcuni problemi di ASCIUTTA qui forse ma si presta bene all'incapsulamento delle preoccupazioni.

Cordiali saluti, recentemente sono entrato in Actionhero e l'ho trovato pieno di funzionalità con socket e compiti, più come un vero framework all-in-one che lancia il paradigma REST sulla sua testa. Probabilmente dovresti dare un'occhiata su andando nudo con express.

var userRouter = require('express').Router();
var itemRouter = require('express').Router({ mergeParams: true }); 

userRouter.route('/')
  .get(function(req, res) {})
  .post(function(req, res) {})
userRouter.route('/:user_id')
  .get(function() {})

itemRouter.route('/')
  .get(function(req, res) {})
  .post(function(req, res) {})
itemRouter.route('/:item_id')
  .get(function(req, res) {
    return res.send(req.params);
  });

app.use('/user/', userRouter);
app.use('/user/:user_id/item', itemRouter);

La chiave per la seconda parte della domanda è l'uso dell'opzione mergeParams

var itemRouter = require('express').Router({ mergeParams: true }); 

Da /user/jordan/item/catottengo una risposta:

{"user_id":"jordan","item_id":"cat"}

Utilizzo della soluzione @Jason Sebring e adattamento per Typescript.

server.ts

import Routes from './api/routes';
app.use('/api/', Routes);

/api/routes/index.ts

import { Router } from 'express';
import HomeRoutes from './home';

const router = Router();

router.use('/', HomeRoutes);
// add other routes...

export default router;

/api/routes/home.ts

import { Request, Response, Router } from 'express';

const router = Router();

router.get('/', (req: Request, res: Response) => {
  res.json({
    message: 'Welcome to API',
  });
});

export default router;

try to add  { mergeParams: true } look to simple example  which it middlware use it in controller file getUser at the same for  postUser
    const userRouter = require("express").Router({ mergeParams: true });
    export default ()=>{
    userRouter
      .route("/")
      .get(getUser)
      .post(postUser);
    userRouter.route("/:user_id").get(function () {});
    
    
    }

È necessario un solo router e utilizzarlo in questo modo:

router.get('/users');
router.get('/users/:user_id');

router.get('/users/:user_id/items');
router.get('/users/:user_id/items/:item_id');

app.use('api/v1', router);