.11-浅析webpack源码之Storage模块

2018-06-24 01:03:42来源：未知阅读 ()

　　至此已完成NodeJsInputFileSysten模块的讲解，下一步就是实际实用的模块：

compiler.inputFileSystem = new CachedInputFileSystem(new NodeJsInputFileSystem(), 60000);

　　挂载到compiler对象上的输入模块其实是带有缓存的输入模块，源码整理如下(用ES6的class重写)：

class CachedInputFileSystem {
    constructor() {
        // fileSystem => NodeJsInputFileSystem => graceful-fs => fs
        this.fileSystem = fileSystem;
        // 生成缓存容器
        this._statStorage = new Storage(duration);
        this._readdirStorage = new Storage(duration);
        this._readFileStorage = new Storage(duration);
        this._readJsonStorage = new Storage(duration);
        this._readlinkStorage = new Storage(duration);
        this._stat = this.fileSystem.stat ? this.fileSystem.stat.bind(this.fileSystem) : null;
        if (!this._stat) this.stat = null;
        // ...more
        // 自定义JSON读取
        if (this.fileSystem.readJson) {
            this._readJson = this.fileSystem.readJson.bind(this.fileSystem);
        } else if (this.readFile) {
            this._readJson = function(path, callback) { /*...*/ }.bind(this);
        } else {
            this.readJson = null;
        }
        // sync...
    }
    stat(path, callback) {
        this._statStorage.provide(path, this._stat, callback);
    };
    // readdir,readFile,readJson,readlink
    // sync...
    purge(what) {
        this._statStorage.purge(what);
        this._readdirStorage.purge(what);
        this._readFileStorage.purge(what);
        this._readlinkStorage.purge(what);
        this._readJsonStorage.purge(what);
    };
}

module.exports = CachedInputFileSystem;

　　这里的核心是利用Storage来生成一个缓存容器，缓存对应的读操作。

　　有两个需要注意的地方。

　　一个是purge方法，这个是Storage的原型方法，所以暂时先放着(形参名有点意思，叫what)。

　　第二个是这个模块自定义了一个方法专门用来读取JSON文件，源码如下：

this._readJson = function(path, callback) {
    // fs.readFile读取文件
    this.readFile(path, function(err, buffer) {
        if (err) return callback(err);
        try {
            // 先将字节流字符转换成utf-8格式的字符串
            // 再调用JSON.parse进行解析
            var data = JSON.parse(buffer.toString("utf-8"));
        } catch (e) {
            return callback(e);
        }
        // 使用回调处理数据
        callback(null, data);
    });
}.bind(this);

　　只是调用JSON.parse解析字符，这个方法只能专门处理JSON格式的数据，不然会报错。

Storage

　　该模块核心在于Storage对象，下面就看一看Storage内部实现，源码如下：

class Storage {
    constructor() {
        // duration => 60000
        this.duration = duration;
        this.running = new Map();
        this.data = new Map();
        this.levels = [];
        if (duration > 0) {
            this.levels.push(new Set(), new Set(), new Set(), new Set(), new Set(), new Set(), new Set(), new Set(), new Set());
            // (duration - 8000) / 500 => 52000 / 500 => 104
            for (var i = 8000; i < duration; i += 500)
                this.levels.push(new Set());
        }
        this.count = 0;
        this.interval = null;
        this.needTickCheck = false;
        this.nextTick = null;
        this.passive = true;
        this.tick = this.tick.bind(this);
    }
    ensureTick() { /*...*/ };
    finished(name, err, result) { /*...*/ };
    finishedSync(name, err, result) { /*...*/ };
    provide(name, provider, callback) { /*...*/ };
    provideSync(name, provider) { /*...*/ };
    tick() { /*...*/ };
    checkTicks() { /*...*/ };
    purge(what) { /*...*/ };
}

　　构造函数中的Set与Map均为ES6新添加的数据结构，详情自行查阅。

　　其中levels数组除去本身的9个Set，根据duration的值，再次加了104个Set对象，之后看具体含义。

　　接下来依次讲解原型函数。

ensureTick

Storage.prototype.ensureTick = function() {
    // 第一调用进行初始化
    // this.tick为定期执行的函数
    // 执行间隔为 (60000 / 113)|0 = 530
    if (!this.interval && this.duration > 0 && !this.nextTick)
        this.interval = setInterval(this.tick, Math.floor(this.duration / this.levels.length));
};

　　可以看出这是一个初始化的方法，初始化一个定时器，间隔取决于传进来的duration。

　　做了一个测试，检测从8000开始到60000定时间隔的变化：

let startNum = 8000,
    startLen = 9,
    result = [];
for (; startNum < 60000; startNum += 500, startLen++) {
    result.push((startNum / startLen | 0));
}

　　输出如图：

　　由于levels的长度最低为9，当传入8000时会达到最大值，所以间隔一定小于0.888秒，且随着duration的值增加而减少，将duration设为100万可以发现这个间隔在500会趋于平缓，大部分暂且可以认为间隔是稳定在0.5秒~0.6秒。

checkTicks

Storage.prototype.checkTicks = function() {
    this.passive = false;
    if (this.nextTick) {
        // 无限执行tick直到返回true
        while (!this.tick());
    }
};

finished

Storage.prototype.finished = function(name, err, result) {
    // 获取指定名字的回调事件流
    var callbacks = this.running.get(name);
    this.running.delete(name);
    if (this.duration > 0) {
        // 设置进data
        this.data.set(name, [err, result]);
        // 获取levels的第一个Set对象
        var levelData = this.levels[0];
        // 新增count才会+1
        this.count -= levelData.size;
        levelData.add(name);
        this.count += levelData.size;
        this.ensureTick();
    }
    // 遍历执行回调
    for (var i = 0; i < callbacks.length; i++) {
        callbacks[i](err, result);
    }
};

　　不应用的话不知道是干嘛用的。

finishedSync

Storage.prototype.finishedSync = function(name, err, result) {
    if (this.duration > 0) {
        // ...一模一样
    }
};

provide

Storage.prototype.provide = function(name, provider, callback) {
    if (typeof name !== "string") {
        callback(new TypeError("path must be a string"));
        return;
    }
    var running = this.running.get(name);
    // 将回调函数加进runnning直接返回
    if (running) {
        running.push(callback);
        return;
    }
    if (this.duration > 0) {
        this.checkTicks();
        // 获取data中对应的事件 异步执行
        var data = this.data.get(name);
        if (data) {
            return process.nextTick(function() {
                callback.apply(null, data);
            });
        }
    }
    // 无法获取running与data时
    this.running.set(name, running = [callback]);
    var _this = this;
    provider(name, function(err, result) {
        _this.finished(name, err, result);
    });
};

　　该方法会先后尝试从running与data中获取对应的事件，无法获取将设置到running中，并调用提供的provider方法。

tick

Storage.prototype.tick = function() {
    var decay = this.levels.pop();
    for (var item of decay) {
        this.data.delete(item);
    }
    this.count -= decay.size;
    decay.clear();
    // 清空后头部插入
    this.levels.unshift(decay);
    // 当没有事件时初始化条件
    if (this.count === 0) {
        clearInterval(this.interval);
        this.interval = null;
        this.nextTick = null;
        return true;
    } else if (this.nextTick) {
        this.nextTick += Math.floor(this.duration / this.levels.length);
        var time = new Date().getTime();
        if (this.nextTick > time) {
            this.nextTick = null;
            // 初始化定时器
            this.interval = setInterval(this.tick, Math.floor(this.duration / this.levels.length));
            return true;
        }
    } else if (this.passive) {
        clearInterval(this.interval);
        this.interval = null;
        this.nextTick = new Date().getTime() + Math.floor(this.duration / this.levels.length);
    } else {
        this.passive = true;
    }
};

　　这个方法在使用中再解释吧。

purge

Storage.prototype.purge = function(what) {
    // 不传参数 
    // 清空所有数据
    if (!what) {
        this.count = 0;
        clearInterval(this.interval);
        this.nextTick = null;
        this.data.clear();
        this.levels.forEach(function(level) {
            level.clear();
        });
    }
    // 传字符串
    // 移除data中所有以参数开头的key 
    else if (typeof what === "string") {
        for (var key of this.data.keys()) {
            if (key.startsWith(what))
                this.data.delete(key);
        }
    }
    // 传数组
    // 递归批量移除
    else {
        for (var i = what.length - 1; i >= 0; i--) {
            this.purge(what[i]);
        }
    }
};