Request

req对象代表了一个HTTP请求，其具有一些属性来保存请求中的一些数据，比如query string，parameters，body，HTTP headers等等。在本文档中，按照惯例，这个对象总是简称为req(http响应简称为res)，但是它们实际的名字由这个回调方法在那里使用时的参数决定。
如下例子:

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

其实你也可以这样写：

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

Properties

在Express 4中，req.files默认在req对象中不再是可用的。为了通过req.files对象来获得上传的文件，你可以使用一个multipart-handling(多种处理的工具集)中间件，比如busboy，multer，formidable，multipraty，connect-multiparty或者pez。

req.app

这个属性持有express程序实例的一个引用，其可以作为中间件使用。
如果你按照这个模式，你创建一个模块导出一个中间件，这个中间件只在你的主文件中require()它，那么这个中间件可以通过req.app来获取express的实例。
例如:

  1.     // index.js
  2.     app.get("/viewdirectory", require('./mymiddleware.js'));
  1. // mymiddleware.js
  2. module.exports = function(req, res) {
  3.     res.send('The views directory is ' + req.app.get('views'));
  4. };

req.baseUrl

一个路由实例挂载的Url路径。

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

即使你使用的路径模式或者一系列路径模式来加载路由，baseUrl属性返回匹配的字符串，而不是路由模式。下面的例子，greet路由被加载在两个路径模式上。

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

当一个请求路径是/greet/jp，baseUrl是/greet，当一个请求路径是/hello/jp，req.baseUrl是/hello。
req.baseUrl和app对象的mountpath属性相似，除了app.mountpath返回的是路径匹配模式。

req.body

在请求的body中保存的是提交的一对对键值数据。默认情况下，它是undefined，当你使用比如body-parser和multer这类解析body数据的中间件时，它是填充的。
下面的例子，给你展示了怎么使用body-parser中间件来填充req.body。

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

req.cookies

当使用cookie-parser中间件的时候，这个属性是一个对象，其包含了请求发送过来的cookies。如果请求没有带cookies，那么其值为{}。

  1.     // Cookie: name=tj
  2.     req.cookies.name
  3.     // => "tj"

获取更多信息，问题，或者关注，可以查阅cookie-parser。

req.fresh

指示这个请求是否是新鲜的。其和req.stale是相反的。
当cache-control请求头没有no-cache指示和下面中的任一一个条件为true，那么其就为true：

  • if-modified-since请求头被指定，和last-modified请求头等于或者早于modified响应头。
  • if-none-match请求头是*。
  • if-none-match请求头在被解析进它的指令之后，不匹配etag响应头(完全不知道什么鬼)。
  1.     req.fresh
  2.     // => true

req.hostname

包含了源自HostHTTP头部的hostname。
当trust proxy设置项被设置为启用值，X-Forwarded-Host头部被使用来代替Host。这个头部可以被客户端或者代理设置。

  1. // Host: "example.com"
  2. req.hostname
  3. // => "example.com"

req.ips

当trust proxy设置项被设置为启用值，这个属性包含了一组在X-Forwarded-For请求头中指定的IP地址。不然，其就包含一个空的数组。这个头部可以被客户端或者代理设置。
例如，如果X-Forwarded-For是client，proxy1，proxy2，req.ips就是["clinet", "proxy1", "proxy2"]，这里proxy2就是最远的下游。

req.originalUrl

req.url不是一个原生的Express属性，它继承自Node’s http module。

这个属性很像req.url；然而，其保留了原版的请求链接，允许你自由地重定向req.url到内部路由。比如，app.use()的mounting特点可以重定向req.url跳转到挂载点。

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

req.params

一个对象，其包含了一系列的属性，这些属性和在路由中命名的参数名是一一对应的。例如，如果你有/user/:name路由，name属性可作为req.params.name。这个对象默认值为{}。

  1. // GET /user/tj
  2. req.params.name
  3. // => "tj"

当你使用正则表达式来定义路由规则，捕获组的组合一般使用req.params[n]，这里的n是第几个捕获租。这个规则被施加在无名通配符匹配，比如/file/*的路由：

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

req.path

包含请求URL的部分路径。

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

当在一个中间件中被调用，挂载点不包含在req.path中。你可以查阅app.use()获得跟多的信息。

req.protocol

请求的协议，一般为http，当启用TLS加密，则为https。
当trust proxy设置一个启用的参数，如果存在X-Forwarded-Proto头部的话，其将被信赖和使用。这个头部可以被客户端或者代理设置。

  1. req.ptotocol
  2. // => "http"

req.query

一个对象，为每一个路由中的query string参数都分配一个属性。如果没有query string，它就是一个空对象，{}。

  1. // GET /search?q=tobi+ferret
  2. req.query.q
  3. // => "tobi ferret"
  5. // GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
  6. req.query.order
  7. // => "desc"
  9. req.query.shoe.color
  10. // => "blue"
  12. req.query.shoe.type
  13. // => "converse"

req.route

当前匹配的路由，其为一串字符。比如：

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

前面片段的输出为:

  1. { path:"/user/:id?"
  2.     stack:
  3.     [
  4.         { handle:[Function:userIdHandler],
  5.           name:"userIdHandler",
  6.           params:undefined,
  7.           path:undefined,
  8.           keys:[],
  9.           regexp:/^\/?$/i,
  10.           method:'get'
  11.         }
  12.     ]
  13.     methods:{get:true}
  14. }

req.secure

一个布尔值，如果建立的是TLS的连接，那么就为true。等价与：

  1.     'https' == req.protocol;

req.signedCookies

当使用cookie-parser中间件的时候，这个属性包含的是请求发过来的签名cookies，不签名的并且为使用做好了准备(这句真不知道怎么翻译了…)。签名cookies驻留在不同的对象中来体现开发者的意图；不然，一个恶意攻击可以被施加在req.cookie值上(它是很容易被欺骗的)。记住，签名一个cookie不是把它藏起来或者加密；而是简单的防止篡改(因为签名使用的加密是私人的)。如果没有发送签名的cookie，那么这个属性默认为{}。

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

为了获取更多的信息，问题或者关注，可以参阅cookie-parser。

req.stale

指示这个请求是否是stale(陈旧的)，它与req.fresh是相反的。更多信息，可以查看req.fresh。

  1. req.stale
  2. // => true

req.subdomains

请求中域名的子域名数组。

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

req.xhr

一个布尔值，如果X-Requested-With的值为XMLHttpRequest，那么其为true，其指示这个请求是被一个客服端库发送，比如jQuery。

  1. req.xhr
  2. // => true

Methods

req.accepts(types)

检查这个指定的内容类型是否被接受，基于请求的Accept HTTP头部。这个方法返回最佳匹配，如果没有一个匹配，那么其返回undefined(在这个case下，服务器端应该返回406和”Not Acceptable”)。
type值可以是一个单的MIME type字符串(比如application/json)，一个扩展名比如json，一个逗号分隔的列表，或者一个数组。对于一个列表或者数组，这个方法返回最佳项(如果有的话)。

  1. // Accept: text/html
  2. req.accepts('html');
  3. // => "html"
  5. // Accept: text/*, application/json
  6. req.accepts('html');
  7. // => "html"
  9. req.accepts('text/html');
  10. // => "text/html"
  12. req.accepts(['json', 'text']);
  13. // => "json"
  15. req.accepts('application/json');
  16. // => "application/json"
  18. // Accept: text/*, application/json
  19. req.accepts('image/png');
  20. req.accepts('png');
  21. // => undefined
  23. // Accept: text/*;q=.5, application/json
  24. req.accepts(['html', 'json']);
  25. // => "json"

获取更多信息，或者如果你有问题或关注，可以参阅accepts。

req.acceptsCharsets(charset[, …])

返回指定的字符集集合中第一个的配置的字符集，基于请求的Accept-CharsetHTTP头。如果指定的字符集没有匹配的，那么就返回false。
获取更多信息，或者如果你有问题或关注，可以参阅accepts。

req.acceptsEncodings(encoding[, …])

返回指定的编码集合中第一个的配置的编码，基于请求的Accept-EncodingHTTP头。如果指定的编码集没有匹配的，那么就返回false。
获取更多信息，或者如果你有问题或关注，可以参阅accepts。

req.acceptsLanguages(lang [, …])

返回指定的语言集合中第一个的配置的语言，基于请求的Accept-LanguageHTTP头。如果指定的语言集没有匹配的，那么就返回false。
获取更多信息，或者如果你有问题或关注，可以参阅accepts。

req.get(field)

返回指定的请求HTTP头部的域内容(不区分大小写)。Referrer和Referer的域内容可互换。

  1. req.get('Content-type');
  2. // => "text/plain"
  4. req.get('content-type');
  5. // => "text/plain"
  7. req.get('Something')
  8. // => undefined

其是req.header(field)的别名。

req.is(type)

如果进来的请求的Content-type头部域匹配参数type给定的MIME type，那么其返回true。否则返回false。

  1. // With Content-Type: text/html; charset=utf-8
  2. req.is('html');
  3. req.is('text/html');
  4. req.is('text/*');
  5. // => true
  7. // When Content-Type is application/json
  8. req.is('json');
  9. req.is('application/json');
  10. req.is('application/*');
  11. // => true
  13. req.is('html');
  14. // => false

获取更多信息，或者如果你有问题或关注，可以参阅type-is。

req.param(naem, [, defaultValue])

过时的。可以在适合的情况下，使用req.params，req.body或者req.query。

返回当前参数name的值。

  1. // ?name=tobi
  2. req.param('name')
  3. // => "tobi"
  5. // POST name=tobi
  6. req.param('name')
  7. // => "tobi"
  8. // /user/tobi for /user/:name
  9. req.param('name')
  10. // => "tobi"

按下面给出的顺序查找：

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

可选的，你可以指定一个defaultValue来设置一个默认值，如果这个参数在任何一个请求的对象中都不能找到。

直接通过req.params，req.body，req.query取得应该更加的清晰-除非你确定每一个对象的输入。
Body-parser中间件必须加载，如果你使用req.param()。详细请看req.body。