Différences entre express.Router et app.get?

Je commence par NodeJS et Express 4, et je suis un peu confus. J'ai lu le site Web Express, mais je ne vois pas quand utiliser un gestionnaire d'itinéraire ou quand l'utiliser express.Router.

Comme je pouvais le voir, si je veux afficher une page ou quelque chose lorsque l'utilisateur frappe /showpar exemple, je devrais utiliser:

var express = require('express')    
var app = express()    
app.get("/show", someFunction)  

Au début, je pensais que c'était vieux (pour Express 3). Est-ce exact ou c'est la voie pour Express 4 aussi?

Si c'est la façon de le faire dans Express 4, à quoi express.Routersert-il?

J'ai lu presque le même exemple que ci-dessus mais en utilisant express.Router:

var express = require('express');
var router = express.Router();
router.get("/show", someFunction)

Alors, quelle est la différence entre les deux exemples?

Lequel dois-je utiliser si je veux simplement faire un site Web de test simple?

app.js

var express = require('express'),
    dogs    = require('./routes/dogs'),
    cats    = require('./routes/cats'),
    birds   = require('./routes/birds');

var app = express();

app.use('/dogs',  dogs);
app.use('/cats',  cats);
app.use('/birds', birds);

app.listen(3000);

dogs.js

var express = require('express');

var router = express.Router();

router.get('/', function(req, res) {
    res.send('GET handler for /dogs route.');
});

router.post('/', function(req, res) {
    res.send('POST handler for /dogs route.');
});

module.exports = router;

Lorsque var app = express()est appelé, un objet d'application est renvoyé. Considérez cela comme l' application principale .

Lorsque var router = express.Router()est appelé, une mini-application légèrement différente est renvoyée. L'idée derrière la mini-application est que chaque itinéraire de votre application peut devenir assez compliqué, et vous auriez avantage à déplacer tout ce code dans un fichier séparé. Le routeur de chaque fichier devient une mini-application , qui a une structure très similaire à l' application principale .

Dans l'exemple ci-dessus, le code de l' itinéraire / dogs a été déplacé dans son propre fichier afin de ne pas encombrer l' application principale . Le code pour / chats et / oiseaux serait structuré de manière similaire dans leurs propres fichiers. En séparant ce code en trois mini-applications , vous pouvez travailler sur la logique de chacune d'elles de manière isolée, et ne pas vous soucier de la façon dont cela affectera les deux autres.

Si vous avez du code (middleware) qui se rapporte aux trois routes, vous pouvez le mettre dans l' application principale , avant les app.use(...)appels. Si vous avez du code (middleware) qui ne concerne qu'une seule de ces routes, vous pouvez le mettre dans le fichier pour cette route uniquement.

Express 4.0 est livré avec le nouveau routeur. Comme mentionné sur le site:

La classe express.Router peut être utilisée pour créer des gestionnaires de routes montables modulaires. Une instance de routeur est un middleware complet et un système de routage; pour cette raison, elle est souvent appelée «mini-application».

Il y a un bon article sur https://scotch.io/tutorials/learn-to-use-the-new-router-in-expressjs-4 qui décrit les différences et ce qui peut être fait avec les routeurs.

Résumer

Avec les routeurs, vous pouvez plus facilement modulariser votre code. Vous pouvez utiliser des routeurs comme:

1. Itinéraires de base: Accueil, À propos
2. Acheminer le middleware pour consigner les demandes sur la console
3. Route avec paramètres
4. Route Middleware for Parameters pour valider des paramètres spécifiques
5. Valide un paramètre transmis à une certaine route

Remarque:

L' app.routerobjet, qui a été supprimé dans Express 4, a fait son retour dans Express 5. Dans la nouvelle version, il s'agit simplement d'une référence au routeur Express de base, contrairement à Express 3, où une application devait le charger explicitement.

app.route('/book')
  .get(function (req, res) {
    res.send('Get a random book')
  })
  .post(function (req, res) {
    res.send('Post a random book')
  })

Comme dans l'exemple ci-dessus, nous pouvons ajouter différentes méthodes de requête HTTP sous une route.

Disons que votre application est peu complexe. Donc, ce que nous faisons d'abord, c'est que nous divisons l'application en plusieurs modules afin que les changements dans un module n'encombrent pas les autres et que vous puissiez continuer à travailler sur des modules individuels, mais à la fin de la journée, vous devez tout intégrer en un depuis que vous construisent une seule application. C'est comme si nous avions une application principale et quelques applications enfants dont le parent est l'application principale. Ainsi, lorsque nous créons l'application parente, nous en créons une en utilisant

var express = require('express');
var parent = express();

Et pour cette application parent, nous devons apporter les applications enfants. Mais comme les applications enfants ne sont pas des applications totalement différentes (puisqu'elles s'exécutent dans le même terme java), express fournit le moyen de le faire au moyen de la fonction de routeur de l'express et c'est ce que nous faisons dans chaque fichier de module enfant et permet d'appeler un de ces modules enfants comme aboutme .

var express = require('express');
var router = express.Router();
/**
** do something here
**/
module.exports = router;

Par module.exports, nous rendons ce module disponible pour les autres utilisateurs et comme nous avons des choses modulaires, nous devons rendre les fichiers de module disponibles pour l'application parent au moyen de la fonction require du nœud, comme tous les autres modules tiers et le fichier parent ressemble quelque chose comme ça.

var express = require('express') 
var parent = express() 
var child = require(./aboutme)

Après avoir mis ce module enfant à la disposition du parent, nous devons indiquer à l'application parent quand utiliser cette application enfant. Disons que lorsqu'un utilisateur atteint le chemin aboutme, nous avons besoin de l'application enfant sur moi pour gérer la demande et nous le faisons en utilisant la méthode d' utilisation d'Express .

parent.use('/aboutme',  aboutme);

et d'un coup le fichier parent ressemble à ceci

var express = require('express');
var parent = express();
var child = require(./aboutme);
/***
**do some stuff here
**/
parent.use('/aboutme',child);

Surtout, ce que le parent peut faire, c'est qu'il peut démarrer un serveur là où l'enfant ne peut pas. J'espère que cela clarifie. Pour plus d'informations, vous pouvez toujours consulter le code source, ce qui prend un certain temps, mais il vous donne beaucoup d'informations. Je vous remercie.

utiliser app.js pour écrire des itinéraires signifie qu'ils sont accessibles à tous les utilisateurs car app.js est chargé au démarrage de l'application. Cependant, le fait de mettre des itinéraires dans des mini-applications express.router () protège et restreint leur accessibilité.

express.Router a de nombreuses options:

• activer la sensibilité à la casse: l' /showitinéraire n'est pas le même que /Show, ce comportement est désactivé par défaut
• mode de routage strict: /show/route vers différent de /show, ce comportement est également désactivé par défaut
• nous pouvons ajouter des middleware / s spécifiques à des routes spécifiques

En un mot, express.Routerpeut faire plus de choses par rapport à app.get(), comme un middleware, en outre, vous pouvez définir un objet routeur supplémentaire avecexpress.Router()