Différence entre app.use et app.get dans express.js

Question

Je suis assez novice en matière d'express et de node.js, et je n'arrive pas à comprendre la différence entre app.use et app.get. Il semble que vous pouvez utiliser les deux pour envoyer des informations. Par exemple :

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

semble être le même que celui-là :

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

Answer 1

app.use() est destiné à lier intergiciel à votre application. Le site path est un " mont " ou " préfixe "et limite l'intergiciel pour qu'il s'applique seulement aux chemins demandés qui commencer avec elle. Il peut même être utilisé pour intégrer une autre application :

// 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'));

// ...

En spécifiant / comme un " mont " chemin, app.use() répondra à tout chemin qui commence par / qui sont toutes et indépendamment du verbe HTTP utilisé :

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

app.get() d'autre part, fait partie du programme "Express". routage d'applications et est destiné à faire correspondre et à traiter une route spécifique lorsqu'elle est demandée avec l'option GET Verbe HTTP :

• GET /

Et, le routage équivalent pour votre exemple de app.use() serait en fait :

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

---

( Mise à jour : Tentative de mieux démontrer les différences. )

Les méthodes de routage, notamment app.get() sont des méthodes pratiques qui vous aident à aligner plus précisément les réponses aux demandes. Elles permettent également de prendre en charge des fonctionnalités telles que paramètres y next('route') .

Dans chaque app.get() est un appel à app.use() Vous pouvez donc certainement faire tout cela avec app.use() directement. Mais, ce faisant, il faudra souvent réimplémenter (probablement inutilement) diverses quantités de code passe-partout.

Exemples :

• Pour les routes simples et statiques :

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

  vs.

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

• Avec plusieurs gestionnaires pour la même route :

  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);
  
      // ...
    });
  });

• Avec des paramètres :

  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;
    // ...
  });

Remarque : la mise en œuvre de ces fonctionnalités par Express est contenue dans son système de gestion de l'information. Router , Layer et Route .

Answer 2

app.use est la méthode de "niveau inférieur" de Connect, le cadre middleware dont dépend Express.

Voici ma ligne directrice :

• Utilisez app.get si vous voulez exposer une méthode GET.
• Utilisez app.use si vous souhaitez ajouter un intergiciel (un gestionnaire de la requête HTTP avant qu'elle n'arrive aux routes que vous avez configurées dans Express), ou si vous souhaitez rendre vos routes modulaires (par exemple, exposer un ensemble de routes à partir d'un module npm que d'autres applications Web pourraient utiliser).

Answer 3

Tout simplement app.use signifie "Exécuter ceci sur TOUTES les demandes".
app.get signifie "Exécuter ceci sur une requête GET, pour l'URL donnée".

Answer 4

app.get est appelé lorsque le Méthode HTTP est réglé sur GET alors que app.use est appelé indépendamment de la méthode HTTP, et définit donc une couche qui se trouve au-dessus de tous les autres types RESTful auxquels les paquets express vous donnent accès.

Answer 5

Différence entre app.use & app.get :

app.use Il est généralement utilisé pour introduire des intergiciels dans votre application et peut traiter tous les types de demandes HTTP.

app.get Il ne sert qu'à traiter les demandes GET HTTP.

Maintenant, il y a une confusion entre app.use & app.all . Il est certain qu'ils ont une chose en commun, à savoir qu'ils peuvent traiter tous les types de requêtes HTTP. Mais il y a quelques différences qui nous recommandent d'utiliser app.use pour les middlewares et app.all pour la gestion des routes.

1. app.use() Il ne prend qu'un seul callback.
   app.all() Il peut prendre plusieurs rappels.

2. app.use() ne verra que si l'url commence par le chemin spécifié.
   Mais, app.all() correspondra au chemin complet.

Par exemple,

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() à l'intérieur du app.use() appellera soit le middleware suivant, soit n'importe quel gestionnaire de route, mais next() appel à l'intérieur app.all() invoquera le gestionnaire de route suivant ( app.all() , app.get/post/put... etc.) uniquement. S'il y a un middleware après, il sera ignoré. Il est donc conseillé de placer tous les middlewares toujours au-dessus des gestionnaires de route.