Express에서 등록 된 모든 경로를 얻는 방법은 무엇입니까?


181

Node.js 및 Express를 사용하여 작성된 웹 응용 프로그램이 있습니다. 이제 등록 된 모든 경로를 적절한 방법으로 나열하고 싶습니다.

예를 들어 내가 처형했다면

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

다음과 같은 객체 (또는 그와 동등한 것)를 검색하고 싶습니다.

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

이것이 가능합니까? 그렇다면 가능합니까?


업데이트 : 한편, 주어진 응용 프로그램에서 경로 를 추출하는 get-routes 라는 npm 패키지를 만들었습니다 .이 문제를 해결합니다. 현재 Express 4.x 만 지원되지만 지금은 괜찮습니다. 참고로


라우터를 정의했을 때 시도한 모든 솔루션이 작동하지 않습니다. 그것은 경로 당 작동합니다-그것은 내 응용 프로그램에서 해당 경로에 대한 전체 URL을 제공하지 않습니다 ...
guy mograbi

답변:


230

3.x를 표현하다

좋아, 나 자신을 발견했다 ... 그것은 단지 app.routes:-)

4.x를 표현하십시오

응용 프로그램 -내장express()

app._router.stack

라우터 -내장express.Router()

router.stack

참고 : 스택에는 미들웨어 기능도 포함되어 있으므로 "라우트" 만 가져 오도록 필터링해야합니다 .


나는 노드 0.10를 사용하고 그리고 그것은이었다 app.routes.routes- 나는 JSON.stringify (app.routes.routes) 할 수있는 수단
남자 mograbi

7
4.x가 아닌 Express 3.x에서만 작동합니다. 4.x의, 당신은 확인해야합니다app._router.stack
avetisk

14
이것은 나에게 예상대로 작동하지 않았습니다. app._router에 app.use ( '/ path', otherRouter)의 경로가 포함되지 않은 것 같습니다.
Michael Cole

실제로 웹 응용 프로그램을 시작하지 않고 라이브 앱과 동일한 경로 파일을 가져 오는 명령 줄 스크립트와 통합 할 수있는 방법이 있습니까?
Lawrence I. Siden

5
적어도 표현 4.13.1 app._router.stack에서는 정의되지 않았습니다.
levigroker

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

1
Express Router (또는 다른 미들웨어)와 같은 것을 사용하는 경우 @Caleb이 약간 더 길어이 접근 방식으로 확장되는 것을 볼 수 있습니다.
Iain Collins

31

앱에 직접 등록 된 경로 (app.VERB를 통해)와 라우터 미들웨어로 등록 된 경로 (app.use를 통해)를 가져옵니다. 익스프레스 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
Express 라우터와 같은 미들웨어를 통해 표시 경로를 설정하는 방법을 보여주는 예 덕분입니다.
Iain Collins

31

더 이상 내 필요에 맞지 않는 오래된 게시물을 수정했습니다. express.Router ()를 사용하고 다음과 같이 내 경로를 등록했습니다.

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

apiTable.js에서 document.js 파일의 이름을 바꾸고 다음과 같이 수정했습니다.

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

그런 다음 server.js에서 다음과 같이 호출합니다.

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

결과는 다음과 같습니다.

결과 예

이것은 단지 예일 뿐이지 만 유용 할 수 있습니다 .. 희망합니다 ..


2
여기에

2
이 답변의 링크를 조심하십시오! 그것은 임의의 웹 사이트로 나를 리디렉션하고 내 컴퓨터로 다운로드를 강요했습니다.
Tyler Bell

29

Express 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

app.js에서 이것을 어디에 넣습니까?
Juan Juan

21

DEBUG=express:* node index.js

위 명령으로 앱을 실행하면 DEBUG모듈로 앱을 시작 하고 경로와 사용중인 모든 미들웨어 기능을 제공합니다.

ExpressJS-디버깅디버그를 참조하십시오 .


3
지금까지 가장 좋은 대답은 ... 하나의 환경 변수입니다!
Jeef

실제로 가장 유용한 답변입니다. @nbsamar DEBUG=express:paths다른 디버그 메시지가 아니라 경로 출력 만 보는 데 사용 하도록 확장 할 수도 있습니다 . 감사!
Mark Edington

19

특급 github 문제 에 대한 Doug Wilson 의 해시 복사 / 붙여 넣기 답변 . 더럽지 만 매력처럼 작동합니다.

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

생산

스크린


경로가 다른 이유는 무엇입니까?
Vladimir Vukanac

1
이것은 Express 4.15에서 나를 위해 일한 유일한 것입니다. 다른 어느 누구도 완전한 길을 제시하지 못했습니다. 유일한 경고는 기본 루트 경로를 제공하지 않는다는 것입니다.
Shane

왜 당신은 인수를 바인딩합니까 이해가되지 않습니다 print?
ZzZombo

@ZzZombo는 Doug Wilson에게 물었다. 원하는 경우이 모든 것을 정리할 수 있습니다.
AlienWebguy

11

https://www.npmjs.com/package/express-list-endpoints 는 꽤 잘 작동합니다.

용법:

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

산출:

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

2
이 기능은 작동하지 않습니다 : server = express(); app1 = express(); server.use('/app1', app1); ...
Danosaure

8

Express 4의 모든 경로를 기록하는 기능 (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);

로그 출력 :

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

이것을 NPM으로 만들었습니다 https://www.npmjs.com/package/express-list-routes


1
이것은 나에게 예상대로 작동하지 않았습니다. app._router에 app.use ( '/ path', otherRouter)의 경로가 포함되지 않은 것 같습니다.
Michael Cole

@MichaelCole Golo Roden의 아래 답변을 보셨습니까?
Labithiotis

@ Dazzler13 나는 한 시간 동안 이것을 가지고 놀았고 그것을 작동시키지 못했습니다. Express 4.0. app., router, app.use (path, router), router route가 app._router에 나타나지 않았습니다. 예?
Michael Cole

아래 @Caleb의 예제는 express.Router와 같은 문제로 처리되는 경로에 적합합니다. 미들웨어 (Express.Router 포함)로 설정된 경로는 즉시 표시되지 않을 수 있으며 app._router에서 확인하기 전에 약간의 지연을 추가해야 할 수도 있습니다 (@Caleb의 접근 방식을 사용하더라도).
Iain Collins

8

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

다음과 같이 보입니다 :

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

문자열 출력

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

다음과 같이 보입니다 :

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

이들은 @corvid의 답변을 기반으로합니다.

도움이 되었기를 바랍니다


5

나는 Labithiotis의 급행 목록 노선에서 영감을 얻었지만 한 번에 모든 경로와 무차별 URL에 대한 개요를 원했고 라우터를 지정하지 않고 매번 접두사를 알아 냈습니다. 내가 생각해 낸 것은 단순히 app.use 함수를 baseUrl과 주어진 라우터를 저장하는 내 함수로 바꾸는 것입니다. 거기에서 모든 경로의 모든 테이블을 인쇄 할 수 있습니다.

참고 다음과 같이 app 객체에 전달되는 특정 경로 파일 (함수)에 경로를 선언하기 때문에 이것은 나를 위해 작동합니다.

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

이를 통해 가짜 사용 기능으로 다른 '앱'객체를 전달할 수 있으며 모든 경로를 얻을 수 있습니다. 이것은 나를 위해 작동합니다 (명확성을 위해 일부 오류 검사가 제거되었지만 여전히 예제에서는 작동합니다).

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

이 전체 예제 (일부 기본 CRUD 라우터 포함)는 방금 테스트 및 인쇄되었습니다.

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

cli-table을 사용하여 다음과 같은 것을 얻었습니다.

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

엉덩이를 차는.


4

익스프레스 4

엔드 포인트 및 중첩 라우터가 있는 Express 4 구성

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

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

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

app.use(router)

@caleb 응답을 확장하면 모든 경로를 재귀 적으로 정렬 할 수 있습니다.

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
}

기본 문자열 출력용.

infoAboutRoutes(app)

콘솔 출력

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

업데이트 1 :

Express 4의 내부 제한으로 인해 탑재 된 앱 및 탑재 된 라우터를 검색 할 수 없습니다. 예를 들어이 구성에서 경로를 얻을 수 없습니다.

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

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

: 목록이 패키지 경로의 작품에 장착 github.com/AlbertoFdzM/express-list-endpoints
jsaddwater

4

조정이 필요하지만 Express v4에서는 작동해야합니다. 로 추가 된 경로를 포함합니다 .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", "..."]

편집 : 코드 개선


3

@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

이것은 나를 위해 일했다

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

고속 라우터 초기화

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

사용자 컨트롤러 가져 오기

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

사용자 경로

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 경로 내보내기

module.exports = router;

산출

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

1

Express 3.5.x에서는 터미널에 경로를 인쇄하기 위해 앱을 시작하기 전에 이것을 추가합니다.

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

아마 도움이 될 수 있습니다 ...


1

/get-all-routesAPI 를 구현할 수 있습니다 .

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

데모는 다음과 같습니다. https://glitch.com/edit/#!/get-all-routes-in-nodejs


0

그래서 나는 모든 대답을보고있었습니다 .. 가장 마음에 들지 않았습니다 .. 몇 가지를 가져갔습니다.

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

가장 예쁘지 않은 ..하지만 중첩, 트릭을 수행

또한 20을 참고하십시오 ... 나는 단지 20 가지 방법으로 정상적인 경로가 없을 것이라고 가정합니다. 그래서 나는 그것이 전부라고 추론합니다.


0

경로 세부 사항은 "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));
});

간단한 코드 출력

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

이 npm 패키지를 사용하면 멋진 형식의 테이블보기로 웹 출력과 터미널 출력이 제공됩니다.

여기에 이미지 설명을 입력하십시오

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


2
이 다른 패키지는 더 많은 수용력을 가지고 있습니다. npmjs.com/package/express-list-endpoints . 매주 34 회 다운로드에 대해 21.111입니다. 그러나 express-routes-catalogue경로를 HTML로 표시 하지만 다른 경로는 그렇지 않습니다.
mayid

1
나쁘지 않은데, 패키지의 문서는 필요할 때 실제 패키지 이름과 다르며이 패키지는 언급 된 다른 모든 패키지와 같이 단일 계층 경로 만 보여줍니다
hamza khan

@hamzakhan ps 업데이트에 감사드립니다. 저는 저자입니다. 곧 설명서에서 업데이트 될 예정입니다.
Vijay

-1

다음은 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

모든 미들웨어 및 경로를 인쇄하는 패키지를 게시하여 Express 응용 프로그램을 감사 할 때 유용합니다. 패키지를 미들웨어로 마운트하면 자체적으로 인쇄됩니다.

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

다음과 같은 종류의 나무를 인쇄합니다.

- middleware 1
- middleware 2
- Route /thing/
- - middleware 3
- - controller (HTTP VERB)  
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.