Resumen de la API Response

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

Propiedades

El objeto res contiene una serie de propiedades que proporcionan información sobre la respuesta HTTP.

res.charset

Asigna el charset. Por defecto "utf-8".

res.charset = 'value';
res.send('<p>some html</p>');
// => Content-Type: text/html; charset=value

Las variables locales de respuesta están limitadas a la solicitud, por lo tanto solo están disponibles para las vista(s) renderizadas durante ese ciclo de solicitud / respuesta, si las hay. Por lo demás esta API es idéntica a app.locals.

Este objeto es útil para exponer información a nivel de solicitud como el pathname de la solicitud, usuario autenticado, configuraciones de usuario etcétera.

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

res.req

Esta propiedad contiene una referencia al objeto request que se relaciona con este objeto de respuesta.

Métodos

El objeto res contiene una serie de métodos que pueden usarse para enviar respuestas, establecer encabezados, y más.

res.attachment([filename])

Establece el campo de encabezado Content-Disposition a "attachment". Si se da un filename entonces el Content-Type será establecido automáticamente basándose en la extensión vía res.type(), y el parámetro "filename=" del Content-Disposition será establecido.

res.attachment();
// Content-Disposition: attachment

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

res.clearCookie(name, [options])

Limpia la cookie name. La opción path por defecto es "/".

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

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

Establece la cookie name al valor value, que puede ser una cadena u objeto convertido a JSON. La opción path por defecto es "/".

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

La opción maxAge es una opción de conveniencia para establecer "expires" relativo al tiempo actual en milisegundos. Lo siguiente es equivalente al ejemplo anterior.

res.cookie('remember_me', '1', { maxAge: 900000, httpOnly: true });

Se puede pasar un objeto que luego se serializa como JSON, el cual es analizado automáticamente por el middleware bodyParser().

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

Las cookies firmadas también son soportadas a través de este método. Simplemente pasa la opción signed. Cuando se da res.cookie() usará el secreto pasado a express.cookieParser(secret) para firmar el valor.

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

Luego puedes acceder a este valor a través del objeto req.signedCookie.

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

Transfiere el archivo en la path como un "attachment", típicamente los navegadores preguntarán al usuario para descargar. El parámetro "filename=" del Content-Disposition, es decir, el que aparecerá en el diálogo del navegador se establece a path por defecto, sin embargo puedes proporcionar un filename de anulación.

Cuando ocurre un error o la transferencia se completa el callback opcional fn es invocado. Este método usa res.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) {
  if (err) {
    // handle error, keep in mind the response may be partially-sent
    // so check res.headerSent
  } else {
    // decrement a download credit etc
  }
});

res.format(object)

Realiza negociación de contenido en el campo de encabezado Accept de la solicitud cuando está presente. Este método usa req.accepted, un array de tipos aceptables ordenados por sus valores de calidad, de lo contrario se invoca el primer callback. Cuando no se realiza ninguna coincidencia el servidor responde con 406 "Not Acceptable", o invoca el callback default.

El Content-Type se establece por ti cuando se selecciona un callback, sin embargo puedes alterarlo dentro del callback usando res.set() o res.type() etcétera.

El siguiente ejemplo respondería con { "message": "hey" } cuando el campo de encabezado Accept está establecido a "application/json" o "/json", sin embargo si se da "/*" entonces "hey" será la respuesta.

res.format({
  'text/plain': function () {
    res.send('hey');
  },

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

  'application/json': function () {
    res.send({ message: 'hey' });
  },
});

Además de los tipos MIME canonizados también puedes usar extensiones mapeadas a estos tipos, proporcionando una implementación ligeramente menos verbosa:

res.format({
  text: function () {
    res.send('hey');
  },

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

  json: function () {
    res.send({ message: 'hey' });
  },
});

res.get(field)

Obtiene el field de encabezado de respuesta sin distinguir mayúsculas y minúsculas.

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

res.json([status|body], [body])

Envía una respuesta JSON. Este método es idéntico a res.send() cuando se pasa un objeto o array, sin embargo puede usarse para conversión explícita a JSON de no-objetos (null, undefined, etc), aunque técnicamente estos no son JSON válido.

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

res.jsonp([status|body], [body])

Envía una respuesta JSON con soporte JSONP. Este método es idéntico a res.json() sin embargo opta por el soporte de callback JSONP.

res.jsonp(null);
// => null

res.jsonp({ user: 'tobi' });
// => { "user": "tobi" }

res.jsonp(500, { error: 'message' });
// => { "error": "message" }

Por defecto el nombre del callback JSONP es simplemente callback, sin embargo puedes alterarlo con el ajuste jsonp callback name. Los siguientes son algunos ejemplos de respuestas JSONP usando el mismo código:

// ?callback=foo
res.jsonp({ user: 'tobi' });
// => foo({ "user": "tobi" })

app.set('jsonp callback name', 'cb');

// ?cb=foo
res.jsonp(500, { error: 'message' });
// => foo({ "error": "message" })

res.links(links)

Une los links dados para popular el campo de encabezado de respuesta "Link".

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

p yields:

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

res.location()

Establece el encabezado location.

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

Puedes usar el mismo tipo de urls que en res.redirect().

Por ejemplo, si tu aplicación está montada en /blog, lo siguiente establecería el encabezado location a /blog/admin:

res.location('admin');

res.redirect([status], url)

Redirige a la url dada con código de status opcional por defecto 302 "Found".

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

Express soporta algunas formas de redirección, la primera siendo una URI completamente calificada para redirigir a un sitio diferente:

res.redirect('https://google.com');

La segunda forma es la redirección relativa al pathname, por ejemplo si estabas en http://example.com/admin/post/new, la siguiente redirección a /admin te llevaría a http://example.com/admin:

res.redirect('/admin');

La siguiente redirección es relativa al punto de montaje de la aplicación. Por ejemplo si tienes una aplicación de blog montada en /blog, idealmente no tiene conocimiento de dónde fue montada, así que donde una redirección de /admin/post/new simplemente te daría http://example.com/admin/post/new, la siguiente redirección relativa al montaje te daría http://example.com/blog/admin/post/new:

res.redirect('admin/post/new');

Las redirecciones relativas al pathname también son posibles. Si estabas en http://example.com/admin/post/new, la siguiente redirección te llevaría a http//example.com/admin/post:

res.redirect('..');

El caso especial final es una redirección back, redirigiendo hacia atrás al Referer (o Referrer), por defecto / cuando falta.

res.redirect('back');

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

Renderiza una view con un callback que responde con la cadena renderizada. Cuando ocurre un error next(err) es invocado internamente. Cuando se proporciona un callback tanto el posible error como la cadena renderizada se pasan, y no se realiza respuesta automatizada.

res.render('index', function (err, html) {
  // ...
});

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

res.send([body|status], [body])

Envía una respuesta.

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

Este método realiza una miríada de tareas útiles para respuestas simples no-streaming como asignar automáticamente el Content-Length a menos que se haya definido previamente y proporcionar soporte automático de frescura de caché HEAD y HTTP.

Cuando se da un Buffer el Content-Type se establece a "application/octet-stream" a menos que se haya definido previamente como se muestra abajo:

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

Cuando se da un String el Content-Type por defecto se establece a "text/html":

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

Cuando se da un Array u Object Express responderá con la representación JSON:

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

Finalmente cuando se da un Number sin ninguno de los cuerpos mencionados previamente, entonces una cadena de cuerpo de respuesta se asigna por ti. Por ejemplo 200 responderá con el texto "OK", y 404 "Not Found" y así sucesivamente.

res.send(200);
res.send(404);
res.send(500);

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

Transfiere el archivo en la path dada.

Por defecto automáticamente establece el campo de encabezado de respuesta Content-Type basándose en la extensión del archivo. El callback fn(err) es invocado cuando la transferencia se completa o cuando ocurre un error.

Opciones:

maxAge en milisegundos, por defecto 0
root directorio raíz para nombres de archivo relativos

Este método proporciona soporte detallado para servir archivos como se ilustra en el siguiente ejemplo:

app.get('/user/:uid/photos/:file', function (req, res) {
  var uid = req.params.uid;
  var file = req.params.file;

  req.user.mayViewFilesFrom(uid, function (yes) {
    if (yes) {
      res.sendfile('/uploads/' + uid + '/' + file);
    } else {
      res.send(403, 'Sorry! you cant see that.');
    }
  });
});

res.set(field, [value])

Establece el encabezado field al valor value, o pasa un objeto para establecer múltiples campos a la vez.

res.set('Content-Type', 'text/plain');

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

Alias como res.header(field, [value]).

res.status(code)

Alias encadenable de res.statusCode= de node.

res.status(404).sendfile('path/to/404.png');

res.type(type)

Establece el Content-Type a la búsqueda mime del type, o cuando "/" está presente el Content-Type simplemente se establece a este valor literal.

res.type('.html');
res.type('html');
res.type('json');
res.type('application/json');
res.type('png');

p Alias como res.contentType(type).