概述

vary 库功能介绍

vary 主要功能是为了方便在响应头上添加 Vary 头信息。

HTTP 响应头 Vary 介绍

响应头 Vary 主要是用于缓存的控制。源服务器会通过 Vary 告诉代理服务器如何使用缓存。
当代理服务器接收到源服务器带有 Vary 响应头的响应后，若要对其进行缓存，则该缓存只对 Vary 指定的请求头字段相同的请求生效。所以即使对相同资源发起请求，但由于 Vary 指定的请求头字段不相同，也无法使用缓存，必须从源服务器中重新获取资源。

基本使用

vary

直接对 response 添加 vary 头信息

  1. // 类型声明
  2. declare function vary(res: ServerResponse, field: string | string[]): void;
  4. // 使用
  5. http.createServer(function(req, res) {
  6.   //...
  7.   vary(res, 'User-Agent')
  8.   //...
  9. })

vary.append

直接在已有的 vary 头信息上添加新的字段信息，合并两个 vary 字段

  1. // 类型声明
  2. declare namespace vary {
  3.     function append(header: string, field: string | string[]): string;
  4. }
  6. // 使用
  7. http.createServer(function(req, res) {
  8.   //...
  9.   const vary = vary.append('Accept, User-Agent', 'Origin')
  10.   res.setHeader
  11.   //...
  12. })

源码阅读

parse

主要对已有的 vary 字段信息进行结构，由字符串信息变成更好处理的数组。
eg: 'Origin, Accept, Origin' => ['Origin', 'Accept', 'Origin']

  1. function parse (header: string): string[] {
  2.   var end = 0
  3.   var start = 0
  4.   var list: string[] = []
  6.   // gather tokens
  7.   // 类似于词法分析中的直接扫描法
  8.   for (var i = 0, len = header.length; i < len; i++) {
  9.       // 遍历字符串
  10.     switch (header.charCodeAt(i)) {
  11.       // 可以忽略字段开头和结尾的空格，但不会忽略字段中间的空格  
  12.       case 0x20: /*   */
  13.         if (start === end) {
  14.           start = end = i + 1
  15.         }
  16.         break
  17.          // 根据 ',' 拆分字段，并加入集合
  18.       case 0x2c: /* , */
  19.         list.push(header.substring(start, end))
  20.         start = end = i + 1
  21.         break
  22.       // 正常字符则略过
  23.       default:
  24.         end = i + 1
  25.         break
  26.     }
  27.   }
  29.   // final token
  30.   // 可能有残留字段，并加入集合
  31.   list.push(header.substring(start, end))
  33.   return list
  34. }

vary.append

  1. function append (header, field) {
  2.   // 入参校验
  3.   if (typeof header !== 'string') {
  4.     throw new TypeError('header argument is required')
  5.   }
  7.   // 入参校验
  8.   if (!field) {
  9.     throw new TypeError('field argument is required')
  10.   }
  12.   // get fields array
  13.   // 解析需要添加的字段成数组
  14.   var fields = !Array.isArray(field)
  15.     ? parse(String(field))
  16.     : field
  18.   // assert on invalid field names
  19.   // 字段验证
  20.   for (var j = 0; j < fields.length; j++) {
  21.     if (!FIELD_NAME_REGEXP.test(fields[j])) {
  22.       throw new TypeError('field argument contains an invalid header name')
  23.     }
  24.   }
  26.   // existing, unspecified vary
  27.   // 如果本来的 vary 是 '*' (所有的请求都被视为唯一并且非缓存的)，则忽略合并并返回
  28.   if (header === '*') {
  29.     return header
  30.   }
  32.   // enumerate current values
  33.   // 解析原有的 vary 字段成数组
  34.   var val = header
  35.   var vals = parse(header.toLowerCase())
  37.   // 与上面一个判断同等意义，如果有 vary 字段为 '*'，则直接返回 '*'
  38.   if (fields.indexOf('*') !== -1 || vals.indexOf('*') !== -1) {
  39.     return '*'
  40.   }
  42.   // 合并字段
  43.   for (var i = 0; i < fields.length; i++) {
  44.     var fld = fields[i].toLowerCase()
  46.     // append value (case-preserving)
  47.     if (vals.indexOf(fld) === -1) {
  48.       vals.push(fld)
  49.       val = val
  50.         ? val + ', ' + fields[i]
  51.         : fields[i]
  52.     }
  53.   }
  55.   return val
  56. }

vary

  1. function vary (res, field) {
  2.   // 判断 res 是否为 SeverResponse 
  3.   if (!res || !res.getHeader || !res.setHeader) {
  4.     // quack quack
  5.     throw new TypeError('res argument is required')
  6.   }
  8.   // get existing header
  9.   // 获取原有的 Vary 头信息，并字符串化
  10.   var val = res.getHeader('Vary') || ''
  11.   var header = Array.isArray(val)
  12.     ? val.join(', ')
  13.     : String(val)
  15.   // set new header
  16.   // 调用 append 合并字段，并设置为新值
  17.   if ((val = append(header, field))) {
  18.     res.setHeader('Vary', val)
  19.   }
  20. }

参考

Vary | MDN
HTTP 协议中 Vary 的一些研究