Comment avez-vous modulariser Node.JS w/Express

Je suis en train de modulariser mon node.js application (à l'aide d'exprimer cadre). L'ennui que j'éprouve lors de la définition de mes itinéraires.

Je ne suis plus en mesure d'extraire les données que j'envoie à la poste. (req.le corps n'est pas défini). Cela fonctionne bien si c'est tout dans le même fichier. Ce que je fais mal ici, et quelle est la meilleure façon de modulariser le code dans node.js?

Mon app.js

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

Mon route.js

exports.setRoutes = function(app){

  app.post('/ask', function(req, res, next){
    time = new Date();

    var newQuestion = {title: req.body.title, time: time.getTime(), vote:1};
    app.questions.push(newQuestion);
    res.render('index', {
      locals: {
        title: 'Questions',
        questions: app.questions
      }
    });
});

OriginalL'auteur Kiran Ryali | 2011-02-20

30

Une meilleure approche:

Créer un routes.js fichier qui contient:
```
var index = require('./controllers/index');

module.exports = function(app) {
  app.all('/', index.index);
}
```
Puis, à partir de l'intérieur de votre server.js (ou cependant vous avez commencé votre serveur), vous auriez besoin en tant que tel:
```
require('./routes')(app);
```
De cette façon, vous ne créent pas des variables globales qui apportent avec eux toute une série de questions (testabilité, collision, etc.)

C'est la meilleure façon de le faire. J'ai commencé à le faire que dans mes projets déjà, merci à vous!
De cette façon, fonctionne très bien, j'ai trouvé un exemple plus complet: stackoverflow.com/questions/6059246/...
comment accéder à l'app à partir de l'index du contrôleur?
Je n'ai pas, vous ne devriez pas avoir besoin de. Ce que vous voulez accomplir dans la voie qui doit le serveur de l'objet? La fonction index recevrez req, res, et à côté des arguments qui devrait être tout ce dont vous avez besoin.
pourquoi app.tous les( ) à la place de l'app.get( )?

OriginalL'auteur ctide
3

Je réalise que quelqu'un a déjà répondu, mais voici ce que je fais de toute façon.

app.js :
```
fs.readdir('./routes', function(err, files){
    files.forEach(function(fn) {
        if(!/\.js$/.test(fn)) return;
        require('./routes/' + fn)(app);
    });
});
```
./routes/index.js :
```
module.exports = function(app) {
        var data_dir = app.get('data-dir');

    app.get('/', function(req, res){
        res.render('index', {title: 'yay title'}
    });
}
```
Peut-être que quelqu'un va trouver cette approche utile.

Prendre soin que requireest une fonction synchrone lorsque fs.readdir est asynchrone. Donc, chaque fois que l'ordre d'exécution de vos modules sera différent lorsque vous exécutez votre application. Mais vous pouvez sort fichiers de tableau avant de forEach pour le rendre déterminé. Vous pouvez aussi asyncly précharger les fichiers de require.cache pour le rendre plus rapide pour commencer si votre application a besoin de beaucoup de redémarrage.

OriginalL'auteur OneOfOne
2

Mon problème est que j'ai été déclarer application dans le mauvais sens. Au lieu de var app = module.exports = express.createServer();, il aurait juste été app = express.createServer();

Et puis tout ce que je devais faire dans mon app.js a require('./routes.js');. Maintenant, le fichier de routes a accès à l'application variable et maintenant je peux simplement déclarer itinéraires normalement dans le fichier de routes.

(routes.js)
```
app.get('/test', function(req, res){
    console.log("Testing getter");
    res.writeHead('200');
    res.end("Hello World");
}); 
```
Cette pratique est mauvaise parce que vous êtes à l'instanciation d'application comme une variable globale. Vous êtes mieux de la passer dans la routes.js fichier (exportation d'une fonction init, par exemple, dans le routes.js qui accepte une application variable).
Il serait bon de savoir que pourquoi cette "mauvaise pratique" est la configuration par défaut fournie par une installation rapide 🙁 Évidemment globales sont moins grands, mais c'est le modèle nous les noobs sont fournis.

OriginalL'auteur Kiran Ryali
0

mondial "app" pour moi (en général). Si vous connaissez l'application ne sera pas require()d, et si vous n'êtes pas maladroit, c'est beaucoup plus facile de travailler avec

Merci pour la réponse! Ce genre de choses doit être évitée lors de l'utilisation de la mondial "app"?
re-affectation 😀 donc, si votre application tourne autour des "applications" comme une ressource, et vous êtes susceptible d'utiliser des "var app =" beaucoup j'ai vraiment ne dirais pas ça haha

OriginalL'auteur tjholowaychuk
0

exemple dans app.js
```
var users = require('./lib/users'); //this is your own module
app.use(users);
```
alors, vous en votre lib/dossier utilisateurs, de créer des fichiers ( index.js,utilisateur.ejs,etc). utilisation index.js par défaut le module de chargement
//index.js
var express = require('express');
var app = module.les exportations = express();
```
app.set('views',__dirname);
app.set('view engine','ejs');
app.get('/users',function(req,res){
    //do stuffs here
});
```
J'ai fait un exemple de Modulaire nœud.jes + Bootstrap ici : Nodemonkey ou d'un tuteur ici ici

OriginalL'auteur ngakak

Vous devez vous connecter pour publier un commentaire.