Jak uzyskać wszystkie zarejestrowane trasy w Express?


181

Mam aplikację internetową zbudowaną przy użyciu Node.js i Express. Teraz chciałbym wymienić wszystkie zarejestrowane trasy wraz z odpowiednimi metodami.

Np. Jeśli wykonałem

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

Chciałbym pobrać obiekt (lub coś równoważnego temu), taki jak:

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

Czy to możliwe, a jeśli tak, to w jaki sposób?


AKTUALIZACJA: W międzyczasie utworzyłem pakiet npm o nazwie get-route, który wyodrębnia trasy z danej aplikacji, co rozwiązuje ten problem. Obecnie obsługiwany jest tylko Express 4.x, ale chyba teraz jest w porządku. Po prostu dla ciebie.


Wszystkie rozwiązania, które wypróbowałem, nie działają, gdy masz zdefiniowane routery. Działa tylko na trasie - co nie daje mi całego
adresu

1
@guymograbi, możesz chcieć spojrzeć na stackoverflow.com/a/55589657/6693775
nbsamar

Odpowiedzi:


230

ekspresowe 3.x

Okej, sam to znalazłem ... to po prostu app.routes :-)

ekspresowe 4.x

Aplikacje - zbudowane zexpress()

app._router.stack

Routery - zbudowane zexpress.Router()

router.stack

Uwaga : stos zawiera również funkcje oprogramowania pośredniego, powinien zostać przefiltrowany, aby uzyskać tylko „trasy” .


Używam węzła 0.10 i było app.routes.routes- co oznacza, że ​​mogłem zrobić JSON.stringify (app.routes.routes)
facet mograbi

7
Działa tylko z Express 3.x, a nie 4.x. W wersji 4.x należy sprawdzićapp._router.stack
avetisk

14
Nie działało to zgodnie z oczekiwaniami. app._router nie wydaje się zawierać tras z app.use ('/ path', otherRouter);
Michael Cole,

Czy jest jakiś sposób, aby można to zintegrować ze skryptem wiersza poleceń, który pobierałby dokładnie te same pliki tras, które robi aplikacja na żywo bez uruchamiania aplikacji sieci web?
Lawrence I. Siden

5
Przynajmniej w ekspresowym 4.13.1 app._router.stackjest niezdefiniowany.
levigroker

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

1
Zauważ, że jeśli używasz czegoś takiego jak Express Router (lub inne oprogramowanie pośrednie), powinieneś zobaczyć @Caleb nieco dłuższą odpowiedź, która rozwija się w tym podejściu.
Iain Collins

31

W ten sposób trasy są rejestrowane bezpośrednio w aplikacji (przez app.VERB) i trasy zarejestrowane jako oprogramowanie pośredniczące routera (przez 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
Doskonale, dziękuję za przykład, który pokazuje, jak ustawić trasy wyświetlania za pomocą oprogramowania pośredniego, takiego jak router Express.
Iain Collins

31

Dostosowałem stary post, który nie jest już dostępny online do moich potrzeb. Użyłem express.Router () i zarejestrowałem moje trasy w następujący sposób:

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

Zmieniłem nazwę pliku document.js w apiTable.js i dostosowałem go w następujący sposób:

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

następnie nazywam to w moim server.js w następujący sposób:

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

Wynik wygląda następująco:

Przykład wyniku

To tylko przykład, ale może się przydać .. mam nadzieję ..


2
Nie działa to w przypadku tras zagnieżdżonych, jak określono tutaj: stackoverflow.com/questions/25260818/…

2
Uwaga na link w tej odpowiedzi! Przekierował mnie na losową stronę i wymusił pobranie na mój komputer.
Tyler Bell

29

Oto drobiazg, którego używam tylko po to, aby uzyskać zarejestrowane ścieżki w ekspresie 4.x.

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

gdzie to umieściłeś w app.js?
Juan

21

DEBUG=express:* node index.js

Jeśli uruchomisz aplikację za pomocą powyższego polecenia, uruchomi ona aplikację z DEBUGmodułem i poda trasy, a także wszystkie używane funkcje oprogramowania pośredniego.

Możesz polecić : ExpressJS - debugowanie i debugowanie .


3
Zdecydowanie najlepsza odpowiedź ... jedna env var!
Jeef

Rzeczywiście, najbardziej przydatna odpowiedź. @nbsamar Możesz nawet rozwinąć tę opcję, DEBUG=express:pathsaby zobaczyć, aby wyświetlić tylko ścieżkę wyjściową, a nie wszystkie inne komunikaty debugowania. Dzięki!
Mark Edington

19

Hacky kopiuj / wklej odpowiedź dzięki uprzejmości Douga Wilsona na temat ekspresowych problemów z githubem . Brudny, ale działa jak urok.

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, []))

Produkuje

Zrzut ekranu


Dlaczego trasy nie są różne?
Vladimir Vukanac

1
To jedyny, który pracował dla mnie z Express 4.15. Żaden z pozostałych nie podał pełnej ścieżki. Jedynym zastrzeżeniem jest to, że nie zwraca domyślnej ścieżki root / - żadna z nich nie.
Shane

Nie rozumiem, dlaczego wiążesz argumenty print?
ZzZombo,

@ZzZombo zapytaj Douga Wilsona, napisał to. Prawdopodobnie możesz to wszystko wyczyścić, jeśli chcesz.
AlienWebguy,

11

https://www.npmjs.com/package/express-list-endpoints działa całkiem dobrze.

Przykład

Stosowanie:

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

Wynik:

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

2
To nie działa z: server = express(); app1 = express(); server.use('/app1', app1); ...
Danosaure

8

Funkcja rejestrowania wszystkich tras w ekspresie 4 (może być łatwo dostosowana do v3 ~)

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

Dane wyjściowe dzienników:

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

Zrobiono to w NPM https://www.npmjs.com/package/express-list-routes


1
Nie działało to zgodnie z oczekiwaniami. app._router nie wydaje się zawierać tras z app.use ('/ path', otherRouter);
Michael Cole,

@MichaelCole Czy spojrzałeś na poniższą odpowiedź od Golo Roden?
Labithiotis,

@ Dazzler13 Bawiłem się tym przez godzinę i nie byłem w stanie zmusić go do działania. Express 4.0. Utworzona aplikacja, wykonany router, użycie aplikacji (ścieżka, router), trasy routera nie pojawiły się w app._router. Przykład?
Michael Cole,

Przykład z @Caleb poniżej działa dobrze dla tras obsługiwanych przez coś takiego jak express.Router, jeśli to twój problem. Pamiętaj, że trasy ustawione za pomocą oprogramowania pośredniego (w tym express.Router) mogą nie pojawić się od razu i konieczne może być dodanie ich z niewielkim opóźnieniem przed sprawdzeniem ich w app._router (nawet przy użyciu podejścia z @Caleb).
Iain Collins

8

wyjście json

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

wygląda tak:

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

ciąg wyjściowy

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

wygląda tak:

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

są one oparte na @ corvid za odpowiedź

mam nadzieję że to pomoże


5

Zainspirowały mnie trasy ekspresowe z listami Labithiotis, ale chciałem przeglądać wszystkie moje trasy i brutalne adresy URL za jednym razem, a nie podawać routera i za każdym razem wymyślać prefiks. Coś, co wymyśliłem, to po prostu zastąpić funkcję app.use moją własną funkcją, która przechowuje baseUrl i dany router. Stamtąd mogę wydrukować dowolną tabelę wszystkich moich tras.

UWAGA, to działa dla mnie, ponieważ deklaruję moje trasy w określonym pliku tras (funkcji), który jest przekazywany w obiekcie aplikacji, jak poniżej:

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

To pozwala mi przekazać inny obiekt „aplikacji” z fałszywą funkcją użytkowania i mogę uzyskać WSZYSTKIE trasy. To działa dla mnie (usunąłem pewne sprawdzanie błędów pod kątem przejrzystości, ale nadal działa w przykładzie):

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

Ten pełny przykład (z kilkoma podstawowymi routerami CRUD) został właśnie przetestowany i wydrukowany:

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

Za pomocą cli-table otrzymałem coś takiego:

┌────────┬───────────────────────┐
         => 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 
└────────┴───────────────────────────────────┘

Który kopie tyłek.


4

Ekspres 4

Biorąc pod uwagę konfigurację Express 4 z punktami końcowymi i zagnieżdżonymi routerami

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

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

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

app.use(router)

Po rozszerzeniu odpowiedzi @caleb można uzyskać rekursywnie i posortować wszystkie trasy.

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
}

Dla podstawowego ciągu wyjściowego.

infoAboutRoutes(app)

Wyjście konsoli

/**
* 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
}

Aktualizacja 1:

Ze względu na wewnętrzne ograniczenia Express 4 nie można pobrać zainstalowanej aplikacji i zamontowanych routerów. Na przykład nie można uzyskać tras z tej konfiguracji.

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

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

Wyświetlanie zamontowanych tras działa z tym pakietem: github.com/AlbertoFdzM/express-list-endpoints
jsaddwater

4

Potrzebujesz korekt, ale powinien działać w Expressie v4. W tym trasy dodane za pomocą .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", "..."]

edycja: ulepszenia kodu


3

Nieco zaktualizowane i bardziej funkcjonalne podejście do odpowiedzi @ 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

To zadziałało dla mnie

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

Zainicjuj router ekspresowy

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!',
      });
   });   

Zaimportuj kontroler użytkownika

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

Trasy użytkownika

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

Eksportuj trasy API

module.exports = router;

Wynik

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

1

W Express 3.5.x dodaję to przed uruchomieniem aplikacji, aby wydrukować trasy na moim terminalu:

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

Może to może pomóc ...


1

Możesz wdrożyć /get-all-routesinterfejs API:

const express = require("express");
const app = express();

app.get("/get-all-routes", (req, res) => {  
  let get = app._router.stack.filter(r => r.route && r.route.methods.get).map(r => r.route.path);
  let post = app._router.stack.filter(r => r.route && r.route.methods.post).map(r => r.route.path);
  res.send({ get: get, post: post });
});

const listener = app.listen(process.env.PORT, () => {
  console.log("Your app is listening on port " + listener.address().port);
});

Oto demo: https://glitch.com/edit/#!/get-all-routes-in-nodejs


0

Więc patrzyłem na wszystkie odpowiedzi .. nie lubiłem większości .. wziąłem kilka z kilku ... zrobiłem to:

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

nie najładniejszy .. ale zagnieżdżony, i załatwia sprawę

Zwróć też uwagę na 20 tam ... Po prostu zakładam, że nie będzie normalnej trasy z 20 metodami ... więc dedukuję, że to wszystko


0

szczegóły trasy zawierają listę tras dla „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));
});

PROSTA WYDAJNOŚĆ KODU

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"}
]

0

Wystarczy użyć tego pakietu npm, da on zarówno wyjście sieciowe, jak i końcowe w ładnym, sformatowanym widoku tabeli.

wprowadź opis zdjęcia tutaj

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


2
Ten drugi pakiet ma o wiele więcej akceptacji. npmjs.com/package/express-list-endpoints . Mam 21.111 wobec 34 cotygodniowych pobrań. Jednak express-routes-cataloguewyświetla również trasy jako HTML, chociaż druga nie.
mayid

1
nieźle, dokumentacja pakietu różni się od rzeczywistej nazwy pakietu, gdy jest wymagany, a ten pakiet, podobnie jak wszystkie inne wspomniane, pokazuje tylko trasy jednowarstwowe, w których jest uwzględniony
hamza khan

@hamzakhan ps dzięki za aktualizację. Jestem autorem, wkrótce zostanie zaktualizowany w dokumentacji.
Vijay

-1

Oto funkcja jednowierszowa do wydrukowania tras w 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

Opublikowałem pakiet, który drukuje całe oprogramowanie pośrednie, a także trasy, bardzo przydatne podczas próby skontrolowania aplikacji ekspresowej. Montujesz pakiet jako oprogramowanie pośrednie, więc nawet się drukuje:

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

Drukuje rodzaj drzewa, takiego jak:

- middleware 1
- middleware 2
- Route /thing/
- - middleware 3
- - controller (HTTP VERB)  
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.