Request

El objeto req es una versión mejorada del propio objeto request de Node y soporta todos los campos y métodos integrados.

Propiedades

El objeto req contiene una serie de propiedades que proporcionan información sobre la solicitud HTTP, como encabezados, parámetros de consulta, y más.

req.accepted

Devuelve un array de tipos de medios aceptados ordenados de mayor a menor calidad.

[
  { "value": "application/json", "quality": 1, "type": "application", "subtype": "json" },
  { "value": "text/html", "quality": 0.5, "type": "text", "subtype": "html" }
]

req.acceptedCharsets

Devuelve un array de charsets aceptados ordenados de mayor a menor calidad.

Accept-Charset: iso-8859-5;q=.2, unicode-1-1;q=0.8
// => ['unicode-1-1', 'iso-8859-5']

req.acceptedLanguages

Devuelve un array de idiomas aceptados ordenados de mayor a menor calidad.

Accept-Language: en;q=.5, en-us
// => ['en-us', 'en']

req.body

Esta propiedad es un objeto que contiene el cuerpo de la solicitud analizado. Esta característica la proporciona el middleware bodyParser(), aunque otro middleware de análisis de cuerpo puede seguir esta convención también. Esta propiedad por defecto es {} cuando se usa bodyParser().

// POST user[name]=tobi&user[email]=tobi@learnboost.com
console.log(req.body.user.name);
// => "tobi"

console.log(req.body.user.email);
// => "tobi@learnboost.com"

// POST { "name": "tobi" }
console.log(req.body.name);
// => "tobi"

req.cookies

Este objeto requiere el middleware cookieParser() para su uso. Contiene las cookies enviadas por el user-agent. Si no se envían cookies, por defecto es {}.

// Cookie: name=tj
console.log(req.cookies.name);
// => "tj"

req.files

Esta propiedad es un objeto de los archivos subidos. Esta característica la proporciona el middleware bodyParser(), aunque otro middleware de análisis de cuerpo puede seguir esta convención también. Esta propiedad por defecto es {} cuando se usa bodyParser().

Por ejemplo si un campo file se llamaba "image", y se subió un archivo, req.files.image contendría el siguiente objeto File:

{ size: 74643,
  path: '/tmp/8ef9c52abe857867fd0a4e9a819d1876',
  name: 'edge.png',
  type: 'image/png',
  hash: false,
  lastModifiedDate: Thu Aug 09 2012 20:07:51 GMT-0700 (PDT),
  _writeStream:
   { path: '/tmp/8ef9c52abe857867fd0a4e9a819d1876',
     fd: 13,
     writable: false,
     flags: 'w',
     encoding: 'binary',
     mode: 438,
     bytesWritten: 74643,
     busy: false,
     _queue: [],
     _open: [Function],
     drainable: true },
  length: [Getter],
  filename: [Getter],
  mime: [Getter] }

El middleware bodyParser() utiliza el

módulo node-formidable internamente, y acepta las mismas opciones. Un ejemplo de esto es la opción de formidable keepExtensions, por defecto false que en este caso te da el nombre de archivo "/tmp/8ef9c52abe857867fd0a4e9a819d1876" sin la extensión ".png". Para habilitar esto, y otras, puedes pasarlas a bodyParser():

app.use(express.bodyParser({ keepExtensions: true, uploadDir: '/my/files' }));

req.fresh

Verifica si la solicitud es fresca - es decir, Last-Modified y/o el ETag todavía coinciden, indicando que el recurso es "fresco".

console.dir(req.fresh);
// => true

req.host

Devuelve el nombre del host del campo de encabezado "Host" (sin número de puerto).

// Host: "example.com:3000"
console.dir(req.host);
// => 'example.com'

req.ip

Devuelve la dirección remota, o cuando "trust proxy" está habilitado - la dirección upstream.

console.dir(req.ip);
// => '127.0.0.1'

req.ips

Cuando "trust proxy" es true, analiza la lista de direcciones ip "X-Forwarded-For" y devuelve un array, de lo contrario se devuelve un array vacío.

Por ejemplo si el valor fuera "client, proxy1, proxy2" recibirías el array ["client", "proxy1", "proxy2"] donde "proxy2" es el más downstream.

req.originalUrl

Esta propiedad es muy parecida a req.url, sin embargo retiene la url original de la solicitud, permitiéndote reescribir req.url libremente para propósitos de enrutamiento interno. Por ejemplo la característica de "montaje" de app.use() reescribirá req.url para eliminar el punto de montaje.

// GET /search?q=something
console.log(req.originalUrl);
// => "/search?q=something"

req.params

Esta propiedad es un array que contiene propiedades mapeadas a los "parámetros" nombrados de la ruta. Por ejemplo si tienes la ruta /user/:name, entonces la propiedad "name" está disponible como req.params.name. Este objeto por defecto es {}.

// GET /user/tj
console.dir(req.params.name);
// => 'tj'

Cuando se usa una expresión regular para la definición de ruta, los grupos de captura se proporcionan en el array usando req.params[N], donde N es el nth grupo de captura. Esta regla se aplica a coincidencias de comodín sin nombre con rutas de cadena como /file/*:

// GET /file/javascripts/jquery.js
console.dir(req.params[0]);
// => 'javascripts/jquery.js'

req.path

Devuelve el pathname de la URL de solicitud.

// example.com/users?sort=desc
console.dir(req.path);
// => '/users'

req.protocol

Devuelve la cadena de protocolo "http" o "https" cuando se solicita con TLS. Cuando el ajuste "trust proxy" está habilitado el campo de encabezado "X-Forwarded-Proto" será de confianza. Si estás detrás de un proxy inverso que proporciona https esto puede habilitarse.

console.dir(req.protocol);
// => 'http'

req.query

Esta propiedad es un objeto que contiene el query-string analizado, por defecto {}.

// GET /search?q=tobi+ferret
console.dir(req.query.q);
// => 'tobi ferret'

// GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
console.dir(req.query.order);
// => 'desc'

console.dir(req.query.shoe.color);
// => 'blue'

console.dir(req.query.shoe.type);
// => 'converse'

req.res

Esta propiedad contiene una referencia al objeto response que se relaciona con este objeto de solicitud.

req.route

La Route coincidente actualmente que contiene varias propiedades como la cadena de ruta original, el regexp generado, y así sucesivamente.

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

Ejemplo de salida del fragmento anterior:

{ path: '/user/:id?',
  method: 'get',
  callbacks: [ [Function] ],
  keys: [ { name: 'id', optional: true } ],
  regexp: /^\/user(?:\/([^\/]+?))?\/?$/i,
  params: [ id: '12' ] }

req.secure

Verifica si una conexión TLS está establecida. Esto es un atajo para:

console.dir(req.protocol === 'https');
// => true

req.signedCookies

Este objeto requiere el middleware cookieParser(secret) para su uso. Contiene cookies firmadas enviadas por el user-agent, sin firmar y listas para usar. Las cookies firmadas residen en un objeto diferente para mostrar la intención del desarrollador; de lo contrario, un ataque malicioso podría colocarse en los valores de req.cookie (que son fáciles de falsificar). Ten en cuenta que firmar una cookie no la hace "oculta" ni cifrada; esto simplemente previene la manipulación (porque el secreto usado para firmar es privado). Si no se envían cookies firmadas, por defecto es {}.

// Cookie: user=tobi.CP7AWaXDfAKIRfH49dQzKJx7sKzzSoPq7/AcBBRVwlI3
console.dir(req.signedCookies.user);
// => 'tobi'

req.stale

Verifica si la solicitud está stale - es decir, Last-Modified y/o el ETag no coinciden, indicando que el recurso está "stale".

console.dir(req.stale);
// => true

req.subdomains

Devuelve los subdominios como un array.

// Host: "tobi.ferrets.example.com"
console.dir(req.subdomains);
// => ['ferrets', 'tobi']

req.xhr

Verifica si la solicitud fue emitida con el campo de encabezado "X-Requested-With" establecido en "XMLHttpRequest" (jQuery etc).

console.dir(req.xhr);
// => true

Métodos

El objeto req también contiene una serie de métodos que pueden usarse para realizar varias tareas relacionadas con la solicitud HTTP, como verificar el tipo de contenido, recuperar valores de encabezado, y más.

req.accepts(types)

Verifica si los types dados son aceptables, devolviendo la mejor coincidencia cuando es true, de lo contrario undefined - en cuyo caso deberías responder con 406 "Not Acceptable".

El valor type puede ser una cadena de tipo mime única como "application/json", el nombre de la extensión como "json", una lista delimitada por comas o un array. Cuando se da una lista o array se devuelve la mejor coincidencia, si la 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']);
req.accepts('html, json');
// => "json"

req.acceptsCharset(charset)

Verifica si el charset dado es aceptable.

req.acceptsLanguage(lang)

Verifica si el lang dado es aceptable.

req.get(field)

Obtiene el field de encabezado de solicitud sin distinguir mayúsculas y minúsculas. Los campos "Referrer" y "Referer" son intercambiables.

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

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

req.get('Something');
// => undefined

Alias como req.header(field).

req.is(type)

Verifica si la solicitud entrante contiene el campo de encabezado "Content-Type", y coincide con el type mime dado.

// 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

req.param(name)

Devuelve el valor del parámetro name cuando está presente.

// ?name=tobi
req.param('name');
// => "tobi"

// POST name=tobi
req.param('name');
// => "tobi"

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

La búsqueda se realiza en el siguiente orden:

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

El acceso directo a req.body, req.params, y req.query debería favorecerse por claridad - a menos que realmente aceptes entrada de cada objeto.