大文件上传

// 生成文件切片 size：切片大小
function createFileChunk(file, size = SIZE) {
    const fileChunkList = [];
    let currentSize = 0;
    let i = 0;
    while (currentSize < file.size) {
        const bigSize =
            file.size < currentSize + size ? file.size : currentSize + size;
        fileChunkList.push({
            chunk: file.slice(currentSize, currentSize + size),
            // 文件名 + 数组下标
            hash: file.name + "-" + i,
            percentage: 0,
            index: i,
            size: bigSize - currentSize,
        });
        currentSize += size;
        i++;
    }
    return fileChunkList;
}

// 并发数量限制
async function asyncPool(poolLimit, iterable, iteratorFn) {
    const ret = [];
    const executing = new Set();
    for (const item of iterable) {
        const p = Promise.resolve().then(() => iteratorFn(item, iterable));
        ret.push(p);
        executing.add(p);
        const clean = () => executing.delete(p);
        p.then(clean).catch(clean);
        // 最大并发量，等待上传
        if (executing.size >= poolLimit) {
            await Promise.race(executing);
        }
    }
    return Promise.all(ret);
}

const fse = require("fs-extra");
// 写入文件流
const pipeStream = (path, writeStream) => {
    return new Promise((resolve) => {
        const readStream = fse.createReadStream(path);
        readStream.on("end", () => {
            fse.unlinkSync(path);
            resolve();
        });
        readStream.pipe(writeStream);
    });
}

// 合并切片
const mergeFileChunk = async (filePath, filename, size) => {
    const chunkDir = path.resolve(UPLOAD_DIR, "chunkDir" + filename);
    const chunkPaths = await fse.readdir(chunkDir);
    // 根据切片下标进行排序
    // 否则直接读取目录的获得的顺序会错乱
    chunkPaths.sort((a, b) => a.split("-")[1] - b.split("-")[1]);
    // 并发写入文件
    await Promise.all(
        chunkPaths.map((chunkPath, index) =>
            pipeStream(
                path.resolve(chunkDir, chunkPath),
                // 根据 size 在指定位置创建可写流
                fse.createWriteStream(filePath, {
                    start: index * size,
                })
            )
        )
    );
    // 合并后删除保存切片的目录
    fse.rmdirSync(chunkDir);
};

// 创建文件对应的唯一hash
function createFileHash(fileChunkList) {
    return new Promise((resolve) => {
        // 添加 worker 属性
        container.value.worker = new Worker("/hash.js");
        // fileChunkList 切片列表
        container.value.worker.postMessage({ fileChunkList });
        container.value.worker.onmessage = (e) => {
            const { percentage, hash } = e.data;
            // 记录生成 hash 进度条
            hashPercentage.value = parseInt(percentage);
            if (hash) {
                resolve(hash);
            }
        };
    });
}

// hash.js

// 导入脚本
self.importScripts("/spark-md5.min.js");

// 生成文件 hash
self.onmessage = e => {
    const { fileChunkList } = e.data;
    const spark = new self.SparkMD5.ArrayBuffer();
    let percentage = 0;
    let count = 0;
    const loadNext = index => {
        const reader = new FileReader();
        reader.readAsArrayBuffer(fileChunkList[index].file);
        reader.onload = e => {
            count++;
            spark.append(e.target.result);
            if (count === fileChunkList.length) {
                self.postMessage({
                    percentage: 100,
                    hash: spark.end()
                });
                self.close();
            } else {
                percentage += 100 / fileChunkList.length;
                self.postMessage({
                    percentage
                });
                // calculate recursively
                loadNext(count);
            }
        };
    };
    loadNext(0);
};