एक्सप्रेस में सभी पंजीकृत मार्ग कैसे प्राप्त करें?


181

मेरे पास Node.js और Express का उपयोग करके बनाया गया एक वेब एप्लिकेशन है। अब मैं सभी पंजीकृत मार्गों को उनके उपयुक्त तरीकों के साथ सूचीबद्ध करना चाहूंगा।

जैसे, अगर मैंने अमल किया है

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

मैं एक वस्तु (या उस के बराबर कुछ) को पुनः प्राप्त करना चाहूंगा:

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

क्या यह संभव है और यदि ऐसा हो तो कैसे?


अद्यतन: इस बीच, मैंने एक एनपीएम पैकेज बनाया है जिसे गेट -रूट कहा जाता है जो किसी दिए गए एप्लिकेशन से मार्गों को निकालता है, जो इस मुद्दे को हल करता है। वर्तमान में, केवल एक्सप्रेस 4.x समर्थित है, लेकिन मुझे लगता है कि अब यह ठीक है। सिर्फ आपकी जानकारी के लिए।


जब मैंने राउटर्स को परिभाषित किया है, तो मेरे द्वारा किए गए सभी समाधान काम नहीं करते हैं। यह केवल प्रति रूट काम करता है - जो मुझे मेरे ऐप में उस रूट के लिए संपूर्ण url नहीं देता है ...
लड़का 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
केवल एक्सप्रेस 3.x के लिए काम करता है, 4.x पर नहीं। 4.x में, आप की जाँच करनी चाहिएapp._router.stack
avetisk

14
यह मेरे लिए उम्मीद के मुताबिक काम नहीं किया। app._router app.use ('/ path', otherRouter) से मार्गों को शामिल नहीं करता है;
माइकल कोल

क्या कोई रास्ता है कि यह एक कमांड-लाइन स्क्रिप्ट के साथ एकीकृत किया जा सकता है जो वास्तव में उसी मार्ग फ़ाइलों में खींचेगा जो लाइव ऐप वास्तव में एक वेब ऐप शुरू किए बिना करता है?
लॉरेंस आई। सिडेन

5
कम से कम 4.13.1 एक्सप्रेस app._router.stackमें अपरिभाषित है।
लेविग्रोकर

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

1
ध्यान दें कि यदि आप एक्सप्रेस राउटर (या अन्य मिडलवेयर) जैसी किसी चीज का उपयोग कर रहे हैं, तो आपको @Caleb को थोड़ा लंबा जवाब देना चाहिए जो इस दृष्टिकोण से फैलता है।
इयान कॉलिन्स

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
बहुत बढ़िया, एक उदाहरण के लिए धन्यवाद जो दिखाता है कि एक्सप्रेस राउटर जैसे मिडलवेयर के माध्यम से डिस्प्ले रूट कैसे प्राप्त करें।
इयान कॉलिन्स

31

मैंने एक पुरानी पोस्ट को अनुकूलित किया है जो अब मेरी जरूरतों के लिए ऑनलाइन नहीं है। मैंने एक्सप्रेस का उपयोग किया है। राउटर () और मेरे मार्गों को इस तरह पंजीकृत किया है:

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

तब मैं इसे अपने सर्वर में कहता हूं। जेएस इस तरह:

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

परिणाम इस तरह दिखता है:

परिणाम उदाहरण

यह सिर्फ एक उदाहरण है, लेकिन उपयोग का हो सकता है .. मुझे आशा है कि ..


2
यह यहां पहचाने गए नेस्टेड मार्गों के लिए काम नहीं करता है: stackoverflow.com/questions/25260818/…

2
इस उत्तर में लिंक से सावधान रहें! इसने मुझे एक बेतरतीब वेबसाइट पर पुनर्निर्देशित किया और मेरे कंप्यूटर को डाउनलोड करने के लिए मजबूर किया।
टायलर बेल

29

यहाँ एक छोटी सी बात है जो मैं व्यक्त 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

कंसोल.लॉग (server._router.stack.map (r => r.route) .filter (r => r) .map (r => ${Object.keys(r.methods).join(', ')} ${r.path})
standup75

आप इसे कहां डालते हैं, app.js में ??
जुआन

21

DEBUG=express:* node index.js

यदि आप अपने ऐप को उपरोक्त कमांड के साथ चलाते हैं, तो यह आपके ऐप को DEBUGमॉड्यूल के साथ लॉन्च करेगा और रूट, प्लस सभी मिडलवेयर फ़ंक्शंस देता है।

आप उल्लेख कर सकते हैं: ExpressJS - डिबगिंग और डीबग


3
अब तक का सबसे अच्छा जवाब ... एक एनवी संस्करण!
Jeef

वास्तव में, सबसे उपयोगी जवाब। @nbsamar आप इसे DEBUG=express:pathsकेवल पथ आउटपुट और अन्य सभी डीबग संदेशों को देखने के लिए उपयोग करने के लिए कहने के लिए भी विस्तारित कर सकते हैं । धन्यवाद!
मार्क एडिंगटन

19

हैथ कॉपी / पेस्ट एक्सप्रेस शिथिल मुद्दों पर डग विल्सन के सौजन्य से जवाब । गंदा लेकिन एक आकर्षण की तरह काम करता है।

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

का उत्पादन

चित्रपट पकड़ना


मार्ग अलग क्यों नहीं हैं?
व्लादिमीर वुकानैक

1
यह केवल वही है जिसने मेरे लिए एक्सप्रेस 4.15 के साथ काम किया। दूसरों में से किसी ने भी पूरा रास्ता नहीं दिया। एकमात्र चेतावनी यह है कि यह डिफ़ॉल्ट रूट पथ को वापस नहीं देता / - उनमें से कोई भी नहीं करता है।
शेन

मुझे समझ नहीं आ रहा है कि आप तर्क क्यों बाँधते हैं print?
ZZZombo

@ZzZombo डग विल्सन से पूछें, उन्होंने इसे लिखा था। आप शायद यह सब साफ कर सकते हैं यदि आप चाहते हैं।
21:39 पर एलियनवेगु

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

एक्सप्रेस 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

इसे एनपीएम https://www.npmjs.com/package/express-list-routes में बनाया


1
यह मेरे लिए उम्मीद के मुताबिक काम नहीं किया। app._router app.use ('/ path', otherRouter) से मार्गों को शामिल नहीं करता है;
माइकल कोल

@MichaelCole क्या आपने नीचे गोलो रोडेन के उत्तर को देखा?
लेबिथियोटिस

@ Dazzler13 मैंने इसके साथ एक घंटे तक खेला, और यह काम करने में सक्षम नहीं था। एक्सप्रेस 4.0। एप बनाया, राउटर, एप.यूज (पाथ, राउटर), राउटर रूट एप में दिखाई नहीं दिया। उदाहरण?
माइकल कोल

नीचे दिए गए @Caleb से उदाहरण व्यक्त करता है कि एक्सप्रेस जैसे कुछ के साथ काम करने वाले मार्गों के लिए। ध्यान दें कि मिडलवेयर (एक्सप्रेस राउटर सहित) के साथ तय किए गए मार्ग अभी दिखाई नहीं दे सकते हैं और आपको ऐप में उनके लिए जाँच करने से पहले थोड़ी देरी में जोड़ना पड़ सकता है।
इयान कॉलिन्स

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

मैं लेबिथियोटिस की एक्सप्रेस-लिस्ट-मार्गों से प्रेरित था, लेकिन मैं अपने सभी मार्गों और एक ही बार में क्रूर url का अवलोकन चाहता था, और एक राउटर निर्दिष्ट नहीं करता था, और हर बार उपसर्ग का पता लगाता था। जो कुछ मैं लेकर आया था वह बस अपने स्वयं के फ़ंक्शन के साथ app.use फ़ंक्शन को बदलना था जो बेसयूआरएल और राउटर को संग्रहीत करता है। वहां से मैं अपने सभी मार्गों की किसी भी तालिका को प्रिंट कर सकता हूं।

नोट करें कि यह मेरे लिए काम करता है क्योंकि मैं अपने मार्गों को एक विशिष्ट मार्ग फ़ाइल (फ़ंक्शन) में घोषित करता हूं जो ऐप ऑब्जेक्ट में पास हो जाता है, जैसे:

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

क्ली-टेबल का उपयोग करके मुझे कुछ इस तरह मिला:

┌────────┬───────────────────────┐
         => 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 कॉन्फ़िगरेशन को देखते हुए

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:

एक्सप्रेस 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

कुछ समायोजन की आवश्यकता है लेकिन एक्सप्रेस 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

@ प्रणय के उत्तर के लिए थोड़ा अद्यतन और अधिक कार्यात्मक दृष्टिकोण:

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

ओ / पी:

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

एपीआई मार्ग निर्यात करें

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

एक्सप्रेस 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-routesएपीआई लागू कर सकते हैं :

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

मार्ग विवरण "एक्सप्रेस" के लिए मार्ग सूचीबद्ध कर रहे हैं: "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-catalogueHTML के रूप में मार्गों को भी प्रदर्शित करता है, दूसरे को नहीं करता है।
मई

1
खराब नहीं है, पैकेज का प्रलेखन आवश्यकता होने पर वास्तविक पैकेज के नाम से भिन्न होता है और यह पैकेज अन्य सभी की तरह ही एकल परत मार्गों को दिखाता है जहां यह शामिल है
हमजा खान

@hamzakhan ps अद्यतन के लिए धन्यवाद। मैं लेखक हूँ, जल्द ही प्रलेखन में अद्यतन किया जाएगा।
विजय

-1

यहां एक्सप्रेस में मार्गों को सुंदर रूप से प्रिंट करने के लिए एक-लाइन फ़ंक्शन है 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();

-1

व्यक्त में 4. *

//Obtiene las rutas declaradas de la API
    let listPathRoutes: any[] = [];
    let rutasRouter = _.filter(application._router.stack, rutaTmp => rutaTmp.name === 'router');
    rutasRouter.forEach((pathRoute: any) => {
        let pathPrincipal = pathRoute.regexp.toString();
        pathPrincipal = pathPrincipal.replace('/^\\','');
        pathPrincipal = pathPrincipal.replace('?(?=\\/|$)/i','');
        pathPrincipal = pathPrincipal.replace(/\\\//g,'/');
        let routesTemp = _.filter(pathRoute.handle.stack, rutasTmp => rutasTmp.route !== undefined);
        routesTemp.forEach((route: any) => {
            let pathRuta = `${pathPrincipal.replace(/\/\//g,'')}${route.route.path}`;
            let ruta = {
                path: pathRuta.replace('//','/'),
                methods: route.route.methods
            }
            listPathRoutes.push(ruta);
        });
    });console.log(listPathRoutes)

-2

मैंने एक पैकेज प्रकाशित किया जो सभी मिडलवेयर और रूट्स को प्रिंट करता है, एक्सप्रेस एप्लिकेशन को ऑडिट करने की कोशिश करते समय वास्तव में उपयोगी होता है। आप पैकेज को मिडलवेयर के रूप में माउंट करते हैं, इसलिए यह खुद भी प्रिंट करता है:

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

यह एक तरह के पेड़ को प्रिंट करता है जैसे:

- middleware 1
- middleware 2
- Route /thing/
- - middleware 3
- - controller (HTTP VERB)  
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.