Angenommen, ich möchte REST-Endpunkte haben, die ungefähr so ​​aussehen:

/user/
/user/user_id 

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

CRUD auf jedem, wenn es Sinn macht. Wenn beispielsweise / user POST einen neuen Benutzer erstellt, ruft GET alle Benutzer ab. / user / user_id GET ruft nur diesen einen Benutzer ab.

Die Elemente sind benutzerspezifisch, daher habe ich sie unter user_id abgelegt , bei der es sich um einen bestimmten Benutzer handelt.

Um das Express-Routing modular zu gestalten, habe ich einige Router-Instanzen erstellt. Es gibt einen Router für den Benutzer und einen Router für das Element.

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);

URL to itemist ein Nachkomme der URL-Hierarchie des user. Wie erhalte ich nun eine URL mit /usersirgendetwas zu userRouter, aber der spezifischeren Route /user/*user_id*/items/zum itemRouter? Außerdem möchte ich, dass user_id nach Möglichkeit auch itemRouter zugänglich ist.

Sie können Router verschachteln, indem Sie sie mit oder ohne Middleware an einen anderen Router anschließen params.

Sie müssen {mergeParams: true}an den untergeordneten Router übergeben, wenn Sie paramsvom übergeordneten Router aus auf den zugreifen möchten .

mergeParamswurde in Express eingeführt4.5.0 (5. Juli 2014)

In diesem Beispiel itemRouterwird das userRouteran die /:userId/itemsRoute angehängt

Dies führt zu folgenden möglichen Routen:

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);

überschaubare verschachtelte Routen ...

Ich wollte ein spezielles Beispiel dafür, wie verschachtelte Routen in Express 4 auf sehr überschaubare Weise ausgeführt werden. Dies war das Top-Suchergebnis für "verschachtelte Routen in Express". Hier ist eine API mit vielen Routen, die beispielsweise aufgelöst werden müssten.

./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;

Verschachtelungsbeispiel in Ordnerstruktur

Ich habe einige Kommentare zu "Verschachtelungsordnerstruktur" bemerkt. Dies ist jedoch nicht offensichtlich, daher habe ich den folgenden Abschnitt hinzugefügt. Hier ist ein spezielles Beispiel für eine verschachtelte Ordnerstruktur für Routen .

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

Dies ist eher ein allgemeines Beispiel für die Funktionsweise des Knotens. Wenn Sie "index.js" in Ordnern ähnlich wie "index.html" auf Webseiten für einen Verzeichnisstandard verwenden, können Sie Ihre Organisation auf der Grundlage der Rekursion leicht skalieren, ohne Ihre Einstiegspunkte in Code zu ändern. "index.js" ist das Standarddokument, auf das bei Verwendung von require in einem Verzeichnis zugegriffen wird .

Inhalt von index.js

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

Inhalt von /api/index.js

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

Inhalt von /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;

Inhalt von /api/admin/users/index.js

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

Möglicherweise gibt es hier einige DRY-Probleme, aber es eignet sich gut zur Zusammenfassung von Bedenken.

Zu Ihrer Information, vor kurzem bin ich zu Actionhero gekommen und habe festgestellt, dass es mit Sockets und Aufgaben ausgestattet ist, eher wie ein echtes All-in-One-Framework, das das REST-Paradigma auf den Kopf stellt. Du solltest es dir wahrscheinlich ansehen, wenn du nackt mit Express bist.

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);

Der Schlüssel zum zweiten Teil Ihrer Frage ist die Verwendung der Option mergeParams

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

Von /user/jordan/item/catbekomme ich eine Antwort:

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

Verwenden der @ Jason Sebring-Lösung und Anpassen an 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 () {});
    
    
    }

Sie benötigen nur einen Router und verwenden ihn folgendermaßen:

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);