uni-app实现一维码，二维码生成

在项目开发过程中，我在网上查找相关生成码的方法，

第一种：

https://blog.csdn.net/m0_58849641/article/details/124901408

第二种：

https://blog.csdn.net/qq826303461/article/details/117320633

第三种：

https://blog.csdn.net/qq_41742576/article/details/121701987

第四种：

https://ext.dcloud.net.cn/plugin?id=406

一共采用了以上四种方式，但无奈怎么都渲染不出一维码，
最后采用的方法借鉴路径：
https://meet-ui.com/#/plugs/web/barcode/?id=%e6%9d%a1%e5%bd%a2%e7%a0%81

1.将w-code放入components文件夹下

2.文件内容分别是
helper.js文件内容：

// 判断arr是否为一个数组，返回一个bool值
function isArray(arr) {
   
  return Object.prototype.toString.call(arr) === '[object Array]';
}
// 深度克隆
function deepClone(obj) {
   
  // 对常见的“非”值，直接返回原来值
  if ([null, undefined, NaN, false].includes(obj)) return obj;
  if (typeof obj !== 'object' && typeof obj !== 'function') {
   
    //原始类型直接返回
    return obj;
  }
  var o = isArray(obj) ? [] : {
   };
  for (let i in obj) {
   
    if (obj.hasOwnProperty(i)) {
   
      o[i] = typeof obj[i] === 'object' ? deepClone(obj[i]) : obj[i];
    }
  }
  return o;
}

function getUUid(len = 32, firstU = true, radix = null) {
   
  let chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
  let uuid = [];
  radix = radix || chars.length;

  if (len) {
   
    // 如果指定uuid长度,只是取随机的字符,0|x为位运算,能去掉x的小数位,返回整数位
    for (let i = 0; i < len; i++) uuid[i] = chars[0 | (Math.random() * radix)];
  } else {
   
    let r;
    // rfc4122标准要求返回的uuid中,某些位为固定的字符
    uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
    uuid[14] = '4';

    for (let i = 0; i < 36; i++) {
   
      if (!uuid[i]) {
   
        r = 0 | (Math.random() * 16);
        uuid[i] = chars[i == 19 ? (r & 0x3) | 0x8 : r];
      }
    }
  }
  // 移除第一个字符,并用u替代,因为第一个字符为数值时,该guuid不能用作id或者class
  if (firstU) {
   
    uuid.shift();
    return 'u' + uuid.join('');
  } else {
   
    return uuid.join('');
  }
}
function platform() {
   
  let val = null;
  // #ifdef  VUE3
  val = 'VUE3';
  // #endif
  // #ifdef  APP-PLUS
  val = 'APP-PLUS';
  // #endif
  // #ifdef  APP-PLUS-NVUE || APP-NVUE
  val = 'NVUE';
  // #endif
  //#ifdef  H5
  val = 'H5';
  //#endif
  // #ifdef  MP-WEIXIN
  val = 'MP-WEIXIN';
  // #endif
  // #ifdef  MP-ALIPAY
  val = 'MP-ALIPAY';
  // #endif
  // #ifdef  MP-BAIDU
  val = 'MP-BAIDU';
  // #endif
  // #ifdef  MP-TOUTIAO
  val = 'MP-TOUTIAO';
  // #endif
  // #ifdef  MP-LARK
  val = 'MP-LARK';
  // #endif
  // #ifdef  MP-TOUTIAO
  val = 'MP-QQ';
  // #endif
  // #ifdef  MP-KUAISHOU
  val = 'MP-KUAISHOU';
  // #endif
  // #ifdef  MP-360
  val = 'MP-360';
  // #endif
  // #ifdef  QUICKAPP-WEBVIEW
  val = 'QUICKAPP-WEBVIEW';
  // #endif
  // #ifdef  QUICKAPP-WEBVIEW-UNION
  val = 'QUICKAPP-WEBVIEW-UNION';
  // #endif
  // #ifdef  QUICKAPP-WEBVIEW-HUAWEI
  val = 'QUICKAPP-WEBVIEW-HUAWEI';
  // #endif

  return val;
}
export {
    deepClone, getUUid, platform };

index.js

var __assign = function () {
   
  return (__assign =
    Object.assign ||
    function (t) {
   
      for (var e, i = 1, r = arguments.length; i < r; i++)
        for (var o in (e = arguments[i]))
          Object.prototype.hasOwnProperty.call(e, o) && (t[o] = e[o]);
      return t;
    }).apply(this, arguments);
};
function __awaiter(t, n, h, a) {
   
  return new (h = h || Promise)(function (i, e) {
   
    function r(t) {
   
      try {
   
        s(a.next(t));
      } catch (t) {
   
        e(t);
      }
    }
    function o(t) {
   
      try {
   
        s(a.throw(t));
      } catch (t) {
   
        e(t);
      }
    }
    function s(t) {
   
      var e;
      t.done
        ? i(t.value)
        : ((e = t.value) instanceof h
            ? e
            : new h(function (t) {
                t(e);
              })
          ).then(r, o);
    }
    s((a = a.apply(t, n || [])).next());
  });
}
function __generator(i, r) {
   
  var o,
    s,
    n,
    h = {
   
      label: 0,
      sent: function () {
   
        if (1 & n[0]) throw n[1];
        return n[1];
      },
      trys: [],
      ops: []
    },
    t = {
    next: e(0), throw: e(1), return: e(2) };
  return (
    'function' == typeof Symbol &&
      (t[Symbol.iterator] = function () {
   
        return this;
      }),
    t
  );
  function e(e) {
   
    return function (t) {
   
      return (function (e) {
   
        if (o) throw new TypeError('Generator is already executing.');
        for (; h; )
          try {
   
            if (
              ((o = 1),
              s &&
                (n =
                  2 & e[0]
                    ? s.return
                    : e[0]
                    ? s.throw || ((n = s.return) && n.call(s), 0)
                    : s.next) &&
                !(n = n.call(s, e[1])).done)
            )
              return n;
            switch (((s = 0), (e = n ? [2 & e[0], n.value] : e)[0])) {
   
              case 0:
              case 1:
                n = e;
                break;
              case 4:
                return h.label++, {
    value: e[1], done: !1 };
              case 5:
                h.label++, (s = e[1]), (e = [0]);
                continue;
              case 7:
                (e = h.ops.pop()), h.trys.pop();
                continue;
              default:
                if (
                  !(n = 0 < (n = h.trys).length && n[n.length - 1]) &&
                  (6 === e[0] || 2 === e[0])
                ) {
   
                  h = 0;
                  continue;
                }
                if (3 === e[0] && (!n || (e[1] > n[0] && e[1] < n[3]))) {
   
                  h.label = e[1];
                  break;
                }
                if (6 === e[0] && h.label < n[1]) {
   
                  (h.label = n[1]), (n = e);
                  break;
                }
                if (n && h.label < n[2]) {
   
                  (h.label = n[2]), h.ops.push(e);
                  break;
                }
                n[2] && h.ops.pop(), h.trys.pop();
                continue;
            }
            e = r.call(i, h);
          } catch (t) {
   
            (e = [6, t]), (s = 0);
          } finally {
   
            o = n = 0;
          }
        if (5 & e[0]) throw e[1];
        return {
    value: e[0] ? e[1] : void 0, done: !0 };
      })([e, t]);
    };
  }
}
var ADELTA = [
    0, 11, 15, 19, 23, 27, 31, 16, 18, 20, 22, 24, 26, 28, 20, 22, 24, 24, 26, 28, 28, 22, 24, 24,
    26, 26, 28, 28, 24, 24, 26, 26, 26, 28, 28, 24, 26, 26, 26, 28, 28
  ],
  VPAT = [
    3220, 1468, 2713, 1235, 3062, 1890, 2119, 1549, 2344, 2936, 1117, 2583, 1330, 2470, 1667, 2249,
    2028, 3780, 481, 4011, 142, 3098, 831, 3445, 592, 2517, 1776, 2234, 1951, 2827, 1070, 2660,
    1345, 3177
  ],
  fmtword = [
    30660, 29427, 32170, 30877, 26159, 25368, 27713, 26998, 21522, 20773, 24188, 23371, 17913,
    16590, 20375, 19104, 13663, 12392, 16177, 14854, 9396, 8579, 11994, 11245, 5769, 5054, 7399,
    6608, 1890, 597, 3340, 2107
  ],
  ECBLOCKS = [
    1, 0, 19, 7, 1, 0, 16, 10, 1, 0, 13, 13, 1, 0, 9, 17, 1, 0, 34, 10, 1, 0, 28, 16, 1, 0, 22, 22,
    1, 0, 16, 28, 1, 0, 55, 15, 1, 0, 44, 26, 2, 0, 17, 18, 2, 0, 13, 22, 1, 0, 80, 20, 2, 0, 32,
    18, 2, 0, 24, 26, 4, 0, 9, 16, 1, 0, 108, 26, 2, 0, 43, 24, 2, 2, 15, 18, 2, 2, 11, 22, 2, 0,
    68, 18, 4, 0, 27, 16, 4, 0, 19, 24, 4, 0, 15, 28, 2, 0, 78, 20, 4, 0, 31, 18, 2, 4, 14, 18, 4,
    1, 13, 26, 2, 0, 97, 24, 2, 2, 38, 22, 4, 2, 18, 22, 4, 2, 14, 26, 2, 0, 116, 30, 3, 2, 36, 22,
    4, 4, 16, 20, 4, 4, 12, 24, 2, 2, 68, 18, 4, 1, 43, 26, 6, 2, 19, 24, 6, 2, 15, 28, 4, 0, 81,
    20, 1, 4, 50, 30, 4, 4, 22, 28, 3, 8, 12, 24, 2, 2, 92, 24, 6, 2, 36, 22, 4, 6, 20, 26, 7, 4,
    14, 28, 4, 0, 107, 26, 8, 1, 37, 22, 8, 4, 20, 24, 12, 4, 11, 22, 3, 1, 115, 30, 4, 5, 40, 24,
    11, 5, 16, 20, 11, 5, 12, 24, 5, 1, 87, 22, 5, 5, 41, 24, 5, 7, 24, 30, 11, 7, 12, 24, 5, 1, 98,
    24, 7, 3, 45, 28, 15, 2, 19, 24, 3, 13, 15, 30, 1, 5, 107, 28, 10, 1, 46, 28, 1, 15, 22, 28, 2,
    17, 14, 28, 5, 1, 120, 30, 9, 4, 43, 26, 17, 1, 22, 28, 2, 19, 14, 28, 3, 4, 113, 28, 3, 11, 44,
    26, 17, 4, 21, 26, 9, 16, 13, 26, 3, 5, 107, 28, 3, 13, 41, 26, 15, 5, 24, 30, 15, 10, 15, 28,
    4, 4, 116, 28, 17, 0, 42, 26, 17, 6, 22, 28, 19, 6, 16, 30, 2, 7, 111, 28, 17, 0, 46, 28, 7, 16,
    24, 30, 34, 0, 13, 24, 4, 5, 121, 30, 4, 14, 47, 28, 11, 14, 24, 30, 16, 14, 15, 30, 6, 4, 117,
    30, 6, 14, 45, 28, 11, 16, 24, 30, 30, 2, 16, 30, 8, 4, 106, 26, 8, 13, 47, 28, 7, 22, 24, 30,
    22, 13, 15, 30, 10, 2, 114, 28, 19, 4, 46, 28, 28, 6, 22, 28, 33, 4, 16, 30, 8, 4, 122, 30, 22,
    3, 45, 28, 8, 26, 23, 30, 12, 28, 15, 30, 3, 10, 117, 30, 3, 23, 45, 28, 4, 31, 24, 30, 11, 31,
    15, 30, 7, 7, 116, 30, 21, 7, 45, 28, 1, 37, 23, 30, 19, 26, 15, 30, 5, 10, 115, 30, 19, 10, 47,
    28, 15, 25, 24, 30, 23, 25, 15, 30, 13, 3, 115, 30, 2, 29, 46, 28, 42, 1, 24, 30, 23, 28, 15,
    30, 17, 0, 115, 30, 10, 23, 46, 28, 10, 35, 24, 30, 19, 35, 15, 30, 17, 1, 115, 30, 14, 21, 46,
    28, 29, 19, 24, 30, 11, 46, 15, 30, 13, 6, 115, 30, 14, 23, 46, 28, 44, 7, 24, 30, 59, 1, 16,
    30, 12, 7, 121, 30, 12, 26, 47, 28, 39, 14, 24, 30, 22, 41, 15, 30, 6, 14, 121, 30, 6, 34, 47,
    28, 46, 10, 24, 30, 2, 64, 15, 30, 17, 4, 122, 30, 29, 14, 46, 28, 49, 10, 24, 30, 24, 46, 15,
    30, 4, 18, 122, 30, 13, 32, 46, 28, 48, 14, 24, 30, 42, 32, 15, 30, 20, 4, 117, 30, 40, 7, 47,
    28, 43, 22, 24, 30, 10, 67, 15, 30, 19, 6, 118, 30, 18, 31, 47, 28, 34, 34, 24, 30, 20, 61, 15,
    30
  ],
  GLOG = [
    255, 0, 1, 25, 2, 50, 26, 198, 3, 223, 51, 238, 27, 104, 199, 75, 4, 100, 224, 14, 52, 141, 239,
    129, 28, 193, 105, 248, 200, 8, 76, 113, 5, 138, 101, 47, 225, 36, 15, 33, 53, 147, 142, 218,
    240, 18, 130, 69, 29, 181, 194, 125, 106, 39, 249, 185, 201, 154, 9, 120, 77, 228, 114, 166, 6,
    191, 139, 98, 102, 221, 48, 253, 226, 152, 37, 179, 16, 145, 34, 136, 54, 208, 148, 206, 143,
    150, 219, 189, 241, 210, 19, 92, 131, 56, 70, 64, 30, 66, 182, 163, 195, 72, 126, 110, 107, 58,
    40, 84, 250, 133, 186, 61, 202, 94, 155, 159, 10, 21, 121, 43, 78, 212, 229, 172, 115, 243, 167,
    87, 7, 112, 192, 247, 140, 128, 99, 13, 103, 74, 222, 237, 49, 197, 254, 24, 227, 165, 153, 119,
    38, 184, 180, 124, 17, 68, 146, 217, 35, 32, 137, 46, 55, 63, 209, 91, 149, 188, 207, 205, 144,
    135, 151, 178, 220, 252, 190, 97, 242, 86, 211, 171, 20, 42, 93, 158, 132, 60, 57, 83, 71, 109,
    65, 162, 31, 45, 67, 216, 183, 123, 164, 118, 196, 23, 73, 236, 127, 12, 111, 246, 108, 161, 59,
    82, 41, 157, 85, 170, 251, 96, 134, 177, 187, 204, 62, 90, 203, 89, 95, 176, 156, 169, 160, 81,
    11, 245, 22, 235, 122, 117, 44, 215, 79, 174, 213, 233, 230, 231, 173, 232, 116, 214, 244, 234,
    168, 80, 88, 175
  ],
  GEXP = [
    1, 2, 4, 8, 16, 32, 64, 128, 29, 58, 116, 232, 205, 135, 19, 38, 76, 152, 45, 90, 180, 117, 234,
    201, 143, 3, 6, 12, 24, 48, 96, 192, 157, 39, 78, 156, 37, 74, 148, 53, 106, 212, 181, 119, 238,
    193, 159, 35, 70, 140, 5, 10, 20, 40, 80, 160, 93, 186, 105, 210, 185, 111, 222, 161, 95, 190,
    97, 194, 153, 47, 94, 188, 101, 202, 137, 15, 30, 60, 120, 240, 253, 231, 211, 187, 107, 214,
    177, 127, 254, 225, 223, 163, 91, 182, 113, 226, 217, 175, 67, 134, 17, 34, 68, 136, 13, 26, 52,
    104, 208, 189, 103, 206, 129, 31, 62, 124, 248, 237, 199, 147, 59, 118, 236, 197, 151, 51, 102,
    204, 133, 23, 46, 92, 184, 109, 218, 169, 79, 158, 33, 66, 132, 21, 42, 84, 168, 77, 154, 41,
    82, 164, 85, 170, 73, 146, 57, 114, 228, 213, 183, 115, 230, 209, 191, 99, 198, 145, 63, 126,
    252, 229, 215, 179, 123, 246, 241, 255, 227, 219, 171, 75, 150, 49, 98, 196, 149, 55, 110, 220,
    165, 87, 174, 65, 130, 25, 50, 100, 200, 141, 7, 14, 28, 56, 112, 224, 221, 167, 83, 166, 81,
    162, 89, 178, 121, 242, 249, 239, 195, 155, 43, 86, 172, 69, 138, 9, 18, 36, 72, 144, 61, 122,
    244, 245, 247, 243, 251, 235, 203, 139, 11, 22, 44, 88, 176, 125, 250, 233, 207, 131, 27, 54,
    108, 216, 173, 71, 142, 0
  ],
  PATTERNS = [
    [2, 1, 2, 2, 2, 2, 0, 0],
    [2, 2, 2, 1, 2, 2, 0, 0],
    [