标签:函数 形参 proc 调用 -o star 地方 catch sock
上节漏了几个地方没有讲。
1、process_params
2、trim_prefix
3、done
分别是动态路由,深层路由与最终回调。
这节就只讲这三个地方,案例还是express-generator,不过请求的方式更为复杂。
process_params
在讲这个函数之前,需要先进一下path-to-regexp模块,里面对字符串的正则化有这么一行replace:
path = (‘^‘ + path + (strict ? ‘‘ : path[path.length - 1] === ‘/‘ ? ‘?‘ : ‘/?‘)) // .replace... .replace(/(\\\/)?(\\\.)?:(\w+)(\(.*?\))?(\*)?(\?)?/g, function (match, slash, format, key, capture, star, optional, offset) { // ... keys.push({ name: key, optional: !!optional, offset: offset + extraOffset }); // ... });
这里会对path里面的:(...)进行匹配,然后获冒号后面的字符串,然后作为key传入keys数组,而这个keys数组是layer的属性,后面要用。
另外还要看一个地方,就是layer.mtach,在上一节,由于传的是根路径,所以直接从fast_slash跳出了。
如果是正常的带参数路径,执行过程如下:
/** * @example path = /users/params * @example router.get(‘/users/:id‘) */ Layer.prototype.match = function match(path) { var match if (path != null) { // ...快速匹配 match = this.regexp.exec(path) } if (!match) { /*...*/ } // 缓存params this.params = {}; this.path = match[0] // [{ name: prarms,... }] var keys = this.keys; var params = this.params; for (var i = 1; i < match.length; i++) { var key = keys[i - 1]; var prop = key.name; // decodeURIComponent(val) var val = decode_param(match[i]); // layer.params.id = params if (val !== undefined || !(hasOwnProperty.call(params, prop))) { params[prop] = val; } } return true; };
根据注释的案例,可以看出路由参数的匹配过程,这里仅仅以单参数为例。
下面可以进入process_params方法了,分两步讲:
proto.process_params = function process_params(layer, called, req, res, done) { var params = this.params; // 获取keys数组 var keys = layer.keys; if (!keys || keys.length === 0) return done(); var i = 0; var name; var paramIndex = 0; var key; var paramVal; var paramCallbacks; var paramCalled; function param(err) { if (err) return done(err); if (i >= keys.length) return done(); paramIndex = 0; key = keys[i++]; name = key.name; // req.params = layer.params paramVal = req.params[name]; // 后面讨论 paramCallbacks = params[name]; // 初始为空对象 paramCalled = called[name]; if (paramVal === undefined || !paramCallbacks) return param(); // param previously called with same value or error occurred if (paramCalled && (paramCalled.match === paramVal || (paramCalled.error && paramCalled.error !== ‘route‘))) { // error... } // 设置值 called[name] = paramCalled = { error: null, match: paramVal, value: paramVal }; paramCallback(); } // single param callbacks function paramCallback(err) { //... } param(); };
这里除去遍历参数,有几个变量,稍微解释下:
1、paramVal => 请求路径带的路由参数
2、paramCallbacks => 调用router.params会填充该对象,请求带有指定路由参数会触发的回调函数
3、paramCalled => 一个标记对象
当参数匹配之后,会调用回调函数paramCallback:
function paramCallback(err) { // 依次取出callback数组的fn var fn = paramCallbacks[paramIndex++]; // 标记val paramCalled.value = req.params[key.name]; if (err) { // store error paramCalled.error = err; param(err); return; } if (!fn) return param(); // 调用回调函数 try { fn(req, res, paramCallback, paramVal, key.name); } catch (e) { paramCallback(e); } }
仅仅只是调用在param方法中预先填充的函数。用法参见官方文档的示例:
router.param(‘user‘, function(req, res, next, id) { // ...do something next(); })
每当路由参数是user时,就会触发调用后面注入的函数,其中4个参数可以跟上面源码的形参对应。虽然源码提供了5个参数,但是示例只有4个。
trim_prefix
这个就比较简单了。
案例还是按照上一节的,假设有这样的请求:
// app.js app.use(‘/user‘,userRouter); // userRouter.js router.get(‘/abcd‘,()=>{...}); // client的get请求 path => ‘/users/abcd‘
此时,内部路由将其分发给了usersRouter,但是在分发之前有一个问题。
在自定义的路由中,是不需要指定根路径的,因为在app.use中已经写明了,如果将完整的路径传递进去,在路径正则匹配时会失败,这时候就需要进行trim_prefix了。
源码如下:
/** * * @param layer 匹配到的layer * @param layerError error * @param layerPath layer.path => ‘/users‘ * @param path req.url.pathname => ‘/users/abcd‘ */ function trim_prefix(layer, layerError, layerPath, path) { if (layerPath.length !== 0) { // 保证路径后面的字符串合法 var c = path[layerPath.length] if (c && c !== ‘/‘ && c !== ‘.‘) return next(layerError) debug(‘trim prefix (%s) from url %s‘, layerPath, req.url); // 缓存被移除的path removed = layerPath; req.url = protohost + req.url.substr(protohost.length + removed.length); // 保证移除后的路径以/开头 if (!protohost && req.url[0] !== ‘/‘) { req.url = ‘/‘ + req.url; slashAdded = true; } // 基本路径拼接 req.baseUrl = parentUrl + (removed[removed.length - 1] === ‘/‘ ? removed.substring(0, removed.length - 1) : removed); } debug(‘%s %s : %s‘, layer.name, layerPath, req.originalUrl); // 将新的req.url传进去处理 if (layerError) { layer.handle_error(layerError, req, res, next); } else { layer.handle_request(req, res, next); } }
可以看出,源码就是去掉路径的头,然后将新的路径传到二级layer对象中做匹配。
done
这个最终回调麻烦的要死。
注意:如果调用了res.send()后,源码内部会调用res.end结束响应,回调将不会被执行,这是为了防止意外情况所做的保险工作。
一层一层的来看最终回调的结构,首先是handle方法中的直接定义:
var done = restore(out, req, ‘baseUrl‘, ‘next‘, ‘params‘);
从方法名可以看出这就是一个值恢复的函数:
function restore(fn, obj) { var props = new Array(arguments.length - 2); var vals = new Array(arguments.length - 2); // 在请求到来的时候先缓存原始信息 /** * props = [‘baseUrl‘, ‘next‘, ‘params‘] * vals = [‘url‘,‘next方法‘,‘动态路由的params‘] */ for (var i = 0; i < props.length; i++) { props[i] = arguments[i + 2]; vals[i] = obj[props[i]]; } return function () { // 在请求处理完后对值进行回滚 for (var i = 0; i < props.length; i++) { obj[props[i]] = vals[i]; } return fn.apply(this, arguments); }; }
简单。
下面来看看这个fn是个啥玩意,默认情况下来源于一个工具:
var done = callback || finalhandler(req, res, { env: this.get(‘env‘), onerror: logerror.bind(this) });
function finalhandler(req, res, options) { // 获取配置参数 var opts = options || {} var env = opts.env || process.env.NODE_ENV || ‘development‘ var onerror = opts.onerror return function (err) { // ... } }
在获取参数后,返回了一个新函数,简单看一下done的调用地方:
// 遇到router标记直接调用done if (layerError === ‘router‘) { setImmediate(done, null) return } // 走完了layer匹配 if (idx >= stack.length) { setImmediate(done, layerError); return; } // path为null var path = getPathname(req); if (path == null) { return done(layerError); }
基本上正常情况下就是null,错误情况下会传了一个err,基本上符合node的err first模式。
进入finalhandler方法:
function done(err) { var headers var msg var status // 请求已发送的情况 if (!err && headersSent(res)) { debug(‘cannot 404 after headers sent‘) return } // unhandled error if (err) { // ... } else { // not found status = 404 msg = ‘Cannot ‘ + req.method + ‘ ‘ + encodeUrl(getResourceName(req)) } debug(‘default %s‘, status) // 处理错误 if (err && onerror) { defer(onerror, err, req, res) } // 请求已发送销毁req的socket实例 if (headersSent(res)) { debug(‘cannot %d after headers sent‘, status) req.socket.destroy() return } // 发送请求 send(req, res, status, headers, msg) }
原来这里才是响应的实际地点,在保证无错误并且响应未手动提前发送的情况下,调用本地方法发送请求。
这里的send过程十分繁杂,暂时不想深究,直接看最终的发送代码:
function write () { // response body var body = createHtmlDocument(message) // response status res.statusCode = status res.statusMessage = statuses[status] // response headers setHeaders(res, headers) // security headers res.setHeader(‘Content-Security-Policy‘, "default-src ‘self‘") res.setHeader(‘X-Content-Type-Options‘, ‘nosniff‘) // standard headers res.setHeader(‘Content-Type‘, ‘text/html; charset=utf-8‘) res.setHeader(‘Content-Length‘, Buffer.byteLength(body, ‘utf8‘)) // 只请求页面的首部 if (req.method === ‘HEAD‘) { res.end() return } res.end(body, ‘utf8‘) }
因为注释都解释的很明白了,所以这里简单的贴一下代码,最终调用的是node的原生res.end进行响应。
至此,基本上完事了。
标签:函数 形参 proc 调用 -o star 地方 catch sock
原文地址:https://www.cnblogs.com/QH-Jimmy/p/8945483.html