web-dev-qa-db-fra.com

node.js nécessite-t-il tous les fichiers d'un dossier?

Comment puis-je exiger tous les fichiers d'un dossier dans node.js?

besoin de quelque chose comme:

files.forEach(function (v,k){
  // require routes
  require('./routes/'+v);
}};
javascriptnode.jsdirectoryrequire
302
Harry

Lorsque require reçoit le chemin d'un dossier, il cherche un fichier index.js dans ce dossier; s'il en existe un, il l'utilise, et s'il n'y en a pas, il échoue.

Il serait probablement plus judicieux (si vous avez le contrôle sur le dossier) de créer un fichier index.js, puis d’affecter tous les "modules" et de simplement l'exiger.

votrefichier.js

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

index.js

exports.something = require("./routes/something.js");
exports.others = require("./routes/others.js");

Si vous ne connaissez pas les noms de fichiers, vous devriez écrire une sorte de chargeur.

Exemple de travail d'un chargeur:

var normalizedPath = require("path").join(__dirname, "routes");

require("fs").readdirSync(normalizedPath).forEach(function(file) {
  require("./routes/" + file);
});

// Continue application logic here
485
tbranyen

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 ) );
});
150
Diogo Cardoso

Sur la base de la solution de @ tbranyen, je crée un fichier index.js qui charge des javascripts arbitraires dans le dossier en cours dans le cadre de 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);
  }
});

Ensuite, vous pouvez require ce répertoire de n’importe où ailleurs.

70
Greg Wang

Une autre option consiste à utiliser le paquetage require-dir qui vous permet de faire ce qui suit. Il prend également en charge la récursivité.

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

J'ai un dossier/champs plein de fichiers avec une seule classe chacun, ex:

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

Déposez ceci dans fields/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 fait que les modules agissent plus comme ils le feraient en Python:

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

Une autre option est require-dir-all combinant les fonctionnalités des packages les plus populaires.

Le plus populaire require-dir n'a pas d'options pour filtrer les fichiers/répertoires et n'a pas de fonction map (voir ci-dessous), mais utilise une astuce pour trouver le chemin actuel du module.

Second par popularité require-all possède un filtrage et un prétraitement d'expressions rationnelles, mais il lui manque un chemin relatif. Vous devez donc utiliser __dirname (qui 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 effectuer certains prétraitements, comme créer des objets et transmettre des valeurs de configuration (en supposant que les modules situés sous les constructeurs d'exportations):

// 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`.
5
alykoshin

Un module que j'ai utilisé pour ce cas d'utilisation exact est require-all .

Il requiert de manière récursive tous les fichiers d’un répertoire donné et de ses sous-répertoires s’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 hachage renvoyé à partir des noms de fichiers.

3
Thorsten Lorenz

Je sais que cette question a 5 ans ou plus, et les réponses données sont bonnes, mais je voulais quelque chose d'un peu plus puissant pour l'express, j'ai donc créé le paquetage express-map2 pour npm. J'allais simplement le nommer express-map, cependant, les personnes de Yahoo ont déjà un paquet portant ce nom. J'ai donc 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. 
});

utilisation du contrôleur:

//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 constater, cela permet de gagner beaucoup de temps et d’écrire, de maintenir et de comprendre le routage de votre application. il supporte tous les verbes http exprimés, ainsi que la méthode spéciale .all().

2
r3wt

J'utilise module de copie des modules de nœud pour créer un seul fichier nécessitant tous les fichiers de notre système basé sur NodeJS.

Le code pour notre fichier d’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 sous forme d'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, il suffit d'appeler:

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

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

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

  • Exiger des fichiers sélectionnés avec un nom uniquement ou tous les fichiers.
  • Pas besoin de chemin d'absoulé.
  • Facile à comprendre et à utiliser.
1
Mayank Soni