Wie bekomme ich alle registrierten Routen in Express?


181

Ich habe eine Webanwendung mit Node.js und Express erstellt. Jetzt möchte ich alle registrierten Routen mit den entsprechenden Methoden auflisten.

ZB wenn ich hingerichtet habe

app.get('/', function (...) { ... });
app.get('/foo/:id', function (...) { ... });
app.post('/foo/:id', function (...) { ... });

Ich möchte ein Objekt (oder etwas Ähnliches) abrufen, wie zum Beispiel:

{
  get: [ '/', '/foo/:id' ],
  post: [ '/foo/:id' ]
}

Ist das möglich und wenn ja, wie?


UPDATE: In der Zwischenzeit habe ich ein npm-Paket namens get-route erstellt , das die Routen aus einer bestimmten Anwendung extrahiert, wodurch dieses Problem behoben wird. Derzeit wird nur Express 4.x unterstützt, aber ich denke, im Moment ist dies in Ordnung. Nur zur Info.


Alle Lösungen, die ich ausprobiert habe, funktionieren nicht, wenn Sie Router definiert haben. Es funktioniert nur pro Route - was mir nicht die gesamte URL für diese Route in meiner App gibt ...
Guy Mograbi

1
@guymograbi Vielleicht möchten Sie sich stackoverflow.com/a/55589657/6693775
nbsamar

Antworten:


229

Express 3.x.

Okay, habe es selbst gefunden ... es ist nur app.routes:-)

Express 4.x.

Anwendungen - erstellt mitexpress()

app._router.stack

Router - gebaut mitexpress.Router()

router.stack

Hinweis : Der Stack enthält auch die Middleware-Funktionen. Er sollte gefiltert werden, um nur die "Routen" abzurufen.


Ich benutze Knoten 0.10 und es war app.routes.routes- was bedeutet, ich könnte JSON.stringify (app.routes.routes) machen
Kerl Mograbi

7
Funktioniert nur für Express 3.x, nicht für 4.x. In 4.x sollten Sie überprüfenapp._router.stack
avetisk

14
Das hat bei mir nicht wie erwartet funktioniert. app._router scheint keine Routen von app.use ('/ path', otherRouter) zu enthalten;
Michael Cole

Gibt es eine Möglichkeit, dies in ein Befehlszeilenskript zu integrieren, das genau dieselben Routendateien abruft wie die Live-App, ohne eine Web-App zu starten?
Lawrence I. Siden

4
Zumindest in Express 4.13.1 app._router.stackist undefiniert.
Levigroker

54
app._router.stack.forEach(function(r){
  if (r.route && r.route.path){
    console.log(r.route.path)
  }
})

1
Beachten Sie, dass bei Verwendung von Express Router (oder anderer Middleware) die Antwort von @Caleb etwas länger angezeigt werden sollte, um diesen Ansatz zu erweitern.
Iain Collins

30

Dadurch werden Routen direkt in der App registriert (über app.VERB) und Routen, die als Router-Middleware registriert sind (über app.use). Express 4.11.0

//////////////
app.get("/foo", function(req,res){
    res.send('foo');
});

//////////////
var router = express.Router();

router.get("/bar", function(req,res,next){
    res.send('bar');
});

app.use("/",router);


//////////////
var route, routes = [];

app._router.stack.forEach(function(middleware){
    if(middleware.route){ // routes registered directly on the app
        routes.push(middleware.route);
    } else if(middleware.name === 'router'){ // router middleware 
        middleware.handle.stack.forEach(function(handler){
            route = handler.route;
            route && routes.push(route);
        });
    }
});

// routes:
// {path: "/foo", methods: {get: true}}
// {path: "/bar", methods: {get: true}}

1
Hervorragend, danke für ein Beispiel, das zeigt, wie Anzeigerouten über Middleware wie den Express-Router festgelegt werden.
Iain Collins

30

Ich habe einen alten Beitrag, der nicht mehr online ist, an meine Bedürfnisse angepasst. Ich habe express.Router () verwendet und meine Routen folgendermaßen registriert:

var questionsRoute = require('./BE/routes/questions');
app.use('/api/questions', questionsRoute);

Ich habe die Datei document.js in apiTable.js umbenannt und wie folgt angepasst:

module.exports =  function (baseUrl, routes) {
    var Table = require('cli-table');
    var table = new Table({ head: ["", "Path"] });
    console.log('\nAPI for ' + baseUrl);
    console.log('\n********************************************');

    for (var key in routes) {
        if (routes.hasOwnProperty(key)) {
            var val = routes[key];
            if(val.route) {
                val = val.route;
                var _o = {};
                _o[val.stack[0].method]  = [baseUrl + val.path];    
                table.push(_o);
            }       
        }
    }

    console.log(table.toString());
    return table;
};

dann nenne ich es in meinem server.js so:

var server = app.listen(process.env.PORT || 5000, function () {
    require('./BE/utils/apiTable')('/api/questions', questionsRoute.stack);
});

Das Ergebnis sieht folgendermaßen aus:

Ergebnisbeispiel

Es ist nur ein Beispiel, könnte aber von Nutzen sein. Ich hoffe.


2
Dies funktioniert nicht für verschachtelte Routen, wie hier angegeben: stackoverflow.com/questions/25260818/…

2
Vorsicht vor dem Link in dieser Antwort! Es leitete mich zu einer zufälligen Website weiter und erzwang einen Download auf meinen Computer.
Tyler Bell

29

Hier ist eine kleine Sache, die ich nur benutze, um die registrierten Pfade in Express 4.x zu erhalten

app._router.stack          // registered routes
  .filter(r => r.route)    // take out all the middleware
  .map(r => r.route.path)  // get all the paths

console.log (server._router.stack.map (r => r.route) .filter (r => r) .map (r => ${Object.keys(r.methods).join(', ')} ${r.path}))
standup75

wo legst du das in app.js ??
Juan

21

DEBUG=express:* node index.js

Wenn Sie Ihre App mit dem obigen Befehl ausführen, wird Ihre App mit DEBUGModul gestartet und es werden Routen sowie alle verwendeten Middleware-Funktionen angegeben.

Sie können verweisen auf: ExpressJS - Debuggen und Debuggen .


3
Mit Abstand die beste Antwort ... eine Umgebung var!
Jeef

In der Tat die nützlichste Antwort. @nbsamar Sie können es sogar erweitern, um zu sagen, dass DEBUG=express:pathsnur die Pfadausgabe und nicht alle anderen Debug-Meldungen angezeigt werden sollen. Vielen Dank!
Mark Edington

19

Hacky Copy / Paste-Antwort mit freundlicher Genehmigung von Doug Wilson zu den Express-Github-Themen . Schmutzig, wirkt aber wie ein Zauber.

function print (path, layer) {
  if (layer.route) {
    layer.route.stack.forEach(print.bind(null, path.concat(split(layer.route.path))))
  } else if (layer.name === 'router' && layer.handle.stack) {
    layer.handle.stack.forEach(print.bind(null, path.concat(split(layer.regexp))))
  } else if (layer.method) {
    console.log('%s /%s',
      layer.method.toUpperCase(),
      path.concat(split(layer.regexp)).filter(Boolean).join('/'))
  }
}

function split (thing) {
  if (typeof thing === 'string') {
    return thing.split('/')
  } else if (thing.fast_slash) {
    return ''
  } else {
    var match = thing.toString()
      .replace('\\/?', '')
      .replace('(?=\\/|$)', '$')
      .match(/^\/\^((?:\\[.*+?^${}()|[\]\\\/]|[^.*+?^${}()|[\]\\\/])*)\$\//)
    return match
      ? match[1].replace(/\\(.)/g, '$1').split('/')
      : '<complex:' + thing.toString() + '>'
  }
}

app._router.stack.forEach(print.bind(null, []))

Produziert

screengrab


Warum sind Routen nicht unterschiedlich?
Vladimir Vukanac

1
Dies ist die einzige, die mit Express 4.15 für mich funktioniert hat. Keiner der anderen gab den vollen Weg. Die einzige Einschränkung ist, dass der Standard-Root-Pfad nicht zurückgegeben wird / - keiner von ihnen.
Shane

Ich verstehe nicht, warum Sie Argumente binden print?
ZzZombo

@ZzZombo Doug Doug fragen, er hat es geschrieben. Sie können das alles wahrscheinlich aufräumen, wenn Sie wollen.
AlienWebguy

11

https://www.npmjs.com/package/express-list-endpoints funktioniert ziemlich gut.

Beispiel

Verwendung:

const all_routes = require('express-list-endpoints');
console.log(all_routes(app));

Ausgabe:

[ { path: '*', methods: [ 'OPTIONS' ] },
  { path: '/', methods: [ 'GET' ] },
  { path: '/sessions', methods: [ 'POST' ] },
  { path: '/sessions', methods: [ 'DELETE' ] },
  { path: '/users', methods: [ 'GET' ] },
  { path: '/users', methods: [ 'POST' ] } ]

2
Dies funktioniert nicht mit: server = express(); app1 = express(); server.use('/app1', app1); ...
Danosaure

8

Eine Funktion zum Protokollieren aller Routen in Express 4 (kann für v3 ~ leicht angepasst werden)

function space(x) {
    var res = '';
    while(x--) res += ' ';
    return res;
}

function listRoutes(){
    for (var i = 0; i < arguments.length;  i++) {
        if(arguments[i].stack instanceof Array){
            console.log('');
            arguments[i].stack.forEach(function(a){
                var route = a.route;
                if(route){
                    route.stack.forEach(function(r){
                        var method = r.method.toUpperCase();
                        console.log(method,space(8 - method.length),route.path);
                    })
                }
            });
        }
    }
}

listRoutes(router, routerAuth, routerHTML);

Protokollausgabe:

GET       /isAlive
POST      /test/email
POST      /user/verify

PUT       /login
POST      /login
GET       /player
PUT       /player
GET       /player/:id
GET       /players
GET       /system
POST      /user
GET       /user
PUT       /user
DELETE    /user

GET       /
GET       /login

Hat dies zu einem NPM gemacht https://www.npmjs.com/package/express-list-routes


1
Das hat bei mir nicht wie erwartet funktioniert. app._router scheint keine Routen von app.use ('/ path', otherRouter) zu enthalten;
Michael Cole

@ MichaelCole Hast du dir die Antwort von Golo Roden unten angesehen?
Labithiotis

@ Dazzler13 Ich habe eine Stunde damit gespielt und konnte es nicht zum Laufen bringen. Express 4.0. App erstellt, Router erstellt, app.use (Pfad, Router), Router-Routen wurden in app._router nicht angezeigt. Beispiel?
Michael Cole

Das folgende Beispiel von @Caleb eignet sich gut für Routen, die mit etwas wie Express.Router behandelt werden, wenn dies Ihr Problem ist. Beachten Sie, dass mit Middleware (einschließlich Express.Router) festgelegte Routen möglicherweise nicht sofort angezeigt werden und Sie möglicherweise eine kurze Verzögerung hinzufügen müssen, bevor Sie in app._router nach ihnen suchen (auch wenn Sie den Ansatz von @Caleb verwenden).
Iain Collins

7

JSON-Ausgabe

function availableRoutes() {
  return app._router.stack
    .filter(r => r.route)
    .map(r => {
      return {
        method: Object.keys(r.route.methods)[0].toUpperCase(),
        path: r.route.path
      };
    });
}

console.log(JSON.stringify(availableRoutes(), null, 2));

sieht aus wie das:

[
  {
    "method": "GET",
    "path": "/api/todos"
  },
  {
    "method": "POST",
    "path": "/api/todos"
  },
  {
    "method": "PUT",
    "path": "/api/todos/:id"
  },
  {
    "method": "DELETE",
    "path": "/api/todos/:id"
  }
]

String-Ausgabe

function availableRoutesString() {
  return app._router.stack
    .filter(r => r.route)
    .map(r => Object.keys(r.route.methods)[0].toUpperCase().padEnd(7) + r.route.path)
    .join("\n  ")
}

console.log(availableRoutesString());

sieht aus wie das:

GET    /api/todos  
POST   /api/todos  
PUT    /api/todos/:id  
DELETE /api/todos/:id

Diese basieren auf @ corvid's Antwort

hoffe das hilft


5

Ich war von Labithiotis 'Express-Listen-Routen inspiriert, wollte aber einen Überblick über alle meine Routen und Brute-URLs auf einmal haben und keinen Router angeben und jedes Mal das Präfix herausfinden. Ich habe mir einfach ausgedacht, die Funktion app.use durch meine eigene Funktion zu ersetzen, in der die baseUrl und der angegebene Router gespeichert sind. Von dort kann ich jede Tabelle aller meiner Routen ausdrucken.

HINWEIS Dies funktioniert für mich, da ich meine Routen in einer bestimmten Routendatei (Funktion) deklariere, die im App-Objekt wie folgt übergeben wird:

// index.js
[...]
var app = Express();
require(./config/routes)(app);

// ./config/routes.js
module.exports = function(app) {
    // Some static routes
    app.use('/users', [middleware], UsersRouter);
    app.use('/users/:user_id/items', [middleware], ItemsRouter);
    app.use('/otherResource', [middleware], OtherResourceRouter);
}

Auf diese Weise kann ich ein anderes 'App'-Objekt mit einer Fake-Use-Funktion übergeben und ALLE Routen abrufen. Dies funktioniert bei mir (einige Fehler wurden aus Gründen der Klarheit entfernt, funktionieren aber immer noch für das Beispiel):

// In printRoutes.js (or a gulp task, or whatever)
var Express = require('express')
  , app     = Express()
  , _       = require('lodash')

// Global array to store all relevant args of calls to app.use
var APP_USED = []

// Replace the `use` function to store the routers and the urls they operate on
app.use = function() {
  var urlBase = arguments[0];

  // Find the router in the args list
  _.forEach(arguments, function(arg) {
    if (arg.name == 'router') {
      APP_USED.push({
        urlBase: urlBase,
        router: arg
      });
    }
  });
};

// Let the routes function run with the stubbed app object.
require('./config/routes')(app);

// GRAB all the routes from our saved routers:
_.each(APP_USED, function(used) {
  // On each route of the router
  _.each(used.router.stack, function(stackElement) {
    if (stackElement.route) {
      var path = stackElement.route.path;
      var method = stackElement.route.stack[0].method.toUpperCase();

      // Do whatever you want with the data. I like to make a nice table :)
      console.log(method + " -> " + used.urlBase + path);
    }
  });
});

Dieses vollständige Beispiel (mit einigen grundlegenden CRUD-Routern) wurde gerade getestet und ausgedruckt:

GET -> /users/users
GET -> /users/users/:user_id
POST -> /users/users
DELETE -> /users/users/:user_id
GET -> /users/:user_id/items/
GET -> /users/:user_id/items/:item_id
PUT -> /users/:user_id/items/:item_id
POST -> /users/:user_id/items/
DELETE -> /users/:user_id/items/:item_id
GET -> /otherResource/
GET -> /otherResource/:other_resource_id
POST -> /otherResource/
DELETE -> /otherResource/:other_resource_id

Mit cli-table habe ich so etwas bekommen:

┌────────┬───────────────────────┐
         => Users              
├────────┼───────────────────────┤
 GET     /users/users          
├────────┼───────────────────────┤
 GET     /users/users/:user_id 
├────────┼───────────────────────┤
 POST    /users/users          
├────────┼───────────────────────┤
 DELETE  /users/users/:user_id 
└────────┴───────────────────────┘
┌────────┬────────────────────────────────┐
         => Items                       
├────────┼────────────────────────────────┤
 GET     /users/:user_id/items/         
├────────┼────────────────────────────────┤
 GET     /users/:user_id/items/:item_id 
├────────┼────────────────────────────────┤
 PUT     /users/:user_id/items/:item_id 
├────────┼────────────────────────────────┤
 POST    /users/:user_id/items/         
├────────┼────────────────────────────────┤
 DELETE  /users/:user_id/items/:item_id 
└────────┴────────────────────────────────┘
┌────────┬───────────────────────────────────┐
         => OtherResources                 
├────────┼───────────────────────────────────┤
 GET     /otherResource/                   
├────────┼───────────────────────────────────┤
 GET     /otherResource/:other_resource_id 
├────────┼───────────────────────────────────┤
 POST    /otherResource/                   
├────────┼───────────────────────────────────┤
 DELETE  /otherResource/:other_resource_id 
└────────┴───────────────────────────────────┘

Welches tritt Arsch.


4

Express 4

Bei einer Express 4- Konfiguration mit Endpunkten und verschachtelten Routern

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

app.get(...)
app.post(...)

router.use(...)
router.get(...)
router.post(...)

app.use(router)

Durch Erweitern der @ caleb- Antwort können alle Routen rekursiv und sortiert abgerufen werden .

getRoutes(app._router && app._router.stack)
// =>
// [
//     [ 'GET', '/'], 
//     [ 'POST', '/auth'],
//     ...
// ]

/**
* Converts Express 4 app routes to an array representation suitable for easy parsing.
* @arg {Array} stack An Express 4 application middleware list.
* @returns {Array} An array representation of the routes in the form [ [ 'GET', '/path' ], ... ].
*/
function getRoutes(stack) {
        const routes = (stack || [])
                // We are interested only in endpoints and router middleware.
                .filter(it => it.route || it.name === 'router')
                // The magic recursive conversion.
                .reduce((result, it) => {
                        if (! it.route) {
                                // We are handling a router middleware.
                                const stack = it.handle.stack
                                const routes = getRoutes(stack)

                                return result.concat(routes)
                        }

                        // We are handling an endpoint.
                        const methods = it.route.methods
                        const path = it.route.path

                        const routes = Object
                                .keys(methods)
                                .map(m => [ m.toUpperCase(), path ])

                        return result.concat(routes)
                }, [])
                // We sort the data structure by route path.
                .sort((prev, next) => {
                        const [ prevMethod, prevPath ] = prev
                        const [ nextMethod, nextPath ] = next

                        if (prevPath < nextPath) {
                                return -1
                        }

                        if (prevPath > nextPath) {
                                return 1
                        }

                        return 0
                })

        return routes
}

Für die grundlegende Ausgabe von Zeichenfolgen.

infoAboutRoutes(app)

Konsolenausgabe

/**
* Converts Express 4 app routes to a string representation suitable for console output.
* @arg {Object} app An Express 4 application
* @returns {string} A string representation of the routes.
*/
function infoAboutRoutes(app) {
        const entryPoint = app._router && app._router.stack
        const routes = getRoutes(entryPoint)

        const info = routes
                .reduce((result, it) => {
                        const [ method, path ] = it

                        return result + `${method.padEnd(6)} ${path}\n`
                }, '')

        return info
}

Update 1:

Aufgrund der internen Einschränkungen von Express 4 ist es nicht möglich, gemountete Apps und gemountete Router abzurufen. Beispielsweise ist es nicht möglich, Routen aus dieser Konfiguration abzurufen.

const subApp = express()
app.use('/sub/app', subApp)

const subRouter = express.Router()
app.use('/sub/route', subRouter)

Das Auflisten von gemounteten Routen funktioniert mit diesem Paket: github.com/AlbertoFdzM/express-list-endpoints
jsaddwater

4

Benötigen Sie einige Anpassungen, sollte aber für Express v4 funktionieren. Einschließlich der mit hinzugefügten Routen .use().

function listRoutes(routes, stack, parent){

  parent = parent || '';
  if(stack){
    stack.forEach(function(r){
      if (r.route && r.route.path){
        var method = '';

        for(method in r.route.methods){
          if(r.route.methods[method]){
            routes.push({method: method.toUpperCase(), path: parent + r.route.path});
          }
        }       

      } else if (r.handle && r.handle.name == 'router') {
        const routerName = r.regexp.source.replace("^\\","").replace("\\/?(?=\\/|$)","");
        return listRoutes(routes, r.handle.stack, parent + routerName);
      }
    });
    return routes;
  } else {
    return listRoutes([], app._router.stack);
  }
}

//Usage on app.js
const routes = listRoutes(); //array: ["method: path", "..."]

Bearbeiten: Code-Verbesserungen


3

Leicht aktualisierter und funktionaler Ansatz für die Antwort von @ prranay:

const routes = app._router.stack
    .filter((middleware) => middleware.route)
    .map((middleware) => `${Object.keys(middleware.route.methods).join(', ')} -> ${middleware.route.path}`)

console.log(JSON.stringify(routes, null, 4));

2

Das hat bei mir funktioniert

let routes = []
app._router.stack.forEach(function (middleware) {
    if(middleware.route) {
        routes.push(Object.keys(middleware.route.methods) + " -> " + middleware.route.path);
    }
});

console.log(JSON.stringify(routes, null, 4));

O / P:

[
    "get -> /posts/:id",
    "post -> /posts",
    "patch -> /posts"
]

2

Express-Router initialisieren

let router = require('express').Router();
router.get('/', function (req, res) {
    res.json({
        status: `API Its Working`,
        route: router.stack.filter(r => r.route)
           .map(r=> { return {"path":r.route.path, 
 "methods":r.route.methods}}),
        message: 'Welcome to my crafted with love!',
      });
   });   

Benutzercontroller importieren

var userController = require('./controller/userController');

Benutzerrouten

router.route('/users')
   .get(userController.index)
   .post(userController.new);
router.route('/users/:user_id')
   .get(userController.view)
   .patch(userController.update)
   .put(userController.update)
   .delete(userController.delete);

API-Routen exportieren

module.exports = router;

Ausgabe

{"status":"API Its Working, APP Route","route": 
[{"path":"/","methods":{"get":true}}, 
{"path":"/users","methods":{"get":true,"post":true}}, 
{"path":"/users/:user_id","methods": ....}

1

In Express 3.5.x füge ich Folgendes hinzu, bevor ich die App starte, um die Routen auf meinem Terminal zu drucken:

var routes = app.routes;
for (var verb in routes){
    if (routes.hasOwnProperty(verb)) {
      routes[verb].forEach(function(route){
        console.log(verb + " : "+route['path']);
      });
    }
}

Vielleicht kann es helfen ...


1

Verwenden Sie einfach dieses npm-Paket, es gibt sowohl die Webausgabe als auch die Terminalausgabe in einer schön formatierten Tabellenansicht.

Geben Sie hier die Bildbeschreibung ein

https://www.npmjs.com/package/express-routes-catalogue


2
Dieses andere Paket hat eine Menge mehr Akzeptanz. npmjs.com/package/express-list-endpoints . Ich bin 21.111 gegen 34 wöchentliche Downloads. Allerdings express-routes-cataloguezeigt auch die Routen wie HTML, ehile die andere nicht.
Mayid

1
Nicht schlecht, die Dokumentation des Pakets unterscheidet sich bei Bedarf vom tatsächlichen Paketnamen, und dieses Paket zeigt, wie alle anderen genannten, nur einschichtige Routen an, in denen es enthalten ist
hamza khan

@hamzakhan ps danke für das Update. Ich bin der Autor, wird bald in der Dokumentation aktualisiert.
Vijay

0

Also habe ich mir alle Antworten angesehen .. mochte die meisten nicht .. nahm einige von ein paar .. machte dies:

const resolveRoutes = (stack) => {
  return stack.map(function (layer) {
    if (layer.route && layer.route.path.isString()) {
      let methods = Object.keys(layer.route.methods);
      if (methods.length > 20)
        methods = ["ALL"];

      return {methods: methods, path: layer.route.path};
    }

    if (layer.name === 'router')  // router middleware
      return resolveRoutes(layer.handle.stack);

  }).filter(route => route);
};

const routes = resolveRoutes(express._router.stack);
const printRoute = (route) => {
  if (Array.isArray(route))
    return route.forEach(route => printRoute(route));

  console.log(JSON.stringify(route.methods) + " " + route.path);
};

printRoute(routes);

nicht die schönste .. aber verschachtelt, und macht den Trick

Beachten Sie auch die 20 dort ... Ich gehe nur davon aus, dass es keine normale Route mit 20 Methoden geben wird. Also schließe ich, dass es alles ist.


0

Routendetails sind Routen für "Express": "4.xx",

import {
  Router
} from 'express';
var router = Router();

router.get("/routes", (req, res, next) => {
  var routes = [];
  var i = 0;
  router.stack.forEach(function (r) {
    if (r.route && r.route.path) {
      r.route.stack.forEach(function (type) {
        var method = type.method.toUpperCase();
        routes[i++] = {
          no:i,
          method: method.toUpperCase(),
          path: r.route.path
        };
      })
    }
  })

  res.send('<h1>List of routes.</h1>' + JSON.stringify(routes));
});

EINFACHE AUSGABE DES CODES

List of routes.

[
{"no":1,"method":"POST","path":"/admin"},
{"no":2,"method":"GET","path":"/"},
{"no":3,"method":"GET","path":"/routes"},
{"no":4,"method":"POST","path":"/student/:studentId/course/:courseId/topic/:topicId/task/:taskId/item"},
{"no":5,"method":"GET","path":"/student/:studentId/course/:courseId/topic/:topicId/task/:taskId/item"},
{"no":6,"method":"PUT","path":"/student/:studentId/course/:courseId/topic/:topicId/task/:taskId/item/:itemId"},
{"no":7,"method":"DELETE","path":"/student/:studentId/course/:courseId/topic/:topicId/task/:taskId/item/:itemId"}
]

-1

Hier ist eine einzeilige Funktion zum hübschen Drucken der Routen in einem Express app:

const getAppRoutes = (app) => app._router.stack.reduce(
  (acc, val) => acc.concat(
    val.route ? [val.route.path] :
      val.name === "router" ? val.handle.stack.filter(
        x => x.route).map(
          x => val.regexp.toString().match(/\/[a-z]+/)[0] + (
            x.route.path === '/' ? '' : x.route.path)) : []) , []).sort();

-2

Ich habe ein Paket veröffentlicht, das alle Middleware sowie Routen druckt. Dies ist sehr nützlich, wenn Sie versuchen, eine Express-Anwendung zu prüfen. Sie mounten das Paket als Middleware, sodass es sich selbst ausdruckt:

https://github.com/ErisDS/middleware-stack-printer

Es druckt eine Art Baum wie:

- middleware 1
- middleware 2
- Route /thing/
- - middleware 3
- - controller (HTTP VERB)  
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.