Diferenças entre express.Router e app.get?

Estou começando com NodeJS e Express 4, e estou um pouco confuso. Eu estava lendo o site do Express, mas não consigo ver quando usar um manipulador de rota ou quando usar express.Router.

Como pude ver, se eu quiser mostrar uma página ou algo quando o usuário acessar, /showpor exemplo, devo usar:

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

No começo, pensei que isso era antigo (para o Express 3). Está certo ou este também é o caminho para o Express 4?

Se essa é a maneira de fazer isso no Express 4, para que express.Routerserve?

Eu li quase o mesmo exemplo acima, mas usando express.Router:

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

Então, qual é a diferença entre os dois exemplos?

Qual deles devo usar se quiser apenas fazer um site de teste simples?

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()é chamado, um objeto de aplicativo é retornado. Pense nisso como o aplicativo principal .

Quando var router = express.Router()é chamado, um mini aplicativo ligeiramente diferente é retornado. A idéia por trás do mini aplicativo é que cada rota no seu aplicativo possa se tornar bastante complicada, e você se beneficiaria de mover todo esse código para um arquivo separado. O roteador de cada arquivo se torna um miniaplicativo , com uma estrutura muito semelhante à do aplicativo principal .

No exemplo acima, o código para a rota / dogs foi movido para seu próprio arquivo para não desorganizar o aplicativo principal . O código para / gatos e / pássaros seria estruturado de maneira semelhante em seus próprios arquivos. Ao separar esse código em três mini aplicativos , você pode trabalhar na lógica de cada um isoladamente e não se preocupar com como isso afetará os outros dois.

Se você possui um código (middleware) que pertence a todas as três rotas, é possível colocá-lo no aplicativo principal antes das app.use(...)chamadas. Se você tiver um código (middleware) referente a apenas uma dessas rotas, poderá colocá-lo no arquivo apenas para essa rota.

O Express 4.0 vem com o novo roteador. Conforme mencionado no site:

A classe express.Router pode ser usada para criar manipuladores de rota montáveis ​​modulares. Uma instância do roteador é um sistema completo de middleware e roteamento; por esse motivo, é frequentemente chamado de "miniaplicativo".

Há um bom artigo em https://scotch.io/tutorials/learn-to-use-the-new-router-in-expressjs-4 que descreve as diferenças e o que pode ser feito com os roteadores.

Resumir

Com os roteadores, você pode modular seu código mais facilmente. Você pode usar roteadores como:

1. Rotas básicas: Início, Sobre
2. Roteie o Middleware para registrar solicitações no console
3. Rota com parâmetros
4. Roteie o Middleware for Parameters para validar parâmetros específicos
5. Valida um parâmetro passado para uma determinada rota

Nota:

O app.routerobjeto, que foi removido no Express 4, voltou ao Express 5. Na nova versão, é apenas uma referência ao roteador Express base, ao contrário do Express 3, onde um aplicativo precisava carregá-lo explicitamente.

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

Como no exemplo acima, podemos adicionar diferentes métodos de solicitação HTTP em uma rota.

Digamos que seu aplicativo seja pouco complexo. Então, o que fazemos primeiro é dividir o aplicativo em vários módulos para que as alterações em um módulo não atrapalhem as demais e você possa continuar trabalhando em módulos individuais, mas no final do dia você precisa integrar tudo em um desde que você estão construindo um único aplicativo. É como se tivéssemos um aplicativo principal e poucos aplicativos filhos cujo pai é o aplicativo principal. Então, quando criamos o aplicativo pai, criamos um usando

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

E para esse aplicativo pai, precisamos incluir os aplicativos filhos. Mas como os aplicativos filhos não são totalmente diferentes (pois são executados no mesmo termo context-java), o express fornece a maneira de fazer isso por meio da função Router do Expresse e é isso que fazemos no arquivo de cada módulo filho e vamos chamar um módulo filho como aboutme .

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

Por module.exports , estamos disponibilizando este módulo para consumo por outros e, como modulamos as coisas, precisamos disponibilizar os arquivos do módulo para o aplicativo pai por meio da função de exigência do nó, como qualquer outro módulo de terceiros e o arquivo pai parece algo assim.

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

depois de disponibilizar esse módulo filho para o pai, precisamos informar ao aplicativo pai quando usar esse aplicativo filho. Digamos que quando um usuário acessa o caminho sobre mim, precisamos do aplicativo filho sobre mim para lidar com a solicitação e fazemos isso usando o método de uso do Expresse .

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

e de uma só vez o arquivo pai se parece com isso

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

Acima de tudo, o que os pais podem fazer é iniciar um servidor onde a criança não pode. Espero que isso esclareça. Para obter mais informações, você sempre pode olhar para o código-fonte que leva algum tempo, mas fornece muitas informações. Obrigado.

usar o app.js para escrever rotas significa que eles estão acessíveis a todos os usuários, pois o app.js é carregado no início do aplicativo. No entanto, colocar rotas nos miniaplicativos express.router () protege e restringe sua acessibilidade.

express.Router tem muitas opções:

• ativar a distinção entre maiúsculas e minúsculas: a /showrota não deve ser a mesma que /Show, esse comportamento é desativado por padrão
• modo de roteamento estrito: /show/rota para não ser igual a /show, esse comportamento também é desativado por padrão
• podemos adicionar middleware / s específicos a rotas específicas

Em uma palavra, você express.Routerpode fazer mais coisas quando comparado a app.get(), como middleware, além disso, você pode definir mais um objeto roteador comexpress.Router()