QR码详解

const canvas = document.querySelector("canvas");
const SIZE = Math.min(window.innerWidth, window.innerHeight) / 6 * 5;
canvas.width = SIZE;
canvas.height = SIZE;

// 版本
const VERSION = 10;
const painter = new Painter(canvas, "2d", VERSION);

// 绘制网格
painter.drawGrid();

// 根据QR码的结构逐步绘制

// 添加定位图案
painter.addLocation();
// 添加对齐图案
painter.addAlignment();
// 添加时序图（定位图形）
painter.addTimeline();
// 添加格式信息
painter.addFormatInfo();
// 添加版本信息
painter.addVersionInfo();
// 添加数据
painter.addData();
// 添加掩膜
painter.addMask();
// 绘制
painter.drawCode();

class Painter {
    /**
     * @param {HTMLCanvasElement} canvas
     * @param {string} contextId
     * @param {number} version
     */
    constructor(canvas, contextId = '2d', version = 1) {
        this.canvas = canvas;
        this.ctx = canvas.getContext(contextId);
        this.version = version;
    }

    // 绘制网格
    drawGrid() {}

    // 添加定位
    addLocation() {}

    // 添加对齐
    addAlignment() {}

    // 添加时序图
    addTimeline() {}

    // 添加格式信息
    addFormatInfo() {}

    // 添加版本信息
    addVersionInfo() {}

    // 添加数据
    addData() {}

    // 添加掩膜
    addMask() {}

    // 绘制
    drawCode() {}
}

class Painter {
    constructor(canvas, contextId = '2d', version = 1) {
        // ...

        // 大小
        this.size = version * 4 + 17;
        // 间隔
        this._spacing = Math.min(canvas.width, canvas.height) / this.size;
        // 结束长度
        this.end = Math.min(canvas.width, canvas.height);
    }

    // 绘制网格
    drawGrid(color = '#000') {
        this.ctx.lineWidth = 0.5;
        this.ctx.strokeStyle = color;
        let end = this.end + this._spacing;
        for (let i = 0; i < end; i += this._spacing) {
            this.ctx.beginPath();
            this.ctx.moveTo(i, 0);
            this.ctx.lineTo(i, this.end);
            this.ctx.stroke();
        }
        for (let i = 0; i < end; i += this._spacing) {
            this.ctx.beginPath();
            this.ctx.moveTo(0, i);
            this.ctx.lineTo(this.end, i);
            this.ctx.stroke();
        }
    }
}

class Painter {
    static ONE_CHANGE = true;   // 是否开启一次写入

    constructor(canvas, contextId = '2d', version = 1) {
        // ...

        // 对应的数据数组（这里需要代理[Proxy]，也可以自定义get、set方法。我们需要一个记录访问过的数据的数组，通过 ONE_CHANGE 来确定值是否可以修改）
        this._codeMap = [];
        for (let i = 0; i < this.size; i++) {
            let row = [];   // 当前行数据
            row.flag = [];  // 访问记录数组
            this._codeMap.push(row);
            for (let j = 0; j < this.size; j++) {
                row.push(0);
                row.flag.push(false);
            }
        }
        // 代理模式
        this._codeMap = new Proxy(this._codeMap, {
            get(target, prop) {
                // 如果不是数字（访问属性），则直接返回该属性
                if (isNaN(Number(prop))) {
                    return target[prop];
                }
                // 给当前行数组挂上一个 y 属性，表示当前行。
                target[prop].y = Number(prop);
                // 行代理
                return new Proxy(target[prop], {
                    set(target, prop, value) {
                        // 如果不是数字（访问属性），则直接返回该属性
                        if (isNaN(Number(prop))) {
                            return target[prop];
                        }

                        // 如果该位置没有被访问过
                        if (target.flag[Number(prop)] === false) {
                            // 如果开启一次写入，则将该位置设置为已访问
                            if (Painter.ONE_CHANGE) {
                                target.flag[Number(prop)] = true;
                            }
                            target[prop] = value;
                        }
                        return true;
                    }
                });
            }
        });
    }

    // 绘制
    drawCode(color = "#000000") {
        this.ctx.fillStyle = color;
        for (let i = 0; i < this.size; i++) {
            for (let j = 0; j < this.size; j++) {
                // 如果为1，则填充颜色
                if (this._codeMap[i][j]) {
                    this.ctx.fillRect(j * this._spacing, i * this._spacing, this._spacing, this._spacing);
                }
            }
        }
    }
}

class Painter {
    // 各个版本校正图形的位置
    static LOCATION = {
        1: [6, 14],
        2: [6, 18],
        3: [6, 22],
        4: [6, 26],
        5: [6, 30],
        6: [6, 34],
        7: [6, 22, 38],
        8: [6, 24, 42],
        9: [6, 26, 46],
        10: [6, 28, 50],
        11: [6, 30, 54],
        12: [6, 32, 58],
        13: [6, 34, 62],
        14: [6, 26, 46, 66],
        15: [6, 26, 48, 70],
        16: [6, 26, 50, 74],
        17: [6, 30, 54, 78],
        18: [6, 30, 56, 82],
        19: [6, 30, 58, 86],
        20: [6, 34, 62, 90],
        21: [6, 28, 50, 72, 94],
        22: [6, 26, 50, 74, 98],
        23: [6, 30, 54, 78, 102],
        24: [6, 28, 54, 80, 106],
        25: [6, 32, 58, 84, 110],
        26: [6, 30, 58, 86, 114],
        27: [6, 34, 62, 90, 118],
        28: [6, 26, 50, 74, 98, 122],
        29: [6, 30, 54, 78, 102, 126],
        30: [6, 26, 52, 78, 104, 130],
        31: [6, 30, 56, 82, 108, 134],
        32: [6, 34, 60, 86, 112, 138],
        33: [6, 30, 58, 86, 114, 142],
        34: [6, 34, 62, 90, 118, 146],
        35: [6, 30, 54, 78, 102, 126, 150],
        36: [6, 24, 50, 76, 102, 128, 154],
        37: [6, 28, 54, 80, 106, 132, 158],
        38: [6, 32, 58, 84, 110, 136, 162],
        39: [6, 26, 54, 82, 110, 138, 166],
        40: [6, 30, 58, 86, 114, 142, 170],
    }

    // 添加定位
    addLocation() {
        // 获取当前版本的校正图形位置
        let location = Painter.LOCATION[this.version];
        // 添加寻象图形（包括分隔符，以寻象图形的左上角x,y开始）
        function setLocation(x, y, codeMap) {
            // 设置外边框
            for (let i = 0; i < 7; i++) {
                codeMap[y][x + i] = 1;
                codeMap[y + 6][x + i] = 1;
                codeMap[y + i][x] = 1;
                codeMap[y + i][x + 6] = 1;
            }
            // 设置内边框（3 * 3区域）
            for (let i = x + 2; i < x + 5; i++) {
                for (let j = y + 2; j < y + 5; j++) {
                    codeMap[j][i] = 1;
                }
            }
            // 其余的设置为0（原本位置也是0，为了是一次设置，将该方格所占用）
            for (let i = x + 1; i < x + 6; i++) {
                for (let j = y + 1; j < y + 6; j++) {
                    if (codeMap[j][i] !== 1) {
                        codeMap[j][i] = 0;
                    }
                }
            }
            // 以下皆为设置分隔符的位置
            if (y - 1 >= 0) {
                for (let i = 0; i < 8; i++) {
                    if (x + i < codeMap.length) {
                        codeMap[y - 1][x + i] = 0;
                    }
                }
            }
            if (x + 7 < codeMap.length) {
                for (let i = 0; i <= 8; i++) {
                    if (y + i < codeMap.length) {
                        codeMap[y + i][x + 7] = 0;
                    }
                }
            }
            if (y + 7 < codeMap.length) {
                for (let i = 0; i < 8; i++) {
                    if (x + i < codeMap.length) {
                        codeMap[y + 7][x + i] = 0;
                    }
                }
            }
            if (x - 1 >= 0) {
                for (let i = 0; i <= 8; i++) {
                    if (y + i < codeMap.length) {
                        codeMap[y + i][x - 1] = 0;
                    }
                }
            }
        }
        // 定位图案
        setLocation(0, 0, this._codeMap);                               // 左上
        setLocation(location[location.length - 1], 0, this._codeMap);   // 右上
        setLocation(0, location[location.length - 1], this._codeMap);   // 左下
    }

    // 添加对齐
    addAlignment() {
        // 版本2（不包括）以下无对齐元素
        if (this.version < 2) {
            return;
        }
        // 获取该版本的校正图形位置
        let location = Painter.LOCATION[this.version];
        // 设置校正图形（以中心点为x,y）
        function setLocation(x, y, codeMap) {
            // 设置外边框
            for (let i = -2; i < 3; i++) {
                codeMap[y - 2][x + i] = 1;
                codeMap[y + 2][x + i] = 1;
                codeMap[y + i][x - 2] = 1;
                codeMap[y + i][x + 2] = 1;
            }
            // 内边框
            codeMap[y][x] = 1;
            // 其余设置为0（原本位置也是0，为了是一次设置，将该方格所占用）
            for (let i = y - 1; i <= y + 1; i++) {
                for (let j = x - 1; j <= x + 1; j++) {
                    if (codeMap[i][j] !== 1) {
                        codeMap[i][j] = 0;
                    }
                }
            }
        }

        // 循环位置，如果不是左上、右上、左下，则设置校正图形
        for (let i = 0; i < location.length; i++) {
            for (let j = 0; j < location.length; j++) {
                if ((i === 0 && j === 0) || (i === 0 && j === location.length - 1) || (i === location.length - 1 && j === 0)) {
                    continue;
                }
                setLocation(location[i], location[j], this._codeMap);
            }
        }
    }

    // 添加时序图（定位图形）
    addTimeline() {
        // 获取当前版本的校正图形位置
        let location = Painter.LOCATION[this.version];
        // 设置定位图形
        for (let i = 7; i < location[location.length - 1]; i += 2) {
            // 黑白间隔
            this._codeMap[6][i] = 0;
            this._codeMap[6][i + 1] = 1;
            this._codeMap[i][6] = 0;
            this._codeMap[i + 1][6] = 1;
        }
    }
}

class MaskPattern {
    constructor(size) {
        this.size = size;
    }

    getMask(maskPatternReference) {
        let maskPattern = [];   // 掩膜
        // 根据编码获取条件
        let maskPatternFunction = {
            0: this.MaskPattern000(),
            1: this.MaskPattern001(),
            2: this.MaskPattern010(),
            3: this.MaskPattern011(),
            4: this.MaskPattern100(),
            5: this.MaskPattern101(),
            6: this.MaskPattern110(),
            7: this.MaskPattern111(),
        }
        // 根据条件获取掩膜
        for (let i = 0; i < this.size; i++) {
            maskPattern.push([]);
            for (let j = 0; j < this.size; j++) {
                maskPattern[i][j] = maskPatternFunction[maskPatternReference](i, j);
            }
        }
        return maskPattern;
    }

    MaskPattern000() {
        return (i, j) => {
            return (i + j) % 2 === 0;
        }
    }

    MaskPattern001() {
        return (i, j) => {
            return i % 2 === 0;
        }
    }

    MaskPattern010() {
        return (i, j) => {
            return j % 3 === 0;
        }
    }

    MaskPattern011() {
        return (i, j) => {
            return (i + j) % 3 === 0;
        }
    }

    MaskPattern100() {
        return (i, j) => {
            return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
        }
    }

    MaskPattern101() {
        return (i, j) => {
            return ((i * j) % 2) + ((i * j) % 3) === 0;
        }
    }

    MaskPattern110() {
        return (i, j) => {
            return (((i * j) % 2) + ((i * j) % 3)) % 2 === 0;
        }
    }

    MaskPattern111() {
        return (i, j) => {
            return (((i * j) % 3) + ((i + j) % 2)) % 2 === 0;
        }
    }
}

class Painter {
    // 添加格式信息（需要提供纠错等级和掩膜编码，默认为M和0）
    addFormatInfo(errorCorrectionLevel = "M", maskPatternReference = 0) {
        // 如果纠错等级不合法，则抛出错误
        if (errorCorrectionLevel !== "L" && errorCorrectionLevel !== "M" && errorCorrectionLevel !== "Q" && errorCorrectionLevel !== "H") {
            throw new Error("errorCorrectionLevel must be L, M, Q or H");
        }
        // 如果掩膜编码不合法，则抛出错误
        if (maskPatternReference < 0 || maskPatternReference > 7) {
            throw new Error("maskPatternReference must be between 0 and 7");
        }
        // 添加到实例对象上，后面需要用到
        this.errorCorrectionLevel = errorCorrectionLevel;
        this.maskPatternReference = maskPatternReference;
        // 纠错级别
        switch (errorCorrectionLevel) {
            case "L": errorCorrectionLevel = 0b01; break;
            case "M": errorCorrectionLevel = 0b00; break;
            case "Q": errorCorrectionLevel = 0b11; break;
            case "H": errorCorrectionLevel = 0b10; break;
        }
        // 数据位（纠错级别 + 掩膜编码）
        let dataBit = (errorCorrectionLevel << 3) | maskPatternReference;
        // BCH(15, 5)
        function BCH_15_To_5_Encode(data) {
            const g = 0x537;
            data <<= 10;    // 填充10个0
            let encode = data;  // 保留原始数据
            // 累除计算余数
            for (let i = 4; i >= 0; i--) {
                if ((data & (1 << (i + 10))) != 0) {
                    data ^= g << i;
                }
            }
            // 与原结果进行异或运算
            return encode ^ data;
        }
        // 纠错位（根据数据位计算BCH(15, 5)）
        let errorCorrectionBit = BCH_15_To_5_Encode(dataBit);
        // 15位异或101010000010010
        dataBit ^= 0b10101;
        errorCorrectionBit ^= 0b0000010010;
        // 有低到高存储位数据
        let formatInfo = [];
        // 添加纠错位
        for (let i = 0; i < 10; i++) {
            formatInfo.push((errorCorrectionBit & (1 << i)) !== 0 ? 1 : 0);
        }
        // 添加数据位
        for (let i = 0; i < 5; i++) {
            formatInfo.push((dataBit & (1 << i)) !== 0 ? 1 : 0);
        }

        // 添加15位信息（0对应位置0，低到高存储位数据）
        this._codeMap[0][8] = formatInfo[0];
        this._codeMap[1][8] = formatInfo[1];
        this._codeMap[2][8] = formatInfo[2];
        this._codeMap[3][8] = formatInfo[3];
        this._codeMap[4][8] = formatInfo[4];
        this._codeMap[5][8] = formatInfo[5];
        this._codeMap[7][8] = formatInfo[6];
        this._codeMap[8][8] = formatInfo[7];
        this._codeMap[8][7] = formatInfo[8];
        this._codeMap[8][5] = formatInfo[9];
        this._codeMap[8][4] = formatInfo[10];
        this._codeMap[8][3] = formatInfo[11];
        this._codeMap[8][2] = formatInfo[12];
        this._codeMap[8][1] = formatInfo[13];
        this._codeMap[8][0] = formatInfo[14];

        // 添加15位信息（0对应位置0，低到高存储位数据）
        for (let i = 1; i <= 8; i++) {
            this._codeMap[8][this.size - i] = formatInfo[i - 1];
        }
        for (let i = 0; i < 7; i++) {
            this._codeMap[this.size - 7 + i][8] = formatInfo[i + 8];
        }
        // 深色模块
        this._codeMap[this.size - 8][8] = 1;
    }
}

class Painter {
    // 添加版本信息（经过该步骤后将ONE_CHANGE设置为false，将不在记录写入情况）
    addVersionInfo() {
        // 版本7以下没有版本信息
        if (this.version < 7) {
            Painter.ONE_CHANGE = false;
            return;
        }
        // BCH(18, 6)，与BCH(15, 5)类似，其中g修改为0x1f25
        function BCH_18_To_6_Encode(data) {
            const g = 0x1f25;
            data <<= 12;
            let encode = data;
            for (let i = 5; i >= 0; i--) {
                if ((data & (1 << (i + 12))) != 0) {
                    data ^= g << i;
                }
            }
            return encode ^ data;
        }
        // 版本信息（6位数据位 + 12位纠错位）
        let versionInfoBit = (this.version << 12) | BCH_18_To_6_Encode(this.version);
        // 由低到高存储位数据
        let versionInfo = [];
        for (let i = 0; i < 18; i++) {
            versionInfo.push((versionInfoBit & (1 << i)) !== 0 ? 1 : 0);
        }
        // 填入版本信息（其中0对应位置0）
        for (let i = 0; i < 6; i++) {
            for (let j = 0; j < 3; j++) {
                this._codeMap[this.size - 11 + j][i] = versionInfo[i * 3 + j];
                this._codeMap[i][this.size - 11 + j] = versionInfo[i * 3 + j];
            }
        }
        Painter.ONE_CHANGE = false;
    }
}

class DataEncode {
    /**
     * 版本   | 数字模式 | 字母数字模式 | 8位字节模式 | 日本汉字模式 | 中国汉字模式
     *  1~9   |   10    |      9      |     8      |      8      |
     *  10~26 |   12    |      11     |     16     |      10     |
     *  27~40 |   14    |      13     |     16     |      12     |
     */
    static CHRE_COUNT_BITS = [
        [10, 9, 8, 8],
        [12, 11, 16, 10],
        [14, 13, 16, 12]
    ];
    /* 字母数字表格 */
    static LETTER_NUMBER_ENCODE_TABLE = {
        "0": 0,
        "1": 1,
        "2": 2,
        "3": 3,
        "4": 4,
        "5": 5,
        "6": 6,
        "7": 7,
        "8": 8,
        "9": 9,
        "A": 10,
        "B": 11,
        "C": 12,
        "D": 13,
        "E": 14,
        "F": 15,
        "G": 16,
        "H": 17,
        "I": 18,
        "J": 19,
        "K": 20,
        "L": 21,
        "M": 22,
        "N": 23,
        "O": 24,
        "P": 25,
        "Q": 26,
        "R": 27,
        "S": 28,
        "T": 29,
        "U": 30,
        "V": 31,
        "W": 32,
        "X": 33,
        "Y": 34,
        "Z": 35,
        " ": 36,
        "$": 37,
        "%": 38,
        "*": 39,
        "+": 40,
        "-": 41,
        ".": 42,
        "/": 43,
        ":": 44,
    }

    /**
     * ECI                  0b0111
     * 数字                 0b0001
     * 字母数字             0b0010
     * 8位字节              0b0100
     * 日本汉字             0b1000
     * 中国汉字             0b1101
     * 结构链接             0b0011
     * FNC1                 0b0101 (第一位置)
     *                      0b1001 (第二位置)
     * 终止符（信息结尾）    0b0000
     */
    /**
     * @param {Object} data 数据 
     * @param {number} version 版本
     * @param {number} mode 模式
     */
    static getDataEncode(data, version, mode) {
        let modeIndex = -1;     // 对应的模式下标
        let versionIndex = -1;  // 对应的版本下标
        // 根据表格设置
        switch (mode) {
            case 0b0001: modeIndex = 0; break;
            case 0b0010: modeIndex = 1; break;
            case 0b0100: modeIndex = 2; break;
            case 0b1000: modeIndex = 3; break;
        }
        if (version >= 1 && version <= 9) {
            versionIndex = 0;
        } else if (version >= 10 && version <= 26) {
            versionIndex = 1;
        } else if (version >= 27 && version <= 40) {
            versionIndex = 2;
        }
        if (modeIndex == -1) {
            throw new Error("没有找到对应的模式");
        }
        if (versionIndex == -1) {
            throw new Error("没有找到对应的版本");
        }
        // 数字编码
        let dataArray = [];
        let dataBitArray = [];
        // 添加编码模式
        for (let i = 3; i >= 0; i--) {
            dataBitArray.push((mode >> i) & 1);
        }
        // 添加长度
        let charCountLength = DataEncode.CHRE_COUNT_BITS[versionIndex][modeIndex];
        let dataLength = data.length;
        for (let i = charCountLength - 1; i >= 0; i--) {
            dataBitArray.push((dataLength >> i) & 1);
        }

        // 根据模式调用不同的方法
        switch (mode) {
            case 0b0001: DataEncode.numberEncode(data, dataBitArray); break;
            case 0b0010: DataEncode.letterNumberEncode(data, dataBitArray); break;
            case 0b0100: DataEncode.byteEncode(data, dataBitArray); break;
            case 0b1000: DataEncode.japaneseEncode(data, dataBitArray); break;
        }


        // 添加结束符
        for (let i = 0; i < 4; i++) {
            dataBitArray.push(0);
        }

        // 补为长度为8的倍数
        while (dataBitArray.length % 8 != 0) {
            dataBitArray.push(0);
        }

        // 将数据转换为8位二进制数组
        let i = 0, end = dataBitArray.length;
        while (i < end) {
            let value = 0;
            for (let j = 0; j < 8; j++) {
                value += dataBitArray[i + j] << (7 - j);
            }
            dataArray.push(value);
            i += 8;
        }

        return dataArray;
    }

    /**
     * 数字编码
     * @param {string} data 数据
     * @param {Array} dataBitArray 数据位数组
     */
    static numberEncode(data, dataBitArray) {
        // 每3个一位
        let charArray = [];
        for (let i = 0; i < data.length; i += 3) {
            charArray.push(data.substring(i, i + 3));
        }
        // 添加数据
        for (let i = 0; i < charArray.length; i++) {
            let num = Number(charArray[i]);
            let bitLength = 0;
            if (charArray[i].length === 3) {
                bitLength = 10;
            } else if (charArray[i].length === 2) {
                bitLength = 7;
            } else if (charArray[i].length === 1) {
                bitLength = 4;
            }

            for (let i = bitLength - 1; i >= 0; i--) {
                dataBitArray.push((num >> i) & 1);
            }
        }
        return dataBitArray;
    }

    /**
     * 字母数字编码
     * @param {*} data 
     * @param {*} dataBitArray 
     */
    static letterNumberEncode(data, dataBitArray) {
        let charArray = [];
        // 每两位一组
        for (let i = 0; i < data.length; i += 2) {
            charArray.push(data.substring(i, i + 2));
        }
        // 查表添加数据
        for (let i = 0; i < charArray.length; i++) {
            let num, bitLength;
            if (charArray[i].length == 2) {
                num = DataEncode.LETTER_NUMBER_ENCODE_TABLE[charArray[i][0]] * 45 + DataEncode.LETTER_NUMBER_ENCODE_TABLE[charArray[i][1]];
                bitLength = 11;
            } else {
                num = DataEncode.LETTER_NUMBER_ENCODE_TABLE[charArray[i][0]];
                bitLength = 6;
            }
            for (let i = bitLength - 1; i >= 0; i--) {
                dataBitArray.push((num >> i) & 1);
            }
        }
        return dataBitArray;
    }

    /**
     * 8位字节编码
     * @param {*} data 
     * @param {*} dataBitArray 
     */
    static byteEncode(data, dataBitArray) {
        // 根据字符编码添加数据
        for (let i = 0; i < data.length; i++) {
            let num = data.charCodeAt(i);
            for (let j = 7; j >= 0; j--) {
                dataBitArray.push((num >> j) & 1);
            }
        }
    }

    /**
     * 日本汉字编码
     * @param {*} data 
     * @param {*} dataBitArray 
     */
    static japaneseEncode(data, dataBitArray) {
        throw new Error("暂不支持");
    }
}

class PaddingData {
    // 版本号和纠错等级对应的数据长度
    static PADDING_DATA = {
        "1-L": 152,
        "1-M": 128,
        "1-Q": 104,
        "1-H": 72,
        "2-L": 272,
        "2-M": 224,
        "2-Q": 176,
        "2-H": 128,
        "3-L": 440,
        "3-M": 352,
        "3-Q": 272,
        "3-H": 208,
        "4-L": 640,
        "4-M": 512,
        "4-Q": 384,
        "4-H": 288,
        "5-L": 864,
        "5-M": 688,
        "5-Q": 496,
        "5-H": 368,
        "6-L": 1088,
        "6-M": 864,
        "6-Q": 608,
        "6-H": 480,
        "7-L": 1248,
        "7-M": 992,
        "7-Q": 704,
        "7-H": 528,
        "8-L": 1552,
        "8-M": 1232,
        "8-Q": 880,
        "8-H": 688,
        "9-L": 1856,
        "9-M": 1456,
        "9-Q": 1056,
        "9-H": 800,
        "10-L": 2192,
        "10-M": 1728,
        "10-Q": 1232,
        "10-H": 976,
        "11-L": 2592,
        "11-M": 2032,
        "11-Q": 1440,
        "11-H": 1120,
        "12-L": 2960,
        "12-M": 2320,
        "12-Q": 1648,
        "12-H": 1264,
        "13-L": 3424,
        "13-M": 2672,
        "13-Q": 1952,
        "13-H": 1440,
        "14-L": 3688,
        "14-M": 3920,
        "14-Q": 2088,
        "14-H": 1576,
        "15-L": 4184,
        "15-M": 3320,
        "15-Q": 2360,
        "15-H": 1784,
        "16-L": 4712,
        "16-M": 3624,
        "16-Q": 2600,
        "16-H": 2024,
        "17-L": 5176,
        "17-M": 4056,
        "17-Q": 2936,
        "17-H": 2264,
        "18-L": 5768,
        "18-M": 4504,
        "18-Q": 3176,
        "18-H": 2504,
        "19-L": 6360,
        "19-M": 5016,
        "19-Q": 3560,
        "19-H": 2728,
        "20-L": 6888,
        "20-M": 5352,
        "20-Q": 3880,
        "20-H": 3080,
        "21-L": 7456,
        "21-M": 5712,
        "21-Q": 4096,
        "21-H": 3248,
        "22-L": 8048,
        "22-M": 6256,
        "22-Q": 4544,
        "22-H": 3536,
        "23-L": 8752,
        "23-M": 6880,
        "23-Q": 4912,
        "23-H": 3712,
        "24-L": 9392,
        "24-M": 7312,
        "24-Q": 5312,
        "24-H": 4112,
        "25-L": 10208,
        "25-M": 8000,
        "25-Q": 5744,
        "25-H": 4304,
        "26-L": 10960,
        "26-M": 8496,
        "26-Q": 6032,
        "26-H": 4768,
        "27-L": 11744,
        "27-M": 9024,
        "27-Q": 6464,
        "27-H": 5024,
        "28-L": 12248,
        "28-M": 9544,
        "28-Q": 6968,
        "28-H": 5288,
        "29-L": 13048,
        "29-M": 10136,
        "29-Q": 7288,
        "29-H": 5608,
        "30-L": 13880,
        "30-M": 10984,
        "30-Q": 7880,
        "30-H": 5960,
        "31-L": 14744,
        "31-M": 11640,
        "31-Q": 8264,
        "31-H": 6344,
        "32-L": 15640,
        "32-M": 12328,
        "32-Q": 8920,
        "32-H": 6760,
        "33-L": 16568,
        "33-M": 13048,
        "33-Q": 9368,
        "33-H": 7208,
        "34-L": 17528,
        "34-M": 13800,
        "34-Q": 9848,
        "34-H": 7688,
        "35-L": 18448,
        "35-M": 14496,
        "35-Q": 10288,
        "35-H": 7888,
        "36-L": 19472,
        "36-M": 15312,
        "36-Q": 10832,
        "36-H": 8432,
        "37-L": 20528,
        "37-M": 15936,
        "37-Q": 11408,
        "37-H": 8768,
        "38-L": 21616,
        "38-M": 16816,
        "38-Q": 12016,
        "38-H": 9136,
        "39-L": 22496,
        "39-M": 17728,
        "39-Q": 12656,
        "39-H": 9776,
        "40-L": 23648,
        "40-M": 18672,
        "40-Q": 13328,
        "40-H": 10208
    }

    static padding(data, version, errorCorrectionLevel) {
        // 根据版本号和纠错等级获取对应的数据长度
        let paddingData = PaddingData.PADDING_DATA[`${version}-${errorCorrectionLevel}`] / 8;
        let dataLength = data.length;   // 数据长度
        // 填充字符
        const a = 0b11101100;
        const b = 0b00010001;
        // 填充到 paddingData 位
        while (dataLength < paddingData) {
            // 填充a
            data.push(a);
            dataLength += 1;
            // 如果长度够了则退出
            if (dataLength >= paddingData) {
                break;
            }
            // 填充b
            data.push(b);
            dataLength += 1;
        }
        return data;
    }
}