¿Cómo incluir manejadores de ruta en múltiples archivos en Express?

En mi expressaplicación NodeJS , tengo app.jsalgunas rutas comunes. Luego, en un wf.jsarchivo, me gustaría definir algunas rutas más.

¿Cómo puedo llegar app.jsa reconocer otros controladores de ruta definidos en el wf.jsarchivo?

Un simple requerimiento no parece funcionar.

Si desea colocar las rutas en un archivo separado , por ejemplo routes.js, puede crear el routes.jsarchivo de esta manera:

module.exports = function(app){

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

    //other routes..
}

Y luego puede requerir que app.jspase el app objeto de esta manera:

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

Mira también estos ejemplos

https://github.com/visionmedia/express/tree/master/examples/route-separation

A pesar de que esta es una pregunta anterior, tropecé aquí buscando una solución a un problema similar. Después de probar algunas de las soluciones aquí, terminé yendo en una dirección diferente y pensé en agregar mi solución para cualquier otra persona que termine aquí.

En express 4.x puede obtener una instancia del objeto enrutador e importar otro archivo que contenga más rutas. Incluso puede hacer esto de forma recursiva para que sus rutas importen otras rutas, lo que le permite crear rutas de URL fáciles de mantener. Por ejemplo, si ya tengo un archivo de ruta separado para mi punto final '/ tests' y quiero agregar un nuevo conjunto de rutas para '/ tests / automatic', es posible que desee dividir estas rutas '/ automatizadas' en otro archivo para mantener mi archivo '/ test' pequeño y fácil de administrar. También le permite agrupar rutas lógicamente por ruta URL, lo que puede ser realmente conveniente.

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

Contenido de ./routes/tests.js

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;

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

Partiendo del ejemplo de @ShadowCloud pude incluir dinámicamente todas las rutas en un subdirectorio.

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

Luego, coloca los archivos de ruta en el directorio de rutas de esta manera:

rutas / test1.js

module.exports = function(app){

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

    //other routes..
}

Repitiendo eso tantas veces como lo necesitaba y luego finalmente en app.js colocando

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

Y construya aún más sobre la respuesta anterior, esta versión de routes / index.js ignorará cualquier archivo que no termine en .js (y en sí mismo)

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

Enrutamiento recursivo completo de todos los .jsarchivos dentro de la /routescarpeta, colóquelo app.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

en /routesponer whatevername.jse inicializar sus rutas de esta manera:

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

Estoy tratando de actualizar esta respuesta con "express": "^ 4.16.3". Esta respuesta es similar 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 esto pueda ayudar a alguien. ¡Feliz codificación!

Si está utilizando express-4.x con TypeScript y ES6, esta sería la mejor plantilla para usar:

src/api/login.ts

import express, { Router, Request, Response } from "express";

const router: Router = express.Router();
// POST /user/signin
router.post('/signin', async (req: Request, res: Response) => {
    try {
        res.send('OK');
    } catch (e) {
        res.status(500).send(e.toString());
    }
});

export default router;

src/app.ts

import express, { Request, Response } from "express";
import compression from "compression";  // compresses requests
import expressValidator from "express-validator";
import bodyParser from "body-parser";
import login from './api/login';

const app = express();

app.use(compression());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(expressValidator());

app.get('/public/hc', (req: Request, res: Response) => {
  res.send('OK');
});

app.use('/user', login);

app.listen(8080, () => {
    console.log("Press CTRL-C to stop\n");
});

Mucho más limpio que usar vary module.exports.

Un ajuste a todas estas respuestas:

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

Simplemente use una expresión regular para filtrar mediante la prueba de cada archivo en la matriz. No es recursivo, pero filtrará las carpetas que no terminen en .js

Sé que esta es una vieja pregunta, pero estaba tratando de resolver algo así para mí y este es el lugar donde terminé, así que quería poner mi solución a un problema similar en caso de que alguien más tenga los mismos problemas que yo ' m teniendo. Hay un buen módulo de nodo llamado consign que hace muchas de las cosas del sistema de archivos que se ven aquí para usted (es decir, no hay cosas readdirSync). Por ejemplo:

Tengo una aplicación de API tranquila que estoy tratando de construir y quiero poner todas las solicitudes que van a '/ api / *' para autenticarme y quiero almacenar todas mis rutas que van en api en su propio directorio (vamos a llamarlo 'api'). En la parte principal de la aplicación:

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

Dentro del directorio de rutas, tengo un directorio llamado "api" y un archivo llamado api.js. En api.js, simplemente tengo:

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;

Todo funcionó como se esperaba. Espero que esto ayude a alguien.

Si desea un archivo .js separado para organizar mejor sus rutas, simplemente cree una variable en el app.jsarchivo que apunte a su ubicación en el sistema de archivos:

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

luego,

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

donde .foose declara alguna función en su wf.jsarchivo. p.ej

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

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

}

¡Escribí un pequeño complemento para hacer esto! me cansé de escribir el mismo código una y otra vez.

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

Espero eso ayude.

Esta es posiblemente la pregunta / respuesta de desbordamiento de pila más impresionante que haya existido. Me encantan las soluciones de Sam / Brad anteriores. Pensé en intervenir con la versión asíncrona que implementé:

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

La estructura de mi directorio es un poco diferente. Normalmente defino rutas en app.js (en el directorio raíz del proyecto) haciendo require-ing './routes'. En consecuencia, me estoy saltando el cheque en contra index.jsporque quiero incluir ese también.

EDITAR: También puede poner esto en una función y llamarlo de forma recursiva (edité el ejemplo para mostrar esto) si desea anidar sus rutas en carpetas de profundidad arbitraria.

puede colocar todas las funciones de ruta en otros archivos (módulos) y vincularlo al archivo del servidor principal. en el archivo express principal, agregue una función que vinculará el módulo al servidor:

   function link_routes(app, route_collection){
       route_collection['get'].forEach(route => app.get(route.path, route.func));
       route_collection['post'].forEach(route => app.post(route.path, route.func));
       route_collection['delete'].forEach(route => app.delete(route.path, route.func));
       route_collection['put'].forEach(route => app.put(route.path, route.func));
   }

y llame a esa función para cada modelo de ruta:

link_routes(app, require('./login.js'))

en los archivos del módulo (por ejemplo, archivo login.js), defina las funciones como de costumbre:

const login_screen = (req, res) => {
    res.sendFile(`${__dirname}/pages/login.html`);
};

const forgot_password = (req, res) => {
    console.log('we will reset the password here')
}

y exportarlo con el método de solicitud como una clave y el valor es una matriz de objetos, cada uno con ruta y teclas de función.

module.exports = {
   get: [{path:'/',func:login_screen}, {...} ],
   post: [{path:'/login:forgotPassword', func:forgot_password}]
};