express()

express()Se utiliza para crear una aplicación Express.express()El método esexpressMétodo de nivel superior exportado por el módulo.

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

Methods

express.static(root, [options])

express.staticEs el único middleware integrado en Express. Está desarrollado basándose en el móduloserver-staticy se encarga de alojar recursos estáticos dentro de la aplicación Express. ParámetrorootEs el directorio raíz donde se encuentran los recursos estáticos. ParámetrooptionsEs opcional y admite las siguientes propiedades:

Si deseas obtener más detalles sobre el uso de middleware, puedes consultarServing static files in Express。

Application()

appEl objeto se usa generalmente para representar la aplicación Express. Se crea llamando al método de nivel superiorexpress()exportado por el módulo Express:

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

app.get('/', function(req, res) {
    res.send('hello world!');
});

app.listen(3000);

El objeto app tiene los siguientes métodos:

• Enruta solicitudes HTTP; para más detalles, consultaapp.METHODyapp.paramestos dos ejemplos.
• Configura middleware; para más detalles, consultaapp.route。
• Renderiza vistas HTML; para más detalles, consultaapp.render。
• Registra el motor de plantillas; para más detalles, consultaapp.engine。

También tiene algunas propiedades de configuración que pueden cambiar el comportamiento de la aplicación. Para obtener más información, consultaApplication settings。

Properties

app.locals

El objeto app.locals es un objeto JavaScript cuyas propiedades son variables locales de la aplicación.

app.locals.title
// => 'My App'
app.locals.email
// => '[email protected]'

Una vez establecidas,app.localslos valores de las propiedades de app.locals permanecen durante todo el ciclo de vida de la aplicación, a diferencia deres.locals, que solo es válido durante el ciclo de vida de la solicitud.

En la aplicación, puedes usar estas variables locales al renderizar plantillas. Son muy útiles, ya que proporcionan métodos útiles y datos a nivel deapppara las plantillas. A través dereq.app.locals(consultareq.app), los Locals se pueden usar en middleware.

app.locals.title = 'My App';
app.locals.strftime = require('strftime');
app.locals.email = '[email protected]';

app.mountpath

app.mountpathLa propiedad es el patrón de ruta donde se monta el subprograma.

Un subprograma es una instancia deexpressque se puede utilizar como manejador de rutas para procesar solicitudes.

var express = require('express');
var app = express(); // the main app
var admin = express(); // the sub app
admin.get('/', function(req, res) {
    console.log(admin.mountpath); // /admin
    res.send('Admin Homepage');
});
app.use('/admin', admin); // mount the sub app

Es similar a la propiedadreq.baseUrl) del objeto req, excepto que req.baseUrl es la ruta URL coincidente, no el patrón coincidente. Si un subprograma está montado en múltiples patrones de ruta, app.mountpath es una lista de los elementos de patrones de montaje, como se muestra en el siguiente ejemplo.

var admin = express();

admin.get('/', function (req, res) {
  console.log(admin.mountpath); // [ '/adm*n', '/manager' ]
  res.send('Admin Homepage');
});

var secret = express();
secret.get('/', function (req, res) {
  console.log(secret.mountpath); // /secr*t
  res.send('Admin Secret');
});

admin.use('/secr*t', secret); // load the 'secret' router on '/secr*t', on the 'admin' sub app
app.use(['/adm*n', '/manager'], admin); // load the 'admin' router on '/adm*n' and '/manager', on the parent app

Events

app.on('mount', callback(parent))

Cuando el subprograma se monta en el programa principal, se emite el evento mount. El objeto del programa principal se pasa como parámetro a la función de devolución de llamada.

var admin = express();
admin.on('mount', function(parent) {
    console.log('Admin Mounted');
    console.log(parent); // refers to the parent app
});
admin.get('/', function(req, res) {
    res.send('Admin Homepage');
});
app.use('/admin', admin);

Methods

app.all(path, callback[, callback ...]

app.allEl método es similar al método estándarapp.METHOD(), excepto que coincide con todos los verbos HTTP. Es muy útil para asignar un manejo lógico global a un prefijo especial, o para una coincidencia incondicional. Por ejemplo, si colocas el siguiente contenido antes de todas las demás definiciones de rutas, se requiere que todas las rutas desde este punto necesiten autenticación y carguen automáticamente un usuario. Recuerda que estas funciones de devolución de llamada no son necesariamente el punto final:loadUserDespués de completar una tarea, se puede llamar al métodonext()para continuar coincidiendo con las rutas posteriores.

app.all('*', requireAuthentication, loadUser);

O esta forma equivalente:

app.all('*', requireAuthentication);
app.all('*', loadUser);

Otro ejemplo es un método de lista blanca global. Este ejemplo es muy similar al anterior, sin embargo, solo restringe las rutas que comienzan con/api.

app.all('/api/*', requireAuthentication);

app.delete(path, callback[, callback ...])

RutaHTTP DELETESolicita a una ruta especial con métodos de devolución de llamada especiales. Para obtener más información, consultarouting guide. Puedes proporcionar múltiples funciones de devolución de llamada, que se comportan igual que el middleware, excepto que estas devoluciones de llamada pueden omitir el resto de las devoluciones de llamada de la ruta llamando anext('router'). Puedes usar este mecanismo para establecer algunas condiciones previas para una ruta. Si no se pueden cumplir las condiciones de procesamiento de la ruta actual, puedes pasar el control a las rutas posteriores.

app.delete('/', function(req, res) {
    res.send('DELETE request to homepage');
});

app.disable(name)

Establece el valor de la configuración llamadanamede tipo booleano enfalse, dondenameSíapp settings tablees una de las propiedades. Llamar aapp.set('foo', false)es equivalente a llamar aapp.disable('foo'). Por ejemplo:

app.disable('trust proxy');
app.get('trust proxy');
// => false

app.disabled(name)

Devuelvetruesi el valor de configuración de tipo booleanonameestá deshabilitado comofalse, dondenameSíapp settings tablees una de las propiedades.

app.disabled('trust proxy');
// => true
app.enable('trust proxy');
app.disabled('trust proxy');
// => false

app.enable(name)

Establece el valor de configuración de tipo booleanonameParatrue, dondenameSíapp settings tablees una de las propiedades. Llamar aapp.set('foo', true)es equivalente a llamar aapp.enable('foo').

app.enable('trust proxy');
app.get('trust proxy');
// => true

app.enabled(name)

Devuelvetruesi el valor de configuración de tipo booleanonameestá habilitado comotrue, dondenameSíapp settings tablees una de las propiedades.

app.enabled('trust proxy');
// => false
app.enable('trust proxy');
app.enabled('trust proxy');
// => true

app.engine(ext, callback)

Registra la función de devolución de llamada del motor dado, usada para renderizar y procesar archivos con extensión ext. De forma predeterminada, Express necesita usarrequire()para cargar motores basados en la extensión de archivo. Por ejemplo, si intentas renderizar un archivofoo.jade, Express llama internamente al siguiente contenido y almacena en caché el resultadorequire()para llamadas posteriores, con el fin de acelerar el rendimiento.

app.engine('jade', require('jade').__express);

Usa el siguiente método para plantillas que no proporcionan un método.__expresslisto para usar, o si deseas usar una extensión de motor de plantillas diferente. Por ejemplo, usando el motor de plantillas EJS para renderizar archivos.html:

app.engine('html', require('ejs').renderFile);

En este ejemplo, EJS proporciona un método.renderFileque cumple con las reglas de firma especificadas por Express:(path, options, callback), sin embargo, recuerda que internamente es solo un alias deejs.__express, por lo que puedes usar directamente la extensión.ejssin hacer nada. Algunos motores de plantillas no siguen esta especificación. La bibliotecaconsolidate.jsasigna los motores de plantillas de la siguiente manera, para que puedan trabajar sin problemas con Express.

var engines = require('consolidate');
app.engine('haml', engines.haml);
app.engine('html', engines.hogan);

app.get(name)

Obtiene el valor de la configuración de la aplicación llamadaname, dondenameSíapp settings tablees una de las propiedades. Como sigue:

app.get('title');
// => undefined
app.set('title', 'My Site');
app.get('title');
// => 'My Site'

app.get(path, callback [, callback ...])

RutaHTTP GETSolicita a una ruta especial con devoluciones de llamada especiales. Para obtener más información, consultarouting guide. Puedes proporcionar múltiples funciones de devolución de llamada, que se comportan igual que el middleware, excepto que estas devoluciones de llamada pueden omitir el resto de las devoluciones de llamada de la ruta llamando anext('router'). Puedes usar este mecanismo para establecer algunas condiciones previas para una ruta. Si la solicitud no cumple las condiciones de procesamiento de la ruta actual, entonces pasa el control a las rutas posteriores.

app.get('/', function(req, res) {
    res.send('GET request to homepage');
});

app.listen(port, [hostname], [backlog], [callback])

Vincula el programa al puerto especificado en el host y número de puerto especificados. Este método es igual queNodeenhttp.Server.listen().

var express = require('express');
var app = express();
app.listen(3000);

El objetoexpress()obtenido al llamar aappes en realidad unFunctionde JavaScript, diseñado para ser usado como una devolución de llamada pasada aNode HTTP serverspara manejar solicitudes. De esta manera, se puede proporcionar fácilmente versiones http y https basadas en el mismo código, por lo que app no hereda de estos (es solo una devolución de llamada simple).

var express = require('express');
var https = require('https');
var http = require('http');
http.createServer(app).listen(80);
https.createServer(options, app).listen(443);

El método app.listen() es un método conveniente como se muestra a continuación (solo para el protocolo HTTP):

app.listen = function() {
    var server = http.createServer(this);
    return server.listen.apply(server, arguments);
};

app.METHOD(path, callback [, callback ...])

Enruta una solicitud HTTP,METHODes el método HTTP de esta solicitud, por ejemploGET，PUT，POST, etc. Ten en cuenta que está en minúsculas. Por lo tanto, los métodos reales sonapp.get()，app.post()，app.put(), etc. A continuación hay una tabla completa de métodos.

Para obtener más información, consultarouting guide. Express admite los siguientes métodos de enrutamiento, correspondientes a los métodos HTTP del mismo nombre:

Si el uso de los métodos anteriores produce nombres de variables de JavaScript no válidos, puedes usar la notación de corchetes, por ejemplo,app['m-search']('/', function ...

Puedes proporcionar múltiples funciones de devolución de llamada, que se comportan igual que el middleware, excepto que estas devoluciones de llamada pueden omitir el resto de las devoluciones de llamada de la ruta llamando anext('router'). Puedes usar este mecanismo para establecer algunas condiciones previas para una ruta. Si la solicitud no cumple las condiciones de procesamiento de la ruta actual, entonces pasa el control a las rutas posteriores.

Este documento de API explica el método HTTPapp.get()，app.post，app.put()，app.delete(), que se usa con más frecuencia, como un elemento separado. Sin embargo, los otros métodos enumerados anteriormente funcionan exactamente de la misma manera.

app.all()Es un método de enrutamiento especial que no pertenece a los métodos especificados en el protocolo HTTP. Carga middleware para una ruta, que es válido para todos los métodos de solicitud.

app.all('/secret', function (req, res) {
    console.log('Accessing the secret section...');
    next(); // pass control to the next handler
});

app.param([name], callback)

Agrega disparadores de devolución de llamada a los parámetros de ruta, dondenamees el nombre del parámetro o un array de parámetros,functiones el método de devolución de llamada. Los parámetros del método de devolución de llamada son, en orden:objeto de solicitud，objeto de respuesta，siguiente middleware，valor del parámetroynombre del parámetro. Sinamees un array, los disparadores de devolución de llamada se registran en el orden en que se declaran los parámetros en el array. Además, para los parámetros que no sean el último, en sus devoluciones de llamada se llama anext()para invocar la devolución de llamada del siguiente parámetro declarado. Para el último parámetro, se llama en la devolución de llamadanext()llamará al siguiente middleware ubicado en la ruta actualmente procesada, sinamees solo unstringentonces es lo mismo (es decir, si solo hay un parámetro, entonces es el último parámetro, igual que el último parámetro del array).:useraparece en la ruta, puedes mapear la lógica de carga del usuario para proporcionar automáticamentereq.usera esta ruta, o validar los parámetros de entrada.

app.param('user', function(req, res, next, id) {
    User.find(id, function(error, user) {
        if (err) {
            next(err);
        }
        else if (user){
            req.user = user;
        } else {
            next(new Error('failed to load user'));
        }
    });
});

ParaParamcon respecto a las rutas definidas por las devoluciones de llamada, son locales. No son heredadas por la app montada ni por las rutas. Por lo tanto, las devoluciones de llamada definidasappenParamsolo tienen efecto cuando están enapplas rutas que tienen este parámetro de ruta.

En rutas que definenparamel parámetro,paramlas devoluciones de llamada se invocan primero, y se llaman una y solo una vez en un ciclo de solicitud-respuesta, incluso si coinciden varias rutas, como en el siguiente ejemplo:

app.param('id', function(req, res, next, id) {
    console.log('CALLED ONLY ONCE');
    next();
});
app.get('/user/:id', function(req, res, next) {
    console.log('although this matches');
    next();
});
app.get('/user/:id', function(req, res) {
    console.log('and this mathces too');
    res.end();
});

Cuando se hace GET /user/42, se obtiene el siguiente resultado:

CALLED ONLY ONCE
although this matches
and this matches too

app.param(['id', 'page'], function(req, res, next, value) {
    console.log('CALLED ONLY ONCE with', value);
    next();
});
app.get('/user/:id/:page', function(req. res, next) {
    console.log('although this matches');
    next();
});
app.get('/user/:id/:page', function (req, res, next) {
    console.log('and this matches too');
    res.end();
});

Al ejecutar GET /user/42/3, el resultado es el siguiente:

CALLED ONLY ONCE with 42
CALLED ONLY ONCE with 3
although this matches
and this mathes too

Lo que se describe en la siguiente secciónapp.param(callback)quedó en desuso después de v4.11.0.

Al pasar un solo parámetro de devolución de llamada aapp.param(name, callback)método,app.param(naem, callback)el comportamiento del método cambiará por completo. Este parámetro de devolución de llamada es unapp.param(name, callback)método personalizado que determina qué comportamiento debe tener. Este método debe aceptar dos parámetros y devolver un middleware.app.param(name, callback)la firma del parámetro se ha modificado aapp.param(name, accessId). El reemplazo acepta un nombre de parámetro y una devolución de llamada,app.param()ahora acepta un nombre de parámetro y un número.

var express = require('express');
var app = express();
app.param(function(param, option){
    return function(req, res, next, val) {
        if (val == option) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
app.param('id', 1337);
app.get('/user/:id', function(req, res) {
    res.send('Ok');
});
app.listen(3000, function() {
    console.log('Ready');
}); 

En este ejemplo, la firma de app.param(name, callback) se mantiene igual que antes, pero se reemplaza por un middleware que define un método personalizado de verificación de tipos para comprobar la corrección del tipo de user id.

app.param(function(param, validator) {
    return function(req, res, next, val) {
        if (validator(val)) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
app.param('id', function(candidate) {
    return !isNaN(parseFloat(candidate)) && isFinite(candidate);
});

Al usar expresiones regulares, no uses.. Por ejemplo, no puedes usar/user-.+/para capturaruser-gami, sino usa[\\s\\S]o[\\w\\>W]en su lugar (como/user-[\\s\\S]+/).

//captures '1-a_6' but not '543-azser-sder'
router.get('/[0-9]+-[[\\w]]*', function); 
//captures '1-a_6' and '543-az(ser"-sder' but not '5-a s'
router.get('/[0-9]+-[[\\S]]*', function); 
//captures all (equivalent to '.*')
router.get('[[\\s\\S]]*', function); 

app.path()

a través de este método se puede obtenerappla ruta típica, que es unastring。

 var app = express()
      , blog = express()
      , blogAdmin = express();
    app.use('/blog', blog);
    app.use('/admin', blogAdmin);
    console.log(app.path()); // ''
    console.log(blog.path()); // '/blog'
    console.log(blogAdmin.path()); // '/blog/admin'

Si la app está montada de forma compleja, el comportamiento de este método también será complejo: una forma más útil de usarlo es emplear req.baseUrl para obtener la ruta típica de la app.

app.post(path, callback, [callback ...])

Enruta solicitudes HTTP POST a una ruta específica con devoluciones de llamada específicas. Para obtener más información, consulta la [guía de enrutamiento](http://expressjs.com/guide/routing.html).

Puedes proporcionar múltiples funciones de devolución de llamada; su comportamiento es igual al de los middleware, excepto que estas devoluciones de llamada pueden omitir el resto de las devoluciones de llamada de la ruta llamando a next('router'). Puedes usar este mecanismo para establecer condiciones previas para una ruta; si la solicitud no cumple las condiciones de manejo de la ruta actual, el control se transfiere a las rutas siguientes.

app.post('/', function(req, res) {
    res.send('POST request to homepage')
});

app.put(path, callback, [callback ...])

EnrutaHTTP PUTsolicitudes a una ruta específica con devoluciones de llamada específicas. Para obtener más información, consultarouting guide。

Puedes proporcionar múltiples funciones de devolución de llamada, que se comportan como middleware, excepto que estas devoluciones de llamada pueden, al llamar a next('router'),next('router')omitir el resto de las devoluciones de llamada de la ruta. Puedes usar este mecanismo para establecer condiciones previas para una ruta; si la solicitud no cumple las condiciones de manejo de la ruta actual, el control se transfiere a las rutas siguientes.

app.put('/', function(req, res) {
    res.send('PUT request to homepage');
});

app.render(view, [locals], callback)

A través decallbackla devolución de llamada devuelve unviewtexto HTML obtenido después de la renderización. Puede aceptar un parámetro opcional que contiene losviewdatos locales necesarios para este. Este método es similar ares.render()，excepto que no envía el texto HTML renderizado al cliente。

va aapp.render()trátalo como un método de utilidad que puede generar cadenas de vista renderizadas. Enres.render()internamente, se utilizaapp.render()para renderizar las vistas.

Si la caché de vistas está habilitada, se conserva la caché de variables locales. Si quieres almacenar en caché las vistas durante el desarrollo, establécelo entrue. En el entorno de producción, la caché de vistas está activada por defecto.

app.render('email', function(err, html) {
// ...
});
app.render('email', {name:'Tobi'}, function(err, html) {
// ...
});

app.route(path)

Devuelve una instancia de ruta en modo singleton, sobre la cual puedes aplicar middleware de varios verbos HTTP. Usaapp.route()para evitar nombres de ruta duplicados (por ejemplo, errores tipográficos): el significado es que se debe usarapp.router()este método singleton para evitar múltiples instancias de ruta para la misma ruta.

var app = express();
app.route('/events')
.all(function(req, res, next) {
  // runs for all HTTP verbs first
  // think of it as route specific middleware!
})
.get(function(req, res, next) {
  res.json(...);
})
.post(function(req, res, next) {
  // maybe add a new event...
})

app.set(name, value)

Asigna el valor value al elemento de configuración name; name es unaApplication settingsde las propiedades de

Puedes usar app.get() para obtener el valor configurado:

app.set('title', 'My Site');
    app.get('title'); // 'My Site'

Application Settings

Sinamees una de las configuraciones de la app, afectará el comportamiento de la app. A continuación se enumeran las configuraciones de la app.

trust proxyopciones de configuraciónConsultaExpress behind proxiespara obtener más información.

app.set('trust proxy', 'loopback') // specify a single subnet
app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address
app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array

app.set('trust proxy', function (ip) {
    if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
    else return false;
  })

etagConfigura la opción ETagcuya implementación utiliza eletagpaquete. Si necesitas obtener más información, puedes consultar su documentación.

app.set('etag', function (body, encoding) {
  return generateHash(body, encoding); // consider the function is defined
  })

app.use([path,], function [, function...])

Montala función middlewareen la ruta. Si no se especifica una ruta, el valor predeterminado es "/".

Una ruta coincidirá con cualquier ruta si esta comienza con la ruta configurada seguida de "/". Por ejemplo:app.use('/appale', ...)coincidirá con "/apple", "/apple/images", "/apple/images/news", etc.

En el middlewarereq.originalUrlSíreq.baseUrlyreq.pathla combinación, como se muestra en el siguiente ejemplo.

app.use('/admin', function(req, res, next) {
// GET 'http://www.example.com/admin/new'
console.log(req.originalUrl); // '/admin/new'
console.log(req.baseUrl); // '/admin'
console.log(req.path);// '/new'
});

Después de montar un middleware en una ruta, cada vez que la parte de prefijo de la ruta solicitada coincida con esta ruta, el middleware se ejecutará. Dado que la ruta predeterminada es/, si el middleware se monta sin especificar una ruta, entonces este middleware se ejecutará para cada solicitud.

 // this middleware will be executed for every request to the app.
app.use(function(req, res, next) {
    console.log('Time: %d', Date.now());
    next();
});

Los métodos de middleware se procesan en orden, por lo que el orden en que se incluyen los middleware es muy importante.

// this middleware will not allow the request to  go beyond it
app.use(function(req, res, next) {
    res.send('Hello World');
});
// this middleware will never reach this route
app.use('/', function(req, res) {
    res.send('Welcome');
});

La ruta puede ser una cadena de caracteres que representa la ruta, un patrón de ruta, una expresión regular que coincida con la ruta, o un conjunto de ellos.

A continuación se muestran ejemplos simples de rutas.

// will match paths starting with /abcd
app.use('/abcd', function (req, res, next) {
  next();
})

// will match paths starting with /abcd and /abd
app.use('/abc?d', function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /abbcd, /abbbbbcd and so on
app.use('/ab+cd', function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /abxcd, /abFOOcd, /abbArcd and so on
app.use('/ab\*cd', function (req, res, next) {
  next();
})

// will match paths starting with /ad and /abcd
app.use('/a(bc)?d', function (req, res, next) {
  next();
})

// will match paths starting with /abc and /xyz
app.use(/\/abc|\/xyz/, function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /xyza, /lmn, and /pqr
app.use(['/abcd', '/xyza', /\/lmn|\/pqr/], function (req, res, next) {
  next();
})

El método puede ser un método de middleware, una serie de métodos de middleware, un conjunto de métodos de middleware o una combinación de ellos. Dado que router y app implementan la interfaz de middleware, puedes usarlos como cualquier otro método de middleware.

app.use(function (req, res, next) {
  next();
})

var router = express.Router();
router.get('/', function (req, res, next) {
  next();
})
app.use(router);

var subApp = express();
subApp.get('/', function (req, res, next) {
  next();
})
app.use(subApp);

var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
})

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
})

app.use(r1, r2);

var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
})

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
})

app.use('/', [r1, r2]);

function mw1(req, res, next) { next(); }
function mw2(req, res, next) { next(); }

var r1 = express.Router();
r1.get('/', function (req, res, next) { next(); });

var r2 = express.Router();
r2.get('/', function (req, res, next) { next(); });

var subApp = express();
subApp.get('/', function (req, res, next) { next(); });

app.use(mw1, [mw2, r1, r2], subApp);

A continuación se muestran algunos ejemplos de uso del middleware express.static en una aplicación Express.

Sirve los recursos estáticos ubicados en el directorio public dentro del directorio de la aplicación:

// GET /style.css etc
app.use(express.static(__dirname + '/public'));

En/staticMonta el middleware en la ruta para proporcionar el servicio de alojamiento de recursos estáticos, solo cuando la solicitud tiene como prefijo/staticcomo prefijo.

// GET /static/style.css etc.
app.use('/static', express.static(express.__dirname + '/public'));

Desactiva el registro de solicitudes de recursos estáticos cargando el middleware de registro después de configurar el middleware de recursos estáticos.

app.use(express.static(__dirname + '/public'));
app.use(logger());

Sirve recursos estáticos desde diferentes rutas, pero./publicla ruta se empareja más fácilmente que otras:

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

Request

reqEl objeto representa una solicitud HTTP y tiene algunas propiedades para almacenar datos de la solicitud, comoquery string，parameters，body，HTTP headersetc. En este documento, por convención, este objeto siempre se abrevia comoreq(la respuesta HTTP se abrevia comores), pero sus nombres reales están determinados por los parámetros de este método de devolución de llamada cuando se usa. Por ejemplo:

app.get('/user/:id', function(req, res) {
    res.send('user' + req.params.id);
});

En realidad, también puedes escribirlo así:

app.get('/user/:id', function(request, response) {
    response.send('user' + request.params.id);
});

Properties

EnExpress 4En ,req.filespor defecto enreqya no está disponible en el objeto.req.filesobjeto para obtener los archivos subidos, puedes usar unmultipart-handling(conjunto de herramientas de procesamiento múltiple) middleware, comobusboy，multer，formidable，multipraty，connect-multipartyopez。

req.app

Esta propiedad contieneexpressuna referencia a la instancia de la aplicación, que se puede usar como middleware.

Si sigues este patrón, creas un módulo que exporta un middleware, y este middleware solo en tu archivo principalrequire()ello, entonces este middleware puede a través dereq.apppara obtener la instancia de express.

// index.js
app.get("/viewdirectory", require('./mymiddleware.js'));

// mymiddleware.js
module.exports = function(req, res) {
    res.send('The views directory is ' + req.app.get('views'));
};

req.baseUrl

La ruta URL donde se monta una instancia de enrutador.

var greet = express.Router();
greet.get('/jp', function(req, res) {
    console.log(req.baseUrl); // greet
    res.send('Konichiwa!');
});
app.use('/greet', greet);

Incluso si usas un patrón de ruta o una serie de patrones de ruta para cargar la ruta,baseUrlla propiedad devuelve la cadena coincidente, no el patrón de ruta. El siguiente ejemplo,greetla ruta se carga en dos patrones de ruta.

app.use(['/gre+t', 'hel{2}o'], greet); // load the on router on '/gre+t' and '/hel{2}o'

Cuando la ruta de una solicitud es/greet/jp，baseUrlSí/greet, cuando la ruta de una solicitud es/hello/jp，req.baseUrlSí/hello。 req.baseUrlyappdel objetomountpathla propiedad es similar, excepto queapp.mountpathdevuelve el patrón de coincidencia de ruta.

req.body

En el body de la solicitud se guardan los pares de datos clave-valor enviados. Por defecto, esundefined, cuando usas, por ejemplo,body-parserymultereste tipo de middleware que analizabodydatos, cuando se usa, se rellena.body-parsermiddleware para rellenarreq.body。

var app = require('express');
var bodyParser = require('body-parser');
var multer = require('multer')；// v1.0.5
var upload = multer(); // for parsing multipart/form-data
app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({extended:true})); // for parsing application/x-www-form-urlencoded
app.post('/profile', upload.array(), function(req, res, next) {
    console.log(req.body);
    res.json(req.body);
});

req.cookies

Cuando se usa el middleware cookie-parser, esta propiedad es un objeto que contiene las cookies enviadas en la solicitud. Si la solicitud no trae cookies, su valor es {}.

// Cookie: name=tj
req.cookies.name
// => "tj"

Para obtener más información, problemas o inquietudes, consultacookie-parser。

req.fresh

Indica si esta solicitud es fresca. Es lo contrario dereq.stalees lo contrario.cache-controlEl encabezado de solicitud no tieneno-cacheindicación y cualquiera de las siguientes condiciones estrue, entonces estrue：

• if-modified-sinceel encabezado de solicitud está especificado, ylast-modifiedel encabezado de solicitud es igual o anterior amodifiedel encabezado de respuesta.
• if-none-matchel encabezado de solicitud es*。
• if-none-matchel encabezado de solicitud, después de ser analizado en sus directivas, yetagel valor del encabezado de respuesta no es igual

ps: Función de If-None-Match: If-None-Match funciona junto con ETag. El principio de funcionamiento es agregar información de ETag en la respuesta HTTP. Cuando el usuario vuelve a solicitar el recurso, se agregará la información If-None-Match (el valor de ETag) en la solicitud HTTP. Si el servidor verifica que el ETag del recurso no ha cambiado (el recurso no se ha actualizado), devolverá un estado 304 para indicar al cliente que use el archivo de caché local. De lo contrario, devolverá un estado 200 junto con el nuevo recurso y el nuevo ETag. El uso de este mecanismo mejorará el rendimiento del sitio web.

req.fresh
// => true

req.hostname

contiene el valor proveniente deHostdel encabezado HTTPhostname。

Cuandotrust proxyla opción de configuración está establecida en un valor habilitado,X-Forwarded-Hostse utiliza el encabezado en lugar deHost. Este encabezado puede ser establecido por el cliente o un proxy.

// Host: "example.com"
req.hostname
// => "example.com"

req.ips

Cuandotrust proxyLa opción de configuración está establecida como habilitada, esta propiedad contiene un conjunto deX-Forwarded-Fordirecciones IP especificadas en el encabezado de solicitud. De lo contrario, contiene un array vacío. Este encabezado puede ser establecido por el cliente o un proxy.

Por ejemplo, siX-Forwarded-ForSíclient，proxy1，proxy2，req.ipsentonces["clinet", "proxy1", "proxy2"], aquíproxy2es el más lejano aguas abajo.

req.originalUrl

req.urlNo es una propiedad nativaExpressla propiedad se hereda deNode's http module。

Esta propiedad es muy similar areq.url; sin embargo, conserva el enlace de solicitud original, permitiéndote redirigir librementereq.urla rutas internas. Por ejemplo,app.use()demountingla característica puede redirigirreq.urlal punto de montaje.

// GET /search?q=something
req.originalUrl
// => "/search?q=something"

req.params

Un objeto que contiene una serie de propiedades que se corresponden una a una con los nombres de los parámetros nombrados en la ruta. Por ejemplo, si tienes/user/:namela ruta,namela propiedad está disponible comoreq.params.name. El valor predeterminado de este objeto es{}。

// GET /user/tj
req.params.name
// => "tj"

Cuando usas expresiones regulares para definir reglas de ruta, las combinaciones de grupos de captura generalmente usanreq.params[n], dondenes el número del grupo de captura./file/*de la ruta:

// GET /file/javascripts/jquery.js
req.params[0]
// => "javascripts/jquery.js"

req.path

Contiene la parte de la ruta de la URL de la solicitud.

// example.com/users?sort=desc
req.path
// => "/users"

Cuando se llama en un middleware, el punto de montaje no se incluye enreq.pathello. Puedes consultarapp.use()para obtener más información.

req.protocol

El protocolo de la solicitud, generalmente,http, cuando se habilita el cifrado TLS, eshttps。

Cuandotrust proxyAl establecer un parámetro habilitado, si existeX-Forwarded-Protoel encabezado, será confiable y se utilizará. Este encabezado puede ser establecido por el cliente o un proxy.

req.ptotocol
// => "http"

req.query

Un objeto que, para cadaquery stringparámetro de la ruta, asigna una propiedad. Si no hayquery string, es un objeto vacío,{}。

// GET /search?q=tobi+ferret
req.query.q
// => "tobi ferret"
// GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
req.query.order
// => "desc"
req.query.shoe.color
// => "blue"
req.query.shoe.type
// => "converse"

req.route

La ruta actualmente coincidente, que es una cadena de caracteres. Por ejemplo:

app.get('/user/:id?', function userIdHandler(req, res) {
    console.log(req.route);
    res.send('GET')
})

La salida del fragmento anterior es:

{ path:"/user/:id?"
    stack:
    [
        { handle:[Function:userIdHandler],
          name:"userIdHandler",
          params:undefined,
          path:undefined,
          keys:[],
          regexp:/^\/?$/i,
          method:'get'
        }
    ]
    methods:{get:true}
}

req.secure

Un valor booleano, si se establece una conexión TLS, entonces estrue. Equivalente a:

'https' == req.protocol;

req.signedCookies

Cuando se usacookie-parserel middleware, esta propiedad contiene la firma enviada en la solicitudcookies, esta propiedad obtiene el valor sin firma, listo para usar. La firmacookiesse guarda en un objeto diferente para reflejar la intención del desarrollador; de lo contrario, se podría aplicar un ataque malicioso a losreq.cookievalores (es muy fácil de engañar). Recuerda, firmar uncookieno es ocultarlo ni cifrarlo; sino simplemente evitar la manipulación (porque el cifrado utilizado para la firma es privado). Si no se envía la firmacookie, entonces esta propiedad por defecto es{}。

// Cookie： user=tobi.CP7AWaXDfAKIRfH49dQzKJx7sKzzSoPq7/AcBBRVwlI3
req.signedCookies.user
// => "tobi"

Para obtener más información, problemas o inquietudes, consultacookie-parser。

req.stale

Indica si esta solicitud esstale(obsoleta), es lo contrario dereq.freshes lo contrario. Más información, puedes consultarreq.fresh。

req.stale
// => true

req.subdomains

El array de subdominios del dominio en la solicitud.

// Host: "tobi.ferrets.example.com"
req.subdomains
// => ["ferrets", "tobi"]

req.xhr

Un valor booleano, siX-Requested-Withel valor de esXMLHttpRequest, entonces estrue, que indica que esta solicitud fue enviada por una biblioteca de cliente, comojQuery。

req.xhr
// => true

Methods

req.accepts(types)

Comprueba si el tipo de contenido especificado es aceptado, basándose en el encabezado HTTP Accept de la solicitud. Este método devuelve la mejor coincidencia; si no hay ninguna coincidencia, devuelve undefined (en ese caso, el servidor debería devolver 406 y "Not Acceptable").

El valor type puede ser una cadena de tipo MIME única (como application/json), una extensión como json, una lista separada por comas o un array. Para una lista o array, este método devuelve el mejor elemento (si lo hay).

// Accept: text/html
req.accepts('html');
// => "html"
// Accept: text/*, application/json
req.accepts('html');
// => "html"
req.accepts('text/html');
// => "text/html"
req.accepts(['json', 'text']);
// => "json"
req.accepts('application/json');
// => "application/json"
// Accept: text/*, application/json
req.accepts('image/png');
req.accepts('png');
// => undefined
// Accept: text/*;q=.5, application/json
req.accepts(['html', 'json']);
// => "json"

Para obtener más información, o si tienes problemas o inquietudes, consultaaccepts。

req.acceptsCharsets(charset[, ...])

Devuelve el primer juego de caracteres configurado del conjunto de juegos de caracteres especificado, basado en la solicitud.Accept-CharsetEncabezado HTTP. Si el conjunto de caracteres especificado no coincide, devuelve false. Para obtener más información, o si tienes preguntas o inquietudes, consultaaccepts。

req.acceptsEncodings(encoding[, ...])

Devuelve la primera codificación configurada del conjunto de codificaciones especificado, basada en la solicitudAccept-EncodingEncabezado HTTP. Si el conjunto de codificaciones especificado no coincide, devuelve false. Para obtener más información, o si tienes preguntas o inquietudes, consultaaccepts。

req.acceptsLanguages(lang [, ...])

Devuelve el primer idioma configurado del conjunto de idiomas especificado, basado en la solicitudAccept-LanguageEncabezado HTTP. Si el conjunto de idiomas especificado no coincide, devuelve false. Para obtener más información, o si tienes preguntas o inquietudes, consultaaccepts。

req.get(field)

Devuelve el contenido del campo de la cabecera HTTP de solicitud especificada (sin distinguir entre mayúsculas y minúsculas).ReferreryRefererLos contenidos de los campos son intercambiables.

req.get('Content-type');
// => "text/plain"
req.get('content-type');
// => "text/plain"
req.get('Something')
// => undefined

que esAlias de req.header(field).

req.is(type)

Si la solicitud entranteContent-typeel campo de cabecera coincide con el parámetrotypedadoMIME type, entonces devuelvetrue. De lo contrario, devuelvefalse。

// With Content-Type: text/html; charset=utf-8
req.is('html');
req.is('text/html');
req.is('text/*');
// => true
// When Content-Type is application/json
req.is('json');
req.is('application/json');
req.is('application/*');
// => true
req.is('html');
// => false

Para obtener más información, o si tienes preguntas o inquietudes, consultatype-is。

req.param(naem, [, defaultValue])

Obsoleto. Cuando sea apropiado, usareq.params，req.bodyoreq.query。

Devuelve el valor del parámetro actualname.

// ?name=tobi
req.param('name')
// => "tobi"
// POST name=tobi
req.param('name')
// => "tobi"
// /user/tobi for /user/:name
req.param('name')
// => "tobi"

Se busca en el siguiente orden:

• req.params
• req.body
• req.query

Opcionalmente, puedes especificar undefaultValuepara establecer un valor predeterminado si el parámetro no se encuentra en ninguno de los objetos de la solicitud.

Directamente a través dereq.params，req.body，req.queryobtenerlo debería ser más claro, a menos que estés seguro de la entrada de cada objeto.Body-parserEl middleware debe cargarse si usasreq.param(). Consulta los detalles enreq.body。

Response

resEl objeto representa la respuesta HTTP queExpressel programa devuelve cuando llega una solicitud HTTP. En este documento, por convención, este objeto siempre se abrevia comores(la solicitud HTTP se abrevia comoreq), pero sus nombres reales están determinados por los parámetros del método de devolución de llamada donde se usan.

app.get('/user/:id', function(req, res) {
    res.send('user' + req.params.id);
});

Escribirlo de esta manera también es lo mismo:

app.get('/user/:id', function(request, response) {
    response.send('user' + request.params.id);
});

Properties

res.app

Esta propiedad contiene una referencia a la instancia de la aplicación express, que se puede usar en el middleware.

res.app y la propiedad req.app del objeto de solicitud son idénticas. /p>

res.headersSent

Propiedad de tipo booleano que indica si esta respuesta ya ha enviado las cabeceras HTTP.

app.get('/', function(req, res) {
    console.log(res.headersSent); // false
    res.send('OK'); // send之后就发送了头部
    console.log(res.headersSent); // true
});

res.locals

Un objeto que contiene las variables de la respuesta para esta solicitud y, por lo tanto, sus variables solo están disponibles para la representación de vistas dentro del ciclo de respuesta de esta solicitud (si hay vistas). En otros aspectos, es igual queapp.localses lo mismo.

Este parámetro es muy útil para exportar información a nivel de solicitud, como la ruta de la solicitud, el usuario autenticado, la configuración del usuario, etc.

app.use(function(req, res, next) {
    res.locals.user = req.user;
    res.locals.authenticated = !req.user.anonymous;
    next();
});

Methods

res.append(field [, value])

El método res.append() está disponible enExpresxsSolo se admite en versiones 4.11.0 o superiores.

En lafieldcabecera HTTP especificada, agrega un valor específicovalue. Si esta cabecera no se ha establecido, se usarávaluepara crear esta cabecera.valuePuede ser una cadena o un array.

Nota: después deres.append()llamar aapp.set()se restablecerán los valores establecidos anteriormente.

res.append('Lind', ['<http://localhost>', '<http://localhost:3000>']);
res.append('Set-Cookie', 'foo=bar;Path=/;HttpOnly');
res.append('Warning', '199 Miscellaneous warning');

res.attachment([filename])

Establece elContent-Dispositionde la respuesta HTTP como 'attachment'. Si se proporcionafilename, entonces se usaráres.type()para obtener la extensión y establecerContent-Type, y se estableceContent-Dispositioncomo 'filename=parámetro'.

res.attachment();
// Content-Disposition: attachment
res.attachment('path/to/logo.png');
// Content-Disposition: attachment; filename="logo.png"
// Content-Type: image/png

res.cookie(name, value [,options])

Establecenameyvaluedecookie，valueEl parámetro puede ser una cadena o un objeto que se convierte en una cadena JSON.

options es un objeto que puede tener las siguientes propiedades.

Todo lo que hace res.cookie() se basa en eloptionsparámetro proporcionado para establecerSet-Cookiela cabecera. Si no se especifica ningúnoptions, entonces el valor predeterminado se especifica enRFC6265.

Ejemplo de uso:

res.cookie('name', 'tobi', {'domain':'.example.com', 'path':'/admin', 'secure':true});
res.cookie('remenberme', '1', {'expires':new Date(Date.now() + 90000), 'httpOnly':true});

maxAge es una opción conveniente para establecer el tiempo de expiración, calculado en milisegundos a partir del tiempo actual. El siguiente ejemplo tiene el mismo efecto que el segundo de arriba.

res.cookie('rememberme', '1', {'maxAge':90000}, "httpOnly":true);

Puedes pasar un objeto como parámetro de value. Luego se serializará como una cadena JSON y será analizado por el middleware bodyParser().

res.cookie('cart', {'items':[1, 2, 3]});
res.cookie('cart', {'items':[1, 2, 3]}, {'maxAge':90000});

Cuando usamos el middleware cookie-parser, este método también admite cookies firmadas. Simplemente incluye la opción signed como true al configurar options. Entonces res.cookie() usará la clave pasada a cookieParser(secret) para firmar el valor.

res.cookie('name', 'tobi', {'signed':true});

res.clearCookie(name [,options])

Según lanameespecificada, borra la cookie correspondiente. Para más información sobreoptionsel objeto, consultares.cookie()。

res.cookie('name', 'tobi', {'path':'/admin'});
res.clearCookie('name', {'path':'admin'});

res.download(path, [,filename], [,fn])

Transfierepathel archivo especificado como adjunto. Normalmente, el navegador le indica al usuario que lo descargue. De forma predeterminada,Content-Dispositionel parámetro del encabezado 'filename=' espath(que suele aparecer en el cuadro de diálogo del navegador). Al especificar elfilenameparámetro se sobrescribe el valor predeterminado.

Cuando ocurre un error o cuando se completa la transferencia, este método llamará alfnmétodo de devolución de llamada especificado. Este método utilizares.sendFile()para transferir el archivo.

res.download('/report-12345.pdf');
res.download('/report-12345.pdf', 'report.pdf');
res.download('report-12345.pdf', 'report.pdf', function(err) {
// Handle error, but keep in mind the response may be partially-sent
// so check res.headersSent
if (err) {
} else {
// decrement a download credit, etc.
}
});

res.end([data] [, encoding])

Finaliza el proceso de esta respuesta. Este método proviene en realidad delNodemódulo central, específicamente deresponse.end() method of http.ServerResponse。

se usa para finalizar rápidamente la solicitud, sin ningún dato. Si necesitas enviar datos, puedes usar métodos comores.send()yres.json().

res.end();
res.status(404).end();

res.format(object)

Realiza la negociación de contenido, según elAcceptencabezado HTTP especificado en el objeto de solicitud para el contenido aceptado. Usa req.accepts() para seleccionar un controlador que sirva la solicitud, ordenados por valor de calidad. Si este encabezado no se especifica, se llama al primer método por defecto. Cuando no hay coincidencia, el servidor devuelve406'Not Acceptable', o llama aldefaultcallback.

Content-TypeLa cabecera de solicitud se establece cuando se selecciona un método de devolución de llamada. Sin embargo, puedes cambiarla dentro de este método usando métodos comores.set()ores.type()。

El siguiente ejemplo responderá{"message":"hey"}, cuando en el objeto de la solicitudAcceptel encabezado se establece como 'application/json' o '*/json' (aunque si es*/*, entonces la respuesta será 'hey').

res.format({
    'text/plain':function() {
        res.send('hey');
    },
    'text/html':function() {
        res.send('<p>hey</p>');
    },
    'application/json':function() {
        res.send({message:'hey'});
    },
    'default':function() {
        res.status(406).send('Not Acceptable');
    }
})

Además de los tipos MIME normalizados, también puedes usar extensiones para mapear estos tipos y evitar implementaciones largas:

res.format({
    text:function() {
        res.send('hey');
    },
    html:function() {
        res.send('<p>hey</p>');
    },
    json:function() {
        res.send({message:'hey'});
    }
})

res.get(field)

Devuelvefieldla cabecera de respuesta HTTP especificada. La coincidencia distingue entre mayúsculas y minúsculas.

res.get('Content-Type');
// => "text/plain"

res.json([body])

Envía una respuesta JSON. Este método es el mismo que pasar un objeto o un array como parámetro ares.send()Sin embargo, puedes usar este método para convertir otros valores a JSON, comonull，undefined. (Aunque técnicamente no son JSON válidos).

res.json(null);
res.json({user:'tobi'});
res.status(500).json({error:'message'});

res.jsonp([body])

Envía una respuesta JSON y admite JSONP. Este método tiene el mismo efecto que res.json(), excepto que admite devoluciones de llamada JSONP en sus opciones.

res.jsonp(null)
// => null
res.jsonp({user:'tobi'})
// => {"user" : "tobi"}
res.status(500).jsonp({error:'message'})
// => {"error" : "message"}

De forma predeterminada, el método de devolución de llamada JSONP se escribe simplemente como callback. Se puedejsonp callback nameconfigurar para sobrescribirlo.

A continuación se muestran algunos ejemplos de respuestas JSONP, usando el mismo código:

// ?callback=foo
res.jsonp({user:'tobo'})
// => foo({"user":"tobi"})
app.set('jsonp callback name', 'cb')
// ?cb=foo
res.status(500).jsonp({error:'message'})
// => foo({"error":"message"})

res.links(links)

Conecta estaslinks，linksse proporcionan como propiedades de los parámetros pasados; el contenido concatenado se usa para completar el encabezado HTTP Link de la respuesta.

res.links({
    next:'http://api.example.com/users?page=2',
    last:'http://api.example.com/user?page=5'
});

Resultado:

Link:<http://api.example.com/users?page=2>;rel="next",
<http://api.example.com/users?page=5>;rel="last"

res.location(path)

Establece elLocationHTTP de la respuesta alpathparámetro especificado.

res.location('/foo/bar');
res.location('http://example.com');
res.location('back');

CuandopathCuando el parámetro esback, tiene un significado especial: especifica la URL como laRefererespecificada en el encabezado del objeto de solicitud. Si no se especifica en la solicitud, entonces es '/'.

Express pasa la cadena URL especificada como valor del encabezadoLocationen la respuesta al navegador, sin inspeccionar ni manipular, excepto porbackeste parámetro. El navegador redirigirá al usuario alocationla URL establecida o aRefererla URL de (backel caso del parámetro).

res.redirect([status,] path)

La redirección se origina desde la URL especificadapathy elHTTP status codestatusespecificado. Si no especificasstatus, el código de estado por defecto es '302 Found'.

res.redirect('/foo/bar');
res.redirect('http://example.com');
res.redirect(301, 'http://example.com');
res.redirect('../login');

La redirección también puede ser una URL completa, para redirigir a un sitio diferente.

res.redirect('http://google.com');</p><p>
重定向也可以相对于主机的根路径。比如，如果程序的路径为<strong>http://example.com/admin/post/new</strong>，那么下面将重定向到<strong>http://example.com/admim</strong>:</p>
<pre>res.redirect('/admin');

La redirección también puede ser relativa a la URL actual. Por ejemplo, viniendo dehttp://example.com/blog/admin/(ten en cuenta la/final), lo siguiente redirigirá ahttp://example.com/blog/admin/post/new。

res.redirect('post/new');

Si vienes dehttp://example.com/blog/admin(sin cola/), redirecciónpost/new，se redirigirá ahttp://example.com/blog/post/new. Si crees que lo anterior es confuso, puedes considerar los segmentos de ruta como directorios (con '/') o archivos, y eso es válido. La redirección a rutas relativas también es válida. Si tu ruta actual eshttp://example.com/admin/post/new, la siguiente operación redirigirá ahttp://example.com/admin/post：

res.redirect('..');

backredirigirá la solicitud areferer, cuando no hayreferercuando..., por defecto es/。

res.redirect('back');

res.render(view [, locals] [, callback])

Renderizar una vista y luego enviar el documento HTML renderizado al cliente. Los parámetros opcionales son:

• locals, un objeto que define las propiedades de las variables locales de la vista.
• callback, un método de callback. Si se proporciona este parámetro,renderel método devolverá el error y la plantilla renderizada, y no enviará la respuesta automáticamente. Cuando se produce un error, se puede llamar dentro de este callback,next(err)método.

La caché de variables locales habilita el almacenamiento en caché de vistas. En el entorno de desarrollo, para almacenar en caché las vistas, se debe establecer manualmente en true; el almacenamiento en caché de vistas está habilitado de forma predeterminada en el entorno de producción.

// send the rendered view to the client
res.render('index');
// if a callback is specified, the render HTML string has to be sent explicitly
res.render('index', function(err, html) {
    res.send(html);
});
// pass a local variable to  the view
res.render('user', {name:'Tobi'}, function(err, html) {
    // ...
});

res.send([body])

enviar la respuesta HTTP.

bodyel parámetro puede ser unBufferobjeto, una cadena, un objeto o un arreglo. Por ejemplo:

res.send(new Buffer('whoop'));
res.send({some:'json'});
res.send('<p>some html</p>');
res.status(404).send('Sorry, we cannot find that!');
res.status(500).send({ error: 'something blew up' });

Para solicitudes no transmitidas en flujo, este método puede realizar muchas tareas útiles: por ejemplo, asigna automáticamente el valor del encabezado de respuesta HTTP Content-Length (a menos que se haya definido previamente), y también admite actualizaciones automáticas de HEAD y caché HTTP.

Cuando el parámetro es un objeto Buffer, este método establece el encabezado de respuesta Content-Type a application/octet-stream, a menos que se haya proporcionado previamente, como se muestra a continuación:

res.set('Content-Type', 'text/html');
res.send(new Buffer('<p>some html</p>'));

Cuando el parámetro es una cadena, este método establece el encabezado de respuesta Content-Type a text/html:

res.send('<p>some html</p>');

Cuando el parámetro es un objeto o un arreglo, Express utiliza el formato JSON para representarlo:

res.send({user:'tobi'});
res.send([1, 2, 3]);

res.sendFile(path [, options] [, fn])

res.sendFile()desdeExpress v4.8.0Comienza a admitir.

transmisiónpathel archivo especificado. Según la extensión del archivo, estableceContent-Typeencabezados HTTP. A menos que enoptionscontiene información sobrerootla configuración,pathdebe ser una ruta absoluta relacionada con el archivo.optionsdetalles del parámetro:

Cuando la transferencia se completa u ocurre algún error, este método llamafnal método de callback. Si se especifica este parámetro de callback y ocurre un error, el método de callback debe manejar explícitamente el proceso de respuesta finalizando el ciclo de solicitud-respuesta o pasando el control a la siguiente ruta.

A continuación se muestra el uso con todos los parámetros.res.sendFile()El ejemplo:

app.get('/file/:name', function(req, res, next) {
    var options = {
        root:__dirname + '/public',
        dotfile:'deny',
        headers:{
            'x-timestamp':Date.now(),
            'x-sent':true
        }
    };
    var fileName = req.params.name;
    res.sendFile(fileName, options, function(err) {
        if (err) {
            console.log(err);
            res.status(err.status).end();
        }
        else {
            console.log('sent', fileName);
        }
    });
});

res.sendFile proporciona soporte de grano fino para el servicio de archivos, como se ilustra en el siguiente ejemplo:

app.get('/user/:uid/photos/:file', function(req, res) {
    var uid = req.params.uid
        , file = req.params.file;
    req.user.mayViewFilesFrom(uid, function(yes) {
        if (yes) {
            res.sendFile('/upload/' + uid + '/' + file);
        }
        else {
            res.status(403).send('Sorry! you cant see that.');
        }
    });
})

Para obtener más información, o si tienes preguntas o inquietudes, puedes consultarsend。

res.sendStatus(statusCode)

establecer el objeto de respuestaHTTP status codeParastatusCodey enviarstatusCodela forma de cadena correspondiente del código como el Body de la respuesta.

res.sendStatus(200); // equivalent to res.status(200).send('OK');
res.sendStatus(403); // equivalent to res.status(403).send('Forbidden');
res.sendStatus(404); // equivalent to res.status(404).send('Not Found');
res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')

Si se especifica un estado no admitido, el estado HTTP se establece de todos modos comostatusCodey se utiliza la cadena de este code como Body.

res.sendStatus(2000); // equivalent to res.status(2000).send('2000');

More about HTTP Status Codes

res.set(field [, value])

Establece los encabezados HTTP del objeto de respuesta.fieldParavalue. Para establecer varios valores a la vez, se puede pasar un objeto como parámetro.

res.set('Content-Type', 'text/plain');
res.set({
    'Content-Type':'text/plain',
    'Content-Length':'123',
    'ETag':'123456'
})

Su efecto es el mismo que res.header(field [,value]).

res.status(code)

Use este método para establecer el estado HTTP del objeto de respuesta. Es elresponse.statusCodeun alias coherente de.

res.status(403).end();
res.status(400).send('Bad Request');
res.status(404).sendFile('/absolute/path/to/404.png');

res.type(type)

El programa estableceráContent-TypeMIME type del encabezado HTTP, si esta configuracióntypepuede sermime.lookupanalizar en el correctoContent-Type. Sitypecontiene/carácter, entonces el programa establecerá directamenteContent-TypeParatype。

res.type('.html');              // => 'text/html'
res.type('html');               // => 'text/html'
res.type('json');               // => 'application/json'
res.type('application/json');   // => 'application/json'
res.type('png');                // => image/png:

res.vary(field)

Agrega el encabezado Vary cuando no hay un encabezado Vary.

Nota: el propósito de vary es decirle al servidor proxy/caché/CDN cómo determinar si las solicitudes son iguales. La combinación en vary es la base para que el servidor/caché/CDN juzgue. Por ejemplo, si Vary contiene User-Agent, entonces, incluso si la solicitud es la misma, cuando un usuario abre una página con IE y luego la abre con Firefox, el CDN/proxy considerará que son páginas diferentes. Si Vary no contiene User-Agent, el CDN/proxy considerará que son la misma página y devolverá directamente la página en caché al usuario, sin volver a solicitar la página correspondiente al servidor web. En términos sencillos, es equivalente afieldusarlo como una clave de caché para determinar si se acierta en el caché.

res.vary('User-Agent').render('docs');

Router

unrouterobjeto es una instancia separada de middleware y enrutamiento. Puedes considerarlo como una "mini-application" (mini programa), que tiene la capacidad de manejar middleware y métodos de enrutamiento. CadaExpressprograma tiene una ruta de app integrada.app.use()un parámetro del método o como el de otra ruta.use()los parámetros.expressEl objeto tiene unRouter()método, puedes usarRouter()para crear un nuevorouterobjeto.

res.vary('User-Agent').render('docs');

Router([options])

de la siguiente manera, puedes crear una ruta:

var router = express.Router([options]);

optionsEl parámetro puede especificar el comportamiento de la ruta, y tiene las siguientes opciones:

Puedesroutertrátalo como un programa, sobre el cual se pueden agregar middleware y métodos de enrutamiento HTTP (por ejemploget，put，postetc.).

// invoked for any requests passed to this router
router.use(function(req, res, next) {
  // .. some logic here .. like any other middleware
  next();
});
// will handle any request that ends in /events
// depends on where the router is "use()'d"
router.get('/events', function(req, res, next) {
  // ..
});

Puedes montar una ruta en una URL raíz especial, de modo que puedas colocar tus distintas rutas en diferentes archivos o incluso en mini programas.

// only requests to /calendar/* will be sent to our "router"
app.use('/calendar', router);

Methods

router.all(path, [callback, ...] callback)

Este método yrouter.METHOD()igual que el método, excepto que este método coincide con todos los verbos HTTP.

Este método es muy útil para mapear el procesamiento lógico global a prefijos de ruta especiales o coincidencias arbitrarias. Por ejemplo, si colocas la ruta que se muestra a continuación delante de otras rutas, se requerirá que todas las rutas desde ese punto realicen operaciones de validación y carguen automáticamente la información del usuario. Recuerda que estas operaciones lógicas globales no necesitan finalizar el ciclo de solicitud-respuesta:loaduserpuede ejecutar una tarea y luego llamar anext()para transferir el flujo de ejecución a la ruta siguiente.

router.all('*', requireAuthentication, loadUser);

la forma equivalente:

router.all('*', requireAuthentication)
router.all('*', loadUser);

Este es un ejemplo de funcionalidad global de lista blanca. Este ejemplo es muy similar al anterior, excepto que solo actúa sobre rutas que comienzan con/apila ruta que comienza con:

router.all('/api/*', requireAuthentication);

router.METHOD(path, [callback, ...] callback)

router.METHOD()El método proporciona métodos de enrutamiento enExpressen, aquíMETHODes uno de los métodos HTTP, por ejemploGET，PUT，POSTetc., perorouterel METHOD dentro está en minúsculas. Por lo tanto, el método real esrouter.get()，router.put()，router.post()etc.

Puedes proporcionar múltiples funciones de callback, que se comportan igual que el middleware, excepto que estos callbacks pueden omitir los callbacks de ruta restantes al llamar anext('router')para omitir los callbacks de ruta restantes. Puedes usar este mecanismo para establecer algunas condiciones previas para una ruta. Si la solicitud no cumple las condiciones de manejo de la ruta actual, entonces se pasa el control a la ruta siguiente.

El siguiente fragmento probablemente ilustra la definición de ruta más simple. Express convierte la cadena path en una expresión regular para coincidir internamente con las solicitudes entrantes. Al coincidir, no se tienen en cuentaQuery stringsPor ejemplo, "GET /" coincidirá con la siguiente ruta, y "GET /?name=tobi" también.

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

Si tienes restricciones especiales sobre el path a coincidir, puedes usar expresiones regulares. Por ejemplo, lo siguiente puede coincidir con "GET /commits/71dbb9c" y "GET /commits/71bb92..4c084f9".

router.get(/^\/commits\/(\w+)(?:\.\.(\w+))?$/, function(req, res) {
    var from = req.params[0];
    var to = req.params[1];
    res.send('commit range ' + from + '..' + to);
});

router.param(name, callback)

Agregar un desencadenador de callback al parámetro de ruta, dondenamees el nombre del parámetro,functiones el método de callback. Los parámetros del método de callback son, en orden, el objeto de solicitud, el objeto de respuesta, el siguiente middleware, el valor del parámetro y el nombre del parámetro. Aunquenametécnicamente es opcional, pero está en desuso desde Express V4.11.0 (ver abajo).

A diferencia deapp.param()，router.param()No acepta un array como parámetro de ruta.

Por ejemplo, cuando:useraparece en el path de la ruta, puedes mapear el procesamiento lógico de la carga del usuario para proporcionar automáticamentereq.userpara esta ruta, o para validar los parámetros de entrada.

router.param('user', function(req, res, next, id) {
    User.find(id, function(error, user) {
        if (err) {
            next(err);
        }
        else if (user){
            req.user = user;
        } else {
            next(new Error('failed to load user'));
        }
    });
});

ParaParamEn cuanto a las rutas definidas con callbacks, son locales. No serán heredadas por la app o el router montados. Por lo tanto, definidas enrouterde arribaparamla devolución de llamada solo es cuandoroutersolo tiene efecto cuando las rutas correspondientes tienen este parámetro de ruta.

En las rutas donde se defineparamel parámetro de ruta,paramlos callbacks son los primeros en ser invocados; se invocan una vez y solo una vez dentro de un ciclo de solicitud-respuesta, incluso si varias rutas coinciden, como se muestra en el siguiente ejemplo:

router.param('id', function(req, res, next, id) {
    console.log('CALLED ONLY ONCE');
    next();
});
router.get('/user/:id', function(req, res, next) {
    console.log('although this matches');
    next();
});
router.get('/user/:id', function(req, res) {
    console.log('and this mathces too');
    res.end();
});

Cuando se hace GET /user/42, se obtiene el siguiente resultado:

CALLED ONLY ONCE
although this matches
and this matches too

Lo descrito en la siguiente secciónrouter.param(callback)está en desuso desde v4.11.0.

Al pasar únicamente un parámetro de callback arouter.param(name, callback)método,router.param(naem, callback)el comportamiento del método cambiará por completo. Este parámetro de callback es acerca derouter.param(name, callback)un método personalizado que define el comportamiento que este debe tener; este método debe aceptar dos parámetros y devolver un middleware.

El primer parámetro de este callback es el nombre del parámetro de URL que se captura; el segundo parámetro puede ser cualquier objeto de JavaScript, que puede utilizarse al implementar el middleware devuelto. El middleware devuelto por este callback determina el comportamiento que se adopta cuando la URL contiene este parámetro.

En el siguiente ejemplo,router.param(name, callback)la firma del parámetro se modificó arouter.param(name, accessId). El reemplazo acepta un nombre de parámetro y un callback,router.param()ahora acepta un nombre de parámetro y un número.

var express = require('express');
var app = express();
var router = express.Router();
router.param(function(param, option){
    return function(req, res, next, val) {
        if (val == option) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
router.param('id', 1337);
router.get('/user/:id', function(req, res) {
    res.send('Ok');
});
app.use(router);
app.listen(3000, function() {
    console.log('Ready');
}); 

En este ejemplo, la firma de router.param(name, callback) se mantiene igual que antes, pero se reemplaza por un middleware que define un método personalizado de detección de tipos de datos para verificar la corrección del tipo de user id.

router.param(function(param, validator) {
    return function(req, res, next, val) {
        if (validator(val)) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
router.param('id', function(candidate) {
    return !isNaN(parseFloat(candidate)) && isFinite(candidate);
});

router.route(path)

Devuelve una instancia de ruta en modo singleton, sobre la cual puedes aplicar middlewares de varias acciones HTTP. Usarouter.route()para evitar nombres de ruta duplicados (por ejemplo, errores tipográficos); lo que se quiere decir es usarrouter.route()este método singleton para evitar múltiples instancias de ruta para el mismo path.

Basándose en el ejemplo anterior,router.param()el siguiente código muestra cómo usarrouter.route()para especificar manejadores para varios métodos HTTP.

var router = express.Router();
router.param('user_id', function(req, res, next, id) {
    // sample user, would actually fetch from DB, etc...
    req.user = {
        id:id,
        name:"TJ"
    };
    next();
});
router.route('/users/:user_id')
    .all(function(req, res, next) {
        // runs for all HTTP verbs first
        // think of it as route specific middleware!
        next();
    })
    .get(function(req, res, next) {
        res.json(req.user);
    })
    .put(function(req, res, next) {
        // just an example of maybe updating the user
        req.user.name = req.params.name;
        // save user ... etc
        res.json(req.user);
    })
    .post(function(req, res, next) {
        next(new Error('not implemented'));
    })
    .delete(function(req, res, next) {
        next(new Error('not implemented'));
    })

Este método reutiliza una única/usrs/:userruta 'id' para añadir varios métodos HTTP.

router.use([path], [function, ...] function)

Para el parámetro opcionalpathque se especifica en la ruta, monta el método middleware dado; si no se especificapathel parámetro, el valor predeterminado es/.app.use()Este método es similar aapp.use()para obtener más información.

El middleware es como una tubería de fontanería: la solicitud comienza en el primer middleware que definas y avanza a lo largo de la pila de middlewares, manejando la solicitud si la ruta coincide.

var express = require('express');
var app = express();
var router = express.Router();
// simple logger for this router`s requests
// all requests to this router will first hit this middleware
router.use(function(req, res, next) {
    console.log('%s %s %s', req.method, req.url, req.path);
    next();
})
// this will only be invoked if the path starts with /bar form the mount ponit
router.use('/bar', function(req, res, next) {
    // ... maybe some additional /bar logging ...
    next();
})
// always be invoked
router.use(function(req, res, next) {
    res.send('hello world')；
})
app.use('/foo', router);
app.listen(3000);

Para las funciones middleware, la ruta de montaje se elimina y no es visible. El impacto principal de esta característica es que puedes montar el mismo middleware en diferentes rutas sin cambios en el código, aunque el prefijo haya cambiado.

El orden en que defines los middlewares con router.use() es importante. Los middlewares se invocan en orden, por lo que el orden determina su prioridad. Por ejemplo, normalmente el registro (logger) es el primer middleware que usarás, para que cada solicitud sea registrada.

var logger = require('morgan');
router.use(logger());
router.use(express.static(__dirname + '/public'));
router.use(function(req, res) {
    res.send('Hello');
});

Ahora, para admitir que no deseas registrar las solicitudes de archivos estáticos, pero continuar registrando aquellas definidas después delogger()las rutas y middlewares. Simplemente puedes moverstatic()al frente para resolverlo:

router.use(express.static(__dirname + '/public'));
router.use(logger());
router.use(function(req, res){
  res.send('Hello');
});

Otro ejemplo claro es servir archivos estáticos desde diferentes rutas; puedes poner./publical frente para obtener una mayor prioridad:

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

router.use()El método también admite parámetros con nombre, de modo que tu punto de montaje puede usar parámetros con nombre para precargar otras rutas, lo cual es muy beneficioso.

Dirección original: https://github.com/bajian/express_api_4.x_chinese