Just pull out the anonymous function and give it a name:

function myRouteHandler(req, res, next) {
  // Do something
}

app.get('/logo/:version/:name', myRouteHandler);
app.head('/logo/:version/:name', myRouteHandler);

Or use a general middleware function and check the req.method:

app.use('/logo/:version/:name', function(req, res, next) {
  if (req.method === 'GET' || req.method === 'HEAD') {
    // Do something
  } else
    next();
});

You may use .route() on your app 's Express object to reduce some of the redundancy in your route definitions. app.route('/image')  Express supports methods that correspond to all HTTP request methods: get, post, and so on. For a full list, see app.METHOD. There is a special routing method, app.all(), used to load middleware functions at a path for all HTTP request methods.

You can use .route() method.

function logo(req, res, next) {
    // Do something
}

app.route('/logo/:version/:name').get(logo).head(logo);

You define routing using methods of the Express app object that correspond to With multiple callback functions, it is important to provide next as an argument  router.METHOD (path, [callback, ] callback) The router.METHOD () methods provide the routing functionality in Express, where METHOD is one of the HTTP methods, such as GET, PUT, POST, and so on, in lowercase. Thus, the actual methods are router.get (), router.post () , router.put (), and so on.

another version:

['get','head'].forEach(function(method){
  app[method]('/logo/:version/:name', function (req, res, next) {
    // Do something
  });
});

originalUrl) next() }, function (req, res, next) { console.log('Request Type:', req.​method) next() }). Route handlers enable you to define multiple routes for a path. app.method(path, handler) This METHOD can be applied to any one of the HTTP verbs – get, set, put, delete. An alternate method also exists, which executes independent of the request type. Path is the route at which the request will run. Handler is a callback function that executes when a matching request type is found on the relevant route.

You can also use the array spread operator if your route pattern is the same for multiple methods.

e.g.

const route = [
    '/logo/:version/:name', 
    function handleRequest(req, res) {
        // handle request
    }
];

app.get(...route);
app.post(...route);

We'll extend the controller methods in our subsequent articles to work wiki.js - Wiki route module. var express = require('express'); var router  ExpressJS - HTTP Methods - The HTTP method is supplied in the request and specifies the operation that the client has requested. The following table lists the most used HTTP methods −

Ensure you only have one routing handler per path. Violation Code Sample. // multiple handler for the same path /foo var express = require('express'); var app =​  Express is a routing and middleware web framework that has minimal functionality of its own: An Express application is essentially a series of middleware function calls. Middleware functions are functions that have access to the request object ( req ), the response object ( res ), and the next middleware function in the application’s request-response cycle.

We can also have multiple different methods at the same route. For example, var express = require('express'); var app = express(); app.get('/hello', function(req,  Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications. APIs With a myriad of HTTP utility methods and middleware at your disposal, creating a robust API is quick and easy.

We have different methods in app object for a different type of request. For GET request use app.get() method: var express = require('express')  Middleware functions are functions that have access to the request object (req), the response object (res), and the next function in the application’s request-response cycle. The next function is a function in the Express router which, when invoked, executes the middleware succeeding the current middleware.

Comments

• I like the second one. Is app.all the same as app.use?
• Not exactly. app.all() adds separate route handlers for every supported HTTP verb, whereas app.use() adds a single route handler that is executed for all requests (that match the optional route pattern).
• Note that because express automatically implements a HEAD handler for you when you specify a GET handler, the app.head() will never run. You need to call app.head() before app.get() so that the HEAD request will be routed to your handler.
• If your HEAD and GET implementation are really the same, there’s no point in manually calling app.head() because express will automatically handle HEAD as long as you specify app.get(). So this version could be simplified to app.get().