om base no exemplo do @ShadowCloud, pude incluir dinamicamente todas as rotas em um subdiretóri

routes / index.js

var fs = require('fs');

module.exports = function(app){
    fs.readdirSync(__dirname).forEach(function(file) {
        if (file == "index.js") return;
        var name = file.substr(0, file.indexOf('.'));
        require('./' + name)(app);
    });
}

Em seguida, coloque os arquivos de rota no diretório de rotas da seguinte maneira:

rotas / test1.js

module.exports = function(app){

    app.get('/test1/', function(req, res){
        //...
    });

    //other routes..
}

Repetindo isso por quantas vezes eu precisasse e, finalmente, em app.js colocando

require('./routes')(app);

Mesmo que esta seja uma pergunta mais antiga, eu tropecei aqui, procurando uma solução para um problema semelhante. Depois de tentar algumas das soluções aqui, acabei indo em uma direção diferente e pensei em adicionar minha solução para qualquer pessoa que acabar aqu

@In express 4.x pode obter uma instância do objeto roteador e importar outro arquivo que contém mais rotas. Você pode até fazer isso recursivamente para que suas rotas importem outras, permitindo criar caminhos de URL fáceis de manter. Por exemplo, se eu já tiver um arquivo de rota separado para o terminal '/ tests' e desejar adicionar um novo conjunto de rotas para '/ tests / automatic', convém dividir essas rotas '/ automatic' em outro arquivo para mantenha meu arquivo '/ test' pequeno e fácil de gerenciar. Ele também permite que você agrupe logicamente as rotas pelo caminho da URL, o que pode ser realmente convenient

Conteúdo de ./app.js

var express = require('express'),
    app = express();

var testRoutes = require('./routes/tests');

// Import my test routes into the path '/test'
app.use('/tests', testRoutes);

Conteúdo de ./routes/tests.j

var express = require('express'),
    router = express.Router();

var automatedRoutes = require('./testRoutes/automated');

router
  // Add a binding to handle '/test'
  .get('/', function(){
    // render the /tests view
  })

  // Import my automated routes into the path '/tests/automated'
  // This works because we're already within the '/tests' route so we're simply appending more routes to the '/tests' endpoint
  .use('/automated', automatedRoutes);

module.exports = router;

Conteúdo de ./routes/testRoutes/automated.js

var express = require('express'),
    router = express.Router();

router
   // Add a binding for '/tests/automated/'
  .get('/', function(){
    // render the /tests/automated view
  })

module.exports = router;

E desenvolva ainda mais a resposta anterior, esta versão do routes / index.js ignorará todos os arquivos que não terminem em .js (e em si)

var fs = require('fs');

module.exports = function(app) {
    fs.readdirSync(__dirname).forEach(function(file) {
        if (file === "index.js" || file.substr(file.lastIndexOf('.') + 1) !== 'js')
            return;
        var name = file.substr(0, file.indexOf('.'));
        require('./' + name)(app);
    });
}

Roteamento recursivo completo de todos os.js arquivos dentro de/routes, coloque isso emapp.js.

// Initialize ALL routes including subfolders
var fs = require('fs');
var path = require('path');

function recursiveRoutes(folderName) {
    fs.readdirSync(folderName).forEach(function(file) {

        var fullName = path.join(folderName, file);
        var stat = fs.lstatSync(fullName);

        if (stat.isDirectory()) {
            recursiveRoutes(fullName);
        } else if (file.toLowerCase().indexOf('.js')) {
            require('./' + fullName)(app);
            console.log("require('" + fullName + "')");
        }
    });
}
recursiveRoutes('routes'); // Initialize it

em/routes você colocawhatevername.js e inicialize suas rotas assim:

module.exports = function(app) {
    app.get('/', function(req, res) {
        res.render('index', { title: 'index' });
    });

    app.get('/contactus', function(req, res) {
        res.render('contactus', { title: 'contactus' });
    });
}

Um ajuste para todas estas respostas:

var routes = fs.readdirSync('routes')
      .filter(function(v){
         return (/.js$/).test(v);
      });

Basta usar um regex para filtrar através do teste de cada arquivo na matriz. Não é recursivo, mas filtrará as pastas que não terminam em .js

Eu sei que essa é uma pergunta antiga, mas eu estava tentando descobrir algo parecido comigo e este é o lugar em que acabei, então eu queria colocar minha solução para um problema semelhante, caso outra pessoa tenha os mesmos problemas que eu. estou tendo. Existe um bom módulo de nó chamado consign que faz muito do material do sistema de arquivos que é visto aqui para você (ou seja, - nada de readdirSync) Por exemplo

Eu tenho um aplicativo API repousante que estou tentando criar e quero colocar todas as solicitações que vão para '/ api / *' para serem autenticadas e quero armazenar todas as minhas rotas que entram na api por conta própria diretório (vamos chamá-lo de 'api'). Na parte principal do aplicativo:

app.use('/api', [authenticationMiddlewareFunction], require('./routes/api'));

Dentro do diretório de rotas, eu tenho um diretório chamado "api" e um arquivo chamado api.js. No api.js, eu simplesmente tenho:

var express = require('express');
var router = express.Router();
var consign = require('consign');

// get all routes inside the api directory and attach them to the api router
// all of these routes should be behind authorization
consign({cwd: 'routes'})
  .include('api')
  .into(router);

module.exports = router;

Tudo funcionou como esperado. Espero que isso ajude alguém.

Se desejar um arquivo .js separado para organizar melhor suas rotas, basta criar uma variável noapp.js arquivo apontando para sua localização no sistema de arquivos:

var wf = require(./routes/wf);

então

app.get('/wf', wf.foo );

Onde.foo é alguma função declarada no seuwf.js Arquivo. por exempl

// wf.js file 
exports.foo = function(req,res){

          console.log(` request object is ${req}, response object is ${res} `);

}

Estou tentando atualizar esta resposta com "express": "^ 4.16.3". Esta resposta é semelhante a ShortRound1911.

server.js

const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');
const db = require('./src/config/db');
const routes = require('./src/routes');
const port = 3001;

const app = new express();

//...use body-parser
app.use(bodyParser.urlencoded({ extended: true }));

//...fire connection
mongoose.connect(db.url, (err, database) => {
  if (err) return console.log(err);

  //...fire the routes
  app.use('/', routes);

  app.listen(port, () => {
    console.log('we are live on ' + port);
  });
});

/ src / routes / index.js

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

const siswaRoute = require('./siswa_route');

app.get('/', (req, res) => {
  res.json({item: 'Welcome ini separated page...'});
})
.use('/siswa', siswaRoute);

module.exports = app;

/ src / routes / siswa_route.js

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

app.get('/', (req, res) => {
  res.json({item: 'Siswa page...'});
});

module.exports = app;

Espero que isso possa ajudar alguém. Feliz codificação!

Esta é possivelmente a (s) pergunta (s) mais impressionante (s) de estouro de pilha de todos os tempos. EUama Soluções de Sam / Brad acima. Pensei que eu iria concordar com a versão assíncrona que eu implementei:

function loadRoutes(folder){
    if (!folder){
        folder = __dirname + '/routes/';
    }

    fs.readdir(folder, function(err, files){
        var l = files.length;
        for (var i = 0; i < l; i++){
            var file = files[i];
            fs.stat(file, function(err, stat){
                if (stat && stat.isDirectory()){
                    loadRoutes(folder + '/' + file + '/');
                } else {
                    var dot = file.lastIndexOf('.');
                    if (file.substr(dot + 1) === 'js'){
                        var name = file.substr(0, dot);

                        // I'm also passing argv here (from optimist)
                        // so that I can easily enable debugging for all
                        // routes.
                        require(folder + name)(app, argv);
                    }
                }
            });
        }
    });
}

Minha estrutura de diretórios é um pouco diferente. Normalmente, defino rotas no app.js (no diretório raiz do projeto) porrequire -ing'./routes'. Conseqüentemente, estou pulando o cheque contraindex.js porque euque para incluir esse també

EDIT: Você também pode colocar isso em uma função e chamá-lo recursivamente (editei o exemplo para mostrar isso) se quiser aninhar suas rotas em pastas de profundidade arbitrári

Eu escrevi um pequeno plugin para fazer isso! ficou cansado de escrever o mesmo código repetidament

https: //www.npmjs.com/package/js-file-re

Espero que ajude