Comment inclure des gestionnaires de routes dans plusieurs fichiers dans Express?

Dans mon expressapplication NodeJS , j'ai app.jsquelques itinéraires communs. Puis dans unwf.js fichier, je voudrais définir quelques itinéraires supplémentaires.

Comment puis-je app.jsreconnaître d'autres gestionnaires d'itinéraires définis dans le wf.jsfichier?

Un simple besoin ne semble pas fonctionner.

Si vous souhaitez placer les routes dans un fichier séparé , par exemple routes.js, vous pouvez créer le routes.jsfichier de cette façon:

module.exports = function(app){

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

    //other routes..
}

Et puis vous pouvez l'exiger de app.jspasser l' app objet de cette façon:

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

Jetez également un œil à ces exemples

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

Même si c'est une question plus ancienne, je suis tombé ici à la recherche d'une solution à un problème similaire. Après avoir essayé certaines des solutions ici, j'ai fini par aller dans une direction différente et j'ai pensé ajouter ma solution à quiconque se retrouverait ici.

Dans express 4.x, vous pouvez obtenir une instance de l'objet routeur et importer un autre fichier contenant plus de routes. Vous pouvez même le faire de manière récursive afin que vos itinéraires importent d'autres itinéraires vous permettant de créer des chemins d'url faciles à entretenir. Par exemple, si j'ai déjà un fichier de route séparé pour mon point de terminaison '/ tests' et que je veux ajouter un nouvel ensemble de routes pour '/ tests / automatisé', je peux vouloir séparer ces routes '/ automatisées' dans un autre fichier pour garder mon fichier '/ test' petit et facile à gérer. Il vous permet également de regrouper logiquement les itinéraires par chemin URL, ce qui peut être très pratique.

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

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

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

En me basant sur l'exemple de @ShadowCloud, j'ai pu inclure dynamiquement toutes les routes dans un sous-répertoire.

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

Ensuite, en plaçant les fichiers d'itinéraire dans le répertoire routes comme suit:

routes / test1.js

module.exports = function(app){

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

    //other routes..
}

Répéter cela autant de fois que nécessaire, puis enfin dans app.js en plaçant

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

Et construisez encore plus sur la réponse précédente, cette version de routes / index.js ignorera tous les fichiers ne se terminant pas par .js (et lui-même)

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

Routage récursif complet de tous les .jsfichiers dans le /routesdossier, mettez-le 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 /routesvous mettez whatevername.jset initialisez vos itinéraires comme ceci:

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

J'essaie de mettre à jour cette réponse avec "express": "^ 4.16.3". Cette réponse est similaire à 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;

J'espère que cela peut aider quelqu'un. Bon codage!

Si vous utilisez express-4.x avec TypeScript et ES6, ce serait le meilleur modèle à utiliser:

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

Beaucoup plus propre que l'utilisation de varet module.exports.

Un ajustement à toutes ces réponses:

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

Utilisez simplement une expression rationnelle pour filtrer en testant chaque fichier du tableau. Ce n'est pas récursif, mais il filtrera les dossiers qui ne se terminent pas par .js

Je sais que c'est une vieille question, mais j'essayais de comprendre quelque chose comme pour moi et c'est l'endroit où je me suis retrouvé, alors je voulais mettre ma solution à un problème similaire au cas où quelqu'un d'autre aurait les mêmes problèmes que moi '' m ayant. Il y a un joli module de nœud appelé consign qui fait beaucoup de choses sur le système de fichiers qui sont vues ici pour vous (c'est-à-dire - pas de choses readdirSync). Par exemple:

J'ai une application API reposante que j'essaie de créer et je veux mettre toutes les demandes qui vont dans '/ api / *' pour être authentifié et je veux stocker toutes mes routes qui vont en api dans leur propre répertoire (appelons-le simplement 'api'). Dans la partie principale de l'application:

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

À l'intérieur du répertoire des routes, j'ai un répertoire appelé "api" et un fichier appelé api.js. Dans api.js, j'ai simplement:

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;

Tout a fonctionné comme prévu. J'espère que cela aide quelqu'un.

Si vous voulez un fichier .js séparé pour mieux organiser vos itinéraires, créez simplement une variable dans le app.jsfichier pointant vers son emplacement dans le système de fichiers:

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

puis,

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

où .fooest une fonction déclarée dans votre wf.jsfichier. par exemple

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

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

}

J'ai écrit un petit plugin pour faire ça! en a eu marre d'écrire le même code encore et encore.

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

J'espère que ça aide.

C'est probablement la question / réponse la plus impressionnante de débordement de pile jamais. J'adore les solutions de Sam / Brad ci - dessus. Je pensais que je jouerais avec la version asynchrone que j'ai implémentée:

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

Ma structure de répertoires est un peu différente. Je définis généralement les itinéraires dans app.js (dans le répertoire racine du projet) par require-ing './routes'. Par conséquent, je saute le chèque index.jsparce que je veux également l'inclure.

EDIT: Vous pouvez également mettre ceci dans une fonction et l'appeler récursivement (j'ai édité l'exemple pour le montrer) si vous voulez imbriquer vos routes dans des dossiers de profondeur arbitraire.

vous pouvez placer toutes les fonctions de routage dans d'autres fichiers (modules) et les lier au fichier serveur principal. dans le fichier express principal, ajoutez une fonction qui liera le module au serveur:

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

et appelez cette fonction pour chaque modèle d'itinéraire:

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

dans les fichiers du module (par exemple - fichier login.js), définissez les fonctions comme d'habitude:

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

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

et l'exporter avec la méthode de demande comme clé et la valeur est un tableau d'objets, chacun avec des touches de chemin et de fonction.

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