je recommande d'utiliser glob pour accomplir cette tâche.

var glob = require( 'glob' )
  , path = require( 'path' );

glob.sync( './routes/**/*.js' ).forEach( function( file ) {
  require( path.resolve( file ) );
});

sur la base de la solution de @tbranyen, je crée un fichier index.js qui charge des javascripts arbitraires sous le dossier courant dans le cadre du exports .

// Load `*.js` under current directory as properties
//  i.e., `User.js` will become `exports['User']` or `exports.User`
require('fs').readdirSync(__dirname + '/').forEach(function(file) {
  if (file.match(/\.js$/) !== null && file !== 'index.js') {
    var name = file.replace('.js', '');
    exports[name] = require('./' + file);
  }
});

alors vous pouvez require ce répertoire de n'importe où ailleurs.

une autre option consiste à utiliser le paquet require-dir ce qui vous permettra de faire ce qui suit. Il supporte aussi la récursion.

var requireDir = require('require-dir');
var dir = requireDir('./path/to/dir');

j'ai un dossier /des champs remplis de fichiers avec une seule classe chacun, ex:

fields/Text.js -> Test class
fields/Checkbox.js -> Checkbox class

supprimez ceci dans les champs/index.js pour exporter chaque classe:

var collectExports, fs, path,
  __hasProp = {}.hasOwnProperty;

fs = require('fs');    
path = require('path');

collectExports = function(file) {
  var func, include, _results;

  if (path.extname(file) === '.js' && file !== 'index.js') {
    include = require('./' + file);
    _results = [];
    for (func in include) {
      if (!__hasProp.call(include, func)) continue;
      _results.push(exports[func] = include[func]);
    }
    return _results;
  }
};

fs.readdirSync('./fields/').forEach(collectExports);

cela rend les modules agir plus comme ils le feraient en Python:

var text = new Fields.Text()
var checkbox = new Fields.Checkbox()

une autre option est require-dir-all combinant des caractéristiques des paquets les plus populaires.

le plus populaire require-dir n'a pas d'options pour filtrer les fichiers/DRS et n'a pas la fonction map (voir ci-dessous), mais utilise un petit truc pour trouver le chemin courant du module.

Second par popularity require-all a regexp filtrage et prétraitement, mais manque de chemin relatif, donc vous devez utiliser __dirname (ce a des avantages et des inconvénients comme:

var libs = require('require-all')(__dirname + '/lib');

Mentionné ici require-index est assez minimaliste.

avec map vous pouvez faire certains prétraitement, comme créer des objets et passer des valeurs de configuration (en supposant que les modules ci-dessous exporte des constructeurs):

// Store config for each module in config object properties 
// with property names corresponding to module names 
var config = {
  module1: { value: 'config1' },
  module2: { value: 'config2' }
};

// Require all files in modules subdirectory 
var modules = require('require-dir-all')(
  'modules', // Directory to require 
  { // Options 
    // function to be post-processed over exported object for each require'd module 
    map: function(reqModule) {
      // create new object with corresponding config passed to constructor 
      reqModule.exports = new reqModule.exports( config[reqModule.name] );
    }
  }
);

// Now `modules` object holds not exported constructors, 
// but objects constructed using values provided in `config`.

Un module que j'ai utilisé pour ce cas d'utilisation est exiger .

il exige récursivement tous les fichiers dans un répertoire donné et ses sous-répertoires tant qu'ils ne correspondent pas à la propriété excludeDirs .

il permet également de spécifier un filtre de fichier et comment dériver les clés du hash retourné à partir des noms de fichiers.

je sais que cette question a plus de 5 ans, et les réponses données sont bonnes, mais je voulais quelque chose d'un peu plus puissant pour express, donc j'ai créé le paquet express-map2 pour npm. J'allais l'appeler simplement express-map , cependant le personnes chez yahoo ont déjà un paquet avec ce nom, donc j'ai dû renommer mon paquet.

1. utilisation de base:

app.js (or whatever you call it)

var app = require('express'); // 1. include express

app.set('controllers',__dirname+'/controllers/');// 2. set path to your controllers.

require('express-map2')(app); // 3. patch map() into express

app.map({
    'GET /':'test',
    'GET /foo':'middleware.foo,test',
    'GET /bar':'middleware.bar,test'// seperate your handlers with a comma. 
});

:

//single function
module.exports = function(req,res){

};

//export an object with multiple functions.
module.exports = {

    foo: function(req,res){

    },

    bar: function(req,res){

    }

};

2. utilisation avancée, avec préfixes:

app.map('/api/v1/books',{
    'GET /': 'books.list', // GET /api/v1/books
    'GET /:id': 'books.loadOne', // GET /api/v1/books/5
    'DELETE /:id': 'books.delete', // DELETE /api/v1/books/5
    'PUT /:id': 'books.update', // PUT /api/v1/books/5
    'POST /': 'books.create' // POST /api/v1/books
});

comme vous pouvez le voir, cela économise une tonne de temps et rend le routage de votre application très simple à écrire, à maintenir et à comprendre. il supporte tous les verbes http qu'express supporte, ainsi que la méthode spéciale .all() .

• package npm: https://www.npmjs.com/package/express-map2
• dépôt github: https://github.com/r3wt/express-map

j'utilise les modules de noeud copient-au module pour créer un fichier unique pour exiger tous les fichiers dans notre système basé sur NodeJS.

le code pour notre fichier utilitaire ressemble à ceci:

/**
 * Module dependencies.
 */

var copy = require('copy-to');
copy(require('./module1'))
.and(require('./module2'))
.and(require('./module3'))
.to(module.exports);

Dans tous les fichiers, la plupart des fonctions sont écrites comme des exportations, comme suit:

exports.function1 = function () { // function contents };
exports.function2 = function () { // function contents };
exports.function3 = function () { // function contents };

donc, pour utiliser n'importe quelle fonction d'un fichier, vous appelez simplement:

var utility = require('./utility');

var response = utility.function2(); // or whatever the name of the function is

peut utiliser: https://www.npmjs.com/package/require-file-directory

• Exiger sélectionné les fichiers avec le nom seulement ou tous les fichiers.
• pas besoin de chemin d'abandon.
• Facile à comprendre et à utiliser.

si vous incluez tous les fichiers de *.js dans l'exemple de répertoire ("app/lib/*.js"):

Dans le répertoire app/lib

exemple.js:

module.exports = function (example) { }

exemple-2.js:

module.exports = function (example2) { }

dans l'application de répertoire créer l'index.js

de l'index.js:

module.exports = require('./app/lib');