Differenze tra express.Router e app.get?

Sto iniziando con NodeJS ed Express 4 e sono un po 'confuso. Ho letto il sito Web Express, ma non riesco a vedere quando utilizzare un gestore di percorsi o quando utilizzare express.Router.

Come ho potuto vedere, se voglio mostrare una pagina o qualcosa quando l'utente colpisce /showad esempio, dovrei usare:

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

All'inizio, ho pensato che fosse vecchio (per Express 3). È giusto o è così anche per Express 4?

Se questo è il modo di farlo in Express 4, a cosa express.Routerserve?

Ho letto quasi lo stesso esempio di cui sopra ma usando express.Router:

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

Quindi, qual è la differenza tra entrambi gli esempi?

Quale dovrei usare se voglio solo fare un semplice sito Web di test?

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;

Quando var app = express()viene chiamato, viene restituito un oggetto app. Pensa a questa come l' app principale .

Quando var router = express.Router()viene chiamato, viene restituita una mini app leggermente diversa . L'idea alla base della mini app è che ogni percorso nella tua app può diventare piuttosto complicato e trarrai vantaggio spostando tutto quel codice in un file separato. Il router di ogni file diventa una mini app , che ha una struttura molto simile all'app principale .

Nell'esempio sopra, il codice per il percorso / dogs è stato spostato nel suo file in modo da non ingombrare l' app principale . Il codice per / cats e / birds sarebbe strutturato in modo simile nei propri file. Separando questo codice in tre mini app , puoi lavorare sulla logica per ognuna in modo isolato e non preoccuparti di come influenzerà le altre due.

Se si dispone di codice (middleware) relativo a tutti e tre i percorsi, è possibile inserirlo nell'app principale prima delle app.use(...)chiamate. Se si dispone di codice (middleware) che riguarda solo una di quelle route, è possibile inserirlo nel file solo per quella route.

Express 4.0 viene fornito con il nuovo router. Come accennato sul sito:

La classe express.Router può essere utilizzata per creare gestori di route montabili modulari. Un'istanza del router è un middleware completo e un sistema di routing; per questo motivo viene spesso definita "mini-app".

C'è un buon articolo su https://scotch.io/tutorials/learn-to-use-the-new-router-in-expressjs-4 che descrive le differenze e cosa si può fare con i router.

Riassumere

Con i router puoi modulare il tuo codice più facilmente. Puoi usare i router come:

1. Percorsi di base: Home, Informazioni
2. Instradare il middleware per registrare le richieste alla console
3. Rotta con parametri
4. Instradare il middleware per i parametri per convalidare parametri specifici
5. Convalida un parametro passato a una determinata route

Nota:

L' app.routeroggetto, che è stato rimosso in Express 4, è tornato in Express 5. Nella nuova versione, è solo un riferimento al router Express di base, a differenza di Express 3, in cui un'app ha dovuto caricarlo esplicitamente.

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

Come nell'esempio precedente, possiamo aggiungere un diverso metodo di richiesta HTTP sotto una route.

Supponiamo che la tua applicazione sia poco complessa. Quindi, ciò che facciamo prima è dividere l'applicazione in più moduli in modo che le modifiche in un modulo non ingombrino gli altri e tu possa continuare a lavorare su singoli moduli, ma alla fine devi integrare tutto in uno poiché stanno costruendo una singola applicazione. È come se avessimo un'applicazione principale e poche applicazioni figlio il cui genitore è l'applicazione principale. Quindi quando creiamo l'applicazione principale ne creiamo una usando

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

E a questa domanda principale dobbiamo inserire le applicazioni secondarie. Ma poiché le applicazioni figlio non sono applicazioni totalmente diverse (poiché funzionano nello stesso termine contesto-java), express fornisce il modo di farlo tramite la funzione Router di Expresse e questo è ciò che facciamo nel file di ciascun modulo figlio e consente di chiamare uno di questi moduli figlio come aboutme .

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

Con module.exports stiamo rendendo questo modulo disponibile per altri da consumare e poiché abbiamo cose modularizzate abbiamo bisogno di rendere i file del modulo disponibili per l'applicazione genitore mediante la funzione di richiesta del nodo proprio come qualsiasi altro modulo di terze parti e l'aspetto del file genitore qualcosa come questo.

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

dopo aver reso questo modulo figlio disponibile per il genitore, dobbiamo dire all'applicazione genitore quando usare questa applicazione figlio. Diciamo che quando un utente colpisce il percorso su di me abbiamo bisogno dell'applicazione figlio su di me per gestire la richiesta e lo facciamo usando il metodo di utilizzo di Expresse .

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

e in un colpo solo il file principale appare così

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

Soprattutto ciò che il genitore può fare è che può avviare un server dove il figlio non può. Spero che questo chiarisca. Per ulteriori informazioni puoi sempre guardare il codice sorgente che richiede del tempo ma ti dà molte informazioni. Grazie.

l'utilizzo di app.js per scrivere i percorsi significa che sono accessibili a tutti gli utenti quando app.js viene caricato all'avvio dell'applicazione. Tuttavia, l'inserimento di percorsi nelle mini app express.router () protegge e limita la loro accessibilità.

express.Router ha molte opzioni:

• abilita la distinzione tra maiuscole e minuscole: la /showroute non è la stessa /Show, questo comportamento è disabilitato per impostazione predefinita
• modalità di routing rigorosa: il /show/percorso non è lo stesso di /show, anche questo comportamento è disabilitato per impostazione predefinita
• possiamo aggiungere middleware / i specifici a percorsi specifici

In una parola, express.Routerpuoi fare più cose se confrontato con app.get(), come middleware, inoltre, puoi definire un altro oggetto router conexpress.Router()