.4-浅析express源码之applicaiton模块(3)-compil…

app.set = function set(setting, val) {
    // ...设值

    // 触发特殊compile函数
    switch (setting) {
        case 'etag':
            this.set('etag fn', compileETag(val));
            break;
        case 'query parser':
            this.set('query parser fn', compileQueryParser(val));
            break;
        case 'trust proxy':
            this.set('trust proxy fn', compileTrust(val));

            Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
                configurable: true,
                value: false
            });

            break;
    }

    return this;
};

exports.compileETag = function(val) {
    var fn;

    if (typeof val === 'function') {
        return val;
    }
    /**
     * true/weak => weak ETag
     * strong => strong ETag
     * false => 禁ETag
     */
    switch (val) {
        case true:
            fn = exports.wetag;
            break;
        case false:
            break;
        case 'strong':
            fn = exports.etag;
            break;
        case 'weak':
            fn = exports.wetag;
            break;
        default:
            throw new TypeError('unknown value for etag function: ' + val);
    }

    return fn;
}

exports.etag = createETagGenerator({ weak: false })
exports.wetag = createETagGenerator({ weak: true })

function createETagGenerator(options) {
    // 返回一个函数
    return function generateETag(body, encoding) {
        // 返回一个Buffer
        var buf = !Buffer.isBuffer(body) ?
            Buffer.from(body, encoding) :
            body;
        // 传入Buffer与weak选项
        return etag(buf, options)
    }
}

function etag(entity, options) {
    if (entity == null) {
        throw new TypeError('argument entity is required')
    }

    // 判断实例是否是stat对象
    var isStats = isstats(entity);
    // weak变量来源于options或者实例类型
    var weak = options && typeof options.weak === 'boolean' ?
        options.weak :
        isStats;

    // validate argument
    if (!isStats && typeof entity !== 'string' && !Buffer.isBuffer(entity)) {
        throw new TypeError('argument entity must be string, Buffer, or fs.Stats')
    }

    // 生成ETag
    var tag = isStats ?
        stattag(entity) :
        entitytag(entity);
    // 根据weak属性返回对应类型的ETag
    return weak ?
        'W/' + tag :
        tag;
}

function isstats(obj) {
    // 用instanceof直接判断
    if (typeof Stats === 'function' && obj instanceof Stats) {
        return true
    }

    // 鸭子类型
    return obj && typeof obj === 'object' &&
        'ctime' in obj && toString.call(obj.ctime) === '[object Date]' &&
        'mtime' in obj && toString.call(obj.mtime) === '[object Date]' &&
        'ino' in obj && typeof obj.ino === 'number' &&
        'size' in obj && typeof obj.size === 'number'
}

function stattag(stat) {
    // 把两个属性转换为16进制字符串
    var mtime = stat.mtime.getTime().toString(16);
    var size = stat.size.toString(16);
    // 拼接
    return '"' + size + '-' + mtime + '"'
}

function entitytag(entity) {
    if (entity.length === 0) {
        // 直接返回加密后的空字符串 这是个常量
        return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
    }

    // 加密处理
    var hash = crypto
        .createHash('sha1')
        .update(entity, 'utf8')
        .digest('base64')
        .substring(0, 27);

    // 计算内容长度
    var len = typeof entity === 'string' ?
        Buffer.byteLength(entity, 'utf8') :
        entity.length;
    // 拼接长度与hash值
    return '"' + len.toString(16) + '-' + hash + '"';
}

exports.compileQueryParser = function compileQueryParser(val) {
    var fn;

    if (typeof val === 'function') {
        return val;
    }
    /**
     * true/simple => 内置querystring模块
     * extended => qs模块
     * false => 不解析
     */
    switch (val) {
        case true:
            fn = querystring.parse;
            break;
        case false:
            fn = newObject;
            break;
        case 'extended':
            fn = parseExtendedQueryString;
            break;
        case 'simple':
            fn = querystring.parse;
            break;
        default:
            throw new TypeError('unknown value for query parser function: ' + val);
    }

    return fn;
}

// var qs = require('qs');
function parseExtendedQueryString(str) {
    return qs.parse(str, {
        // 该选项允许解析后对象的键覆盖原型方法
        allowPrototypes: true
    });
}