Diferencia entre app.use y app.get en express.js

Soy un poco nuevo en express y node.js, y no puedo entender la diferencia entre app.use y app.get. Parece que puede usar ambos para enviar información. Por ejemplo:

app.use('/',function(req, res,next) {
    res.send('Hello');
    next();
});

parece ser lo mismo que esto:

app.get('/', function (req,res) {
   res.send('Hello');
});

app.use()está destinado a vincular middleware a su aplicación. El pathes una ruta de " montaje " o " prefijo " y limita el middleware para que solo se aplique a las rutas solicitadas que comienzan con él. Incluso se puede usar para incrustar otra aplicación:

// subapp.js
var express = require('express');
var app = modules.exports = express();
// ...

// server.js
var express = require('express');
var app = express();

app.use('/subapp', require('./subapp'));

// ...

Al especificar /como una ruta de " montaje ", app.use()responderá a cualquier ruta que comience /, que son todas e independientemente del verbo HTTP utilizado:

• GET /
• PUT /foo
• POST /foo/bar
• etc.

app.get(), por otro lado, es parte del enrutamiento de la aplicación Express y está destinado a hacer coincidir y manejar una ruta específica cuando se solicita con el GETverbo HTTP:

• GET /

Y, el enrutamiento equivalente para su ejemplo de app.use()realidad sería:

app.all(/^\/.*/, function (req, res) {
    res.send('Hello');
});

( Actualización: Intentando demostrar mejor las diferencias ) .

Los métodos de enrutamiento, incluidos app.get(), son métodos convenientes que lo ayudan a alinear las respuestas a las solicitudes con mayor precisión. También agregan soporte para características como parámetros y next('route').

Dentro de cada uno app.get()hay una llamada a app.use(), por lo que ciertamente puede hacer todo esto app.use()directamente. Pero hacerlo requerirá a menudo (probablemente innecesariamente) reimplementar varias cantidades de código repetitivo.

Ejemplos:

• Para rutas simples y estáticas:

  app.get('/', function (req, res) {
    // ...
  });

  vs.

  app.use('/', function (req, res, next) {
    if (req.method !== 'GET' || req.url !== '/')
      return next();
  
    // ...
  });

• Con múltiples controladores para la misma ruta:

  app.get('/', authorize('ADMIN'), function (req, res) {
    // ...
  });

  vs.

  const authorizeAdmin = authorize('ADMIN');
  
  app.use('/', function (req, res, next) {
    if (req.method !== 'GET' || req.url !== '/')
      return next();
  
    authorizeAdmin(req, res, function (err) {
      if (err) return next(err);
  
      // ...
    });
  });

• Con parámetros:

  app.get('/item/:id', function (req, res) {
    let id = req.params.id;
    // ...
  });

  vs.

  const pathToRegExp = require('path-to-regexp');
  
  function prepareParams(matches, pathKeys, previousParams) {
    var params = previousParams || {};
  
    // TODO: support repeating keys...
    matches.slice(1).forEach(function (segment, index) {
      let { name } = pathKeys[index];
      params[name] = segment;
    });
  
    return params;
  }
  
  const itemIdKeys = [];
  const itemIdPattern = pathToRegExp('/item/:id', itemIdKeys);
  
  app.use('/', function (req, res, next) {
    if (req.method !== 'GET') return next();
  
    var urlMatch = itemIdPattern.exec(req.url);
    if (!urlMatch) return next();
  
    if (itemIdKeys && itemIdKeys.length)
      req.params = prepareParams(urlMatch, itemIdKeys, req.params);
  
    let id = req.params.id;
    // ...
  });

Nota: la aplicación de estas características Express están contenidos en su Router, LayeryRoute .

app.use es el método de "nivel inferior" de Connect, el marco de middleware del que Express depende.

Aquí está mi guía:

• Úselo app.getsi desea exponer un método GET.
• Úselo app.usesi desea agregar algún middleware (un controlador para la solicitud HTTP antes de que llegue a las rutas que ha configurado en Express), o si desea que sus rutas sean modulares (por ejemplo, exponga un conjunto de rutas desde un módulo npm que otras aplicaciones web podrían usar).

Simplemente app.use significa "Ejecutar esto en TODAS las solicitudes"
app.get significa "Ejecutar esto en una solicitud GET, para la URL dada"

app.getse llama cuando el método HTTP se establece en GET, mientras que app.usese llama independientemente del método HTTP y, por lo tanto, define una capa que está por encima de todos los otros tipos RESTful a los que los paquetes express le dan acceso.

Diferencia entre app.use& app.get:

app.use → Generalmente se usa para introducir middlewares en su aplicación y puede manejar todo tipo de solicitudes HTTP.

app.get → Es solo para manejar solicitudes GET HTTP.

Ahora, hay una confusión entre app.use& app.all. Sin duda, hay una cosa común en ellos, que ambos pueden manejar todo tipo de solicitudes HTTP. Pero hay algunas diferencias que nos recomiendan usar app.use para middlewares y app.all para el manejo de rutas.

1. app.use()→ Solo se necesita una devolución de llamada.
   app.all()→ Puede tomar múltiples devoluciones de llamada.

2. app.use()solo verá si la url comienza con la ruta especificada.
   Pero, app.all()coincidirá con la ruta completa.

Por ejemplo,

app.use( "/book" , middleware);
// will match /book
// will match /book/author
// will match /book/subject

app.all( "/book" , handler);
// will match /book
// won't match /book/author   
// won't match /book/subject    

app.all( "/book/*" , handler);
// won't match /book        
// will match /book/author
// will match /book/subject

3. next()llamar al interior app.use()llamará al siguiente middleware o a cualquier controlador de ruta, pero next()llamar al interior app.all()invocará únicamente al siguiente controlador de ruta ( app.all(), app.get/post/put...etc.). Si hay algún middleware después, se omitirá. Por lo tanto, es recomendable colocar todos los middlewares siempre por encima de los controladores de ruta.

Además de las explicaciones anteriores, lo que experimento:

app.use('/book', handler);  

coincidirá con todas las solicitudes que comiencen con '/ book' como URL. entonces también coincide con '/ book / 1' o '/ book / 2'

app.get('/book')  

solo coincide con la solicitud GET con la coincidencia exacta . No manejará URL como '/ book / 1' o '/ book / 2'

Entonces, si desea un controlador global que maneje todas sus rutas, entonces esa app.use('/')es la opción. app.get('/')manejará solo la URL raíz.