在小程序中的使用:

utils文件夹下 barcode.js 粘粘以下代码

var CHAR_TILDE = 126
var CODE_FNC1 = 102 var SET_STARTA = 103
var SET_STARTB = 104
var SET_STARTC = 105
var SET_SHIFT = 98
var SET_CODEA = 101
var SET_CODEB = 100
var SET_STOP = 106 var REPLACE_CODES = {
CHAR_TILDE: CODE_FNC1 // ~ corresponds to FNC1 in GS1-128 standard
} var CODESET = {
ANY: 1,
AB: 2,
A: 3,
B: 4,
C: 5
} function getBytes (str) {
var bytes = []
for (var i = 0; i < str.length; i++) {
bytes.push(str.charCodeAt(i))
}
return bytes
} exports.code128 = function (ctx, text, width, height) {
width = parseInt(width) height = parseInt(height) var codes = stringToCode128(text) var g = new Graphics(ctx, width, height) var barWeight = g.area.width / ((codes.length - 3) * 11 + 35) var x = g.area.left
var y = g.area.top
for (var i = 0; i < codes.length; i++) {
var c = codes[i]
// two bars at a time: 1 black and 1 white
for (var bar = 0; bar < 8; bar += 2) {
var barW = PATTERNS[c][bar] * barWeight
// var barH = height - y - this.border;
var barH = height - y
var spcW = PATTERNS[c][bar + 1] * barWeight // no need to draw if 0 width
if (barW > 0) {
g.fillFgRect(x, y, barW, barH)
} x += barW + spcW
}
} ctx.draw()
} function stringToCode128 (text) {
var barc = {
currcs: CODESET.C
} var bytes = getBytes(text)
// decide starting codeset
var index = bytes[0] === CHAR_TILDE ? 1 : 0 var csa1 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB
var csa2 = bytes.length > 0 ? codeSetAllowedFor(bytes[index++]) : CODESET.AB
barc.currcs = getBestStartSet(csa1, csa2)
barc.currcs = perhapsCodeC(bytes, barc.currcs) // if no codeset changes this will end up with bytes.length+3
// start, checksum and stop
var codes = [] switch (barc.currcs) {
case CODESET.A:
codes.push(SET_STARTA)
break
case CODESET.B:
codes.push(SET_STARTB)
break
default:
codes.push(SET_STARTC)
break
} for (var i = 0; i < bytes.length; i++) {
var b1 = bytes[i] // get the first of a pair
// should we translate/replace
if (b1 in REPLACE_CODES) {
codes.push(REPLACE_CODES[b1])
i++ // jump to next
b1 = bytes[i]
} // get the next in the pair if possible
var b2 = bytes.length > (i + 1) ? bytes[i + 1] : -1 codes = codes.concat(codesForChar(b1, b2, barc.currcs))
// code C takes 2 chars each time
if (barc.currcs === CODESET.C) i++
} // calculate checksum according to Code 128 standards
var checksum = codes[0]
for (var weight = 1; weight < codes.length; weight++) {
checksum += (weight * codes[weight])
}
codes.push(checksum % 103) codes.push(SET_STOP) // encoding should now be complete
return codes function getBestStartSet (csa1, csa2) {
// tries to figure out the best codeset
// to start with to get the most compact code
var vote = 0
vote += csa1 === CODESET.A ? 1 : 0
vote += csa1 === CODESET.B ? -1 : 0
vote += csa2 === CODESET.A ? 1 : 0
vote += csa2 === CODESET.B ? -1 : 0
// tie goes to B due to my own predudices
return vote > 0 ? CODESET.A : CODESET.B
} function perhapsCodeC (bytes, codeset) {
for (var i = 0; i < bytes.length; i++) {
var b = bytes[i]
if ((b < 48 || b > 57) && b !== CHAR_TILDE) { return codeset }
}
return CODESET.C
} // chr1 is current byte
// chr2 is the next byte to process. looks ahead.
function codesForChar (chr1, chr2, currcs) {
var result = []
var shifter = -1 if (charCompatible(chr1, currcs)) {
if (currcs === CODESET.C) {
if (chr2 === -1) {
shifter = SET_CODEB
currcs = CODESET.B
} else if ((chr2 !== -1) && !charCompatible(chr2, currcs)) {
// need to check ahead as well
if (charCompatible(chr2, CODESET.A)) {
shifter = SET_CODEA
currcs = CODESET.A
} else {
shifter = SET_CODEB
currcs = CODESET.B
}
}
}
} else {
// if there is a next char AND that next char is also not compatible
if ((chr2 !== -1) && !charCompatible(chr2, currcs)) {
// need to switch code sets
switch (currcs) {
case CODESET.A:
shifter = SET_CODEB
currcs = CODESET.B
break
case CODESET.B:
shifter = SET_CODEA
currcs = CODESET.A
break
}
} else {
// no need to shift code sets, a temporary SHIFT will suffice
shifter = SET_SHIFT
}
} // ok some type of shift is nessecary
if (shifter !== -1) {
result.push(shifter)
result.push(codeValue(chr1))
} else {
if (currcs === CODESET.C) {
// include next as well
result.push(codeValue(chr1, chr2))
} else {
result.push(codeValue(chr1))
}
}
barc.currcs = currcs return result
}
} // reduce the ascii code to fit into the Code128 char table
function codeValue (chr1, chr2) {
if (typeof chr2 === 'undefined') {
return chr1 >= 32 ? chr1 - 32 : chr1 + 64
} else {
return parseInt(String.fromCharCode(chr1) + String.fromCharCode(chr2))
}
} function charCompatible (chr, codeset) {
var csa = codeSetAllowedFor(chr)
if (csa === CODESET.ANY) return true
// if we need to change from current
if (csa === CODESET.AB) return true
if (csa === CODESET.A && codeset === CODESET.A) return true
if (csa === CODESET.B && codeset === CODESET.B) return true
return false
} function codeSetAllowedFor (chr) {
if (chr >= 48 && chr <= 57) {
// 0-9
return CODESET.ANY
} else if (chr >= 32 && chr <= 95) {
// 0-9 A-Z
return CODESET.AB
} else {
// if non printable
return chr < 32 ? CODESET.A : CODESET.B
}
} var Graphics = function (ctx, width, height) {
this.width = width
this.height = height
this.quiet = Math.round(this.width / 40) this.border_size = 0
this.padding_width = 0 this.area = {
width: width - this.padding_width * 2 - this.quiet * 2,
height: height - this.border_size * 2,
top: this.border_size - 4,
left: this.padding_width + this.quiet
} this.ctx = ctx
this.fg = '#000000'
this.bg = '#ffffff' // fill background
this.fillBgRect(0, 0, width, height) // fill center to create border
this.fillBgRect(0, this.border_size, width, height - this.border_size * 2)
} // use native color
Graphics.prototype._fillRect = function (x, y, width, height, color) {
this.ctx.setFillStyle(color)
this.ctx.fillRect(x, y, width, height)
} Graphics.prototype.fillFgRect = function (x, y, width, height) {
this._fillRect(x, y, width, height, this.fg)
} Graphics.prototype.fillBgRect = function (x, y, width, height) {
this._fillRect(x, y, width, height, this.bg)
} var PATTERNS = [
[2, 1, 2, 2, 2, 2, 0, 0], //
[2, 2, 2, 1, 2, 2, 0, 0], //
[2, 2, 2, 2, 2, 1, 0, 0], //
[1, 2, 1, 2, 2, 3, 0, 0], //
[1, 2, 1, 3, 2, 2, 0, 0], //
[1, 3, 1, 2, 2, 2, 0, 0], //
[1, 2, 2, 2, 1, 3, 0, 0], //
[1, 2, 2, 3, 1, 2, 0, 0], //
[1, 3, 2, 2, 1, 2, 0, 0], //
[2, 2, 1, 2, 1, 3, 0, 0], //
[2, 2, 1, 3, 1, 2, 0, 0], //
[2, 3, 1, 2, 1, 2, 0, 0], //
[1, 1, 2, 2, 3, 2, 0, 0], //
[1, 2, 2, 1, 3, 2, 0, 0], //
[1, 2, 2, 2, 3, 1, 0, 0], //
[1, 1, 3, 2, 2, 2, 0, 0], //
[1, 2, 3, 1, 2, 2, 0, 0], //
[1, 2, 3, 2, 2, 1, 0, 0], //
[2, 2, 3, 2, 1, 1, 0, 0], //
[2, 2, 1, 1, 3, 2, 0, 0], //
[2, 2, 1, 2, 3, 1, 0, 0], //
[2, 1, 3, 2, 1, 2, 0, 0], //
[2, 2, 3, 1, 1, 2, 0, 0], //
[3, 1, 2, 1, 3, 1, 0, 0], //
[3, 1, 1, 2, 2, 2, 0, 0], //
[3, 2, 1, 1, 2, 2, 0, 0], //
[3, 2, 1, 2, 2, 1, 0, 0], //
[3, 1, 2, 2, 1, 2, 0, 0], //
[3, 2, 2, 1, 1, 2, 0, 0], //
[3, 2, 2, 2, 1, 1, 0, 0], //
[2, 1, 2, 1, 2, 3, 0, 0], //
[2, 1, 2, 3, 2, 1, 0, 0], //
[2, 3, 2, 1, 2, 1, 0, 0], //
[1, 1, 1, 3, 2, 3, 0, 0], //
[1, 3, 1, 1, 2, 3, 0, 0], //
[1, 3, 1, 3, 2, 1, 0, 0], //
[1, 1, 2, 3, 1, 3, 0, 0], //
[1, 3, 2, 1, 1, 3, 0, 0], //
[1, 3, 2, 3, 1, 1, 0, 0], //
[2, 1, 1, 3, 1, 3, 0, 0], //
[2, 3, 1, 1, 1, 3, 0, 0], //
[2, 3, 1, 3, 1, 1, 0, 0], //
[1, 1, 2, 1, 3, 3, 0, 0], //
[1, 1, 2, 3, 3, 1, 0, 0], //
[1, 3, 2, 1, 3, 1, 0, 0], //
[1, 1, 3, 1, 2, 3, 0, 0], //
[1, 1, 3, 3, 2, 1, 0, 0], //
[1, 3, 3, 1, 2, 1, 0, 0], //
[3, 1, 3, 1, 2, 1, 0, 0], //
[2, 1, 1, 3, 3, 1, 0, 0], //
[2, 3, 1, 1, 3, 1, 0, 0], //
[2, 1, 3, 1, 1, 3, 0, 0], //
[2, 1, 3, 3, 1, 1, 0, 0], //
[2, 1, 3, 1, 3, 1, 0, 0], //
[3, 1, 1, 1, 2, 3, 0, 0], //
[3, 1, 1, 3, 2, 1, 0, 0], //
[3, 3, 1, 1, 2, 1, 0, 0], //
[3, 1, 2, 1, 1, 3, 0, 0], //
[3, 1, 2, 3, 1, 1, 0, 0], //
[3, 3, 2, 1, 1, 1, 0, 0], //
[3, 1, 4, 1, 1, 1, 0, 0], //
[2, 2, 1, 4, 1, 1, 0, 0], //
[4, 3, 1, 1, 1, 1, 0, 0], //
[1, 1, 1, 2, 2, 4, 0, 0], //
[1, 1, 1, 4, 2, 2, 0, 0], //
[1, 2, 1, 1, 2, 4, 0, 0], //
[1, 2, 1, 4, 2, 1, 0, 0], //
[1, 4, 1, 1, 2, 2, 0, 0], //
[1, 4, 1, 2, 2, 1, 0, 0], //
[1, 1, 2, 2, 1, 4, 0, 0], //
[1, 1, 2, 4, 1, 2, 0, 0], //
[1, 2, 2, 1, 1, 4, 0, 0], //
[1, 2, 2, 4, 1, 1, 0, 0], //
[1, 4, 2, 1, 1, 2, 0, 0], //
[1, 4, 2, 2, 1, 1, 0, 0], //
[2, 4, 1, 2, 1, 1, 0, 0], //
[2, 2, 1, 1, 1, 4, 0, 0], //
[4, 1, 3, 1, 1, 1, 0, 0], //
[2, 4, 1, 1, 1, 2, 0, 0], //
[1, 3, 4, 1, 1, 1, 0, 0], //
[1, 1, 1, 2, 4, 2, 0, 0], //
[1, 2, 1, 1, 4, 2, 0, 0], //
[1, 2, 1, 2, 4, 1, 0, 0], //
[1, 1, 4, 2, 1, 2, 0, 0], //
[1, 2, 4, 1, 1, 2, 0, 0], //
[1, 2, 4, 2, 1, 1, 0, 0], //
[4, 1, 1, 2, 1, 2, 0, 0], //
[4, 2, 1, 1, 1, 2, 0, 0], //
[4, 2, 1, 2, 1, 1, 0, 0], //
[2, 1, 2, 1, 4, 1, 0, 0], //
[2, 1, 4, 1, 2, 1, 0, 0], //
[4, 1, 2, 1, 2, 1, 0, 0], //
[1, 1, 1, 1, 4, 3, 0, 0], //
[1, 1, 1, 3, 4, 1, 0, 0], //
[1, 3, 1, 1, 4, 1, 0, 0], //
[1, 1, 4, 1, 1, 3, 0, 0], //
[1, 1, 4, 3, 1, 1, 0, 0], //
[4, 1, 1, 1, 1, 3, 0, 0], //
[4, 1, 1, 3, 1, 1, 0, 0], //
[1, 1, 3, 1, 4, 1, 0, 0], //
[1, 1, 4, 1, 3, 1, 0, 0], //
[3, 1, 1, 1, 4, 1, 0, 0], //
[4, 1, 1, 1, 3, 1, 0, 0], //
[2, 1, 1, 4, 1, 2, 0, 0], //
[2, 1, 1, 2, 1, 4, 0, 0], //
[2, 1, 1, 2, 3, 2, 0, 0], //
[2, 3, 3, 1, 1, 1, 2, 0] //
]

utils文件夹下 index.js 放以下代码

var barcode = require('./barcode')
function convertlength (length) {
return Math.round(wx.getSystemInfoSync().windowWidth * length / 750)
}
function barc (id, code, width, height) {
barcode.code128(wx.createCanvasContext(id), code, convertlength(width), convertlength(height))
}
module.exports = {
barcode: barc
}

然后在小程序或mpvue中

<canvas canvas-id="barcode"></canvas>

var barcode = require('@/utils/index')

barcode.barcode('barcode', 'JsBarcode',  500, 350)

配置:

JsBarcode("#barcode", "123", {
format: "CODE39",//选择要使用的条形码类型
width:3,//设置条之间的宽度
height:100,//高度
displayValue:true,//是否在条形码下方显示文字
text:"456",//覆盖显示的文本
fontOptions:"bold italic",//使文字加粗体或变斜体
font:"fantasy",//设置文本的字体
textAlign:"left",//设置文本的水平对齐方式
textPosition:"top",//设置文本的垂直位置
textMargin:5,//设置条形码和文本之间的间距
fontSize:15,//设置文本的大小
background:"#eee",//设置条形码的背景
lineColor:"#2196f3",//设置条和文本的颜色。
margin:15//设置条形码周围的空白边距
});

官方:

https://github.com/lindell/JsBarcode/wiki/Options

参考: https://blog.csdn.net/huangpb123/article/details/82527344

如用到二维码:

下为:qrcode.js

(function () {
// alignment pattern
var adelta = [
0, 11, 15, 19, 23, 27, 31, // force 1 pat
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
] // version block
var vpat = [
0xc94, 0x5bc, 0xa99, 0x4d3, 0xbf6, 0x762, 0x847, 0x60d,
0x928, 0xb78, 0x45d, 0xa17, 0x532, 0x9a6, 0x683, 0x8c9,
0x7ec, 0xec4, 0x1e1, 0xfab, 0x08e, 0xc1a, 0x33f, 0xd75,
0x250, 0x9d5, 0x6f0, 0x8ba, 0x79f, 0xb0b, 0x42e, 0xa64,
0x541, 0xc69
] // final format bits with mask: level << 3 | mask
var fmtword = [
0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976, // L
0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0, // M
0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed, // Q
0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b // H
] // 4 per version: number of blocks 1,2; data width; ecc width
var eccblocks = [
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
] // Galois field log table
var glog = [
0xff, 0x00, 0x01, 0x19, 0x02, 0x32, 0x1a, 0xc6, 0x03, 0xdf, 0x33, 0xee, 0x1b, 0x68, 0xc7, 0x4b,
0x04, 0x64, 0xe0, 0x0e, 0x34, 0x8d, 0xef, 0x81, 0x1c, 0xc1, 0x69, 0xf8, 0xc8, 0x08, 0x4c, 0x71,
0x05, 0x8a, 0x65, 0x2f, 0xe1, 0x24, 0x0f, 0x21, 0x35, 0x93, 0x8e, 0xda, 0xf0, 0x12, 0x82, 0x45,
0x1d, 0xb5, 0xc2, 0x7d, 0x6a, 0x27, 0xf9, 0xb9, 0xc9, 0x9a, 0x09, 0x78, 0x4d, 0xe4, 0x72, 0xa6,
0x06, 0xbf, 0x8b, 0x62, 0x66, 0xdd, 0x30, 0xfd, 0xe2, 0x98, 0x25, 0xb3, 0x10, 0x91, 0x22, 0x88,
0x36, 0xd0, 0x94, 0xce, 0x8f, 0x96, 0xdb, 0xbd, 0xf1, 0xd2, 0x13, 0x5c, 0x83, 0x38, 0x46, 0x40,
0x1e, 0x42, 0xb6, 0xa3, 0xc3, 0x48, 0x7e, 0x6e, 0x6b, 0x3a, 0x28, 0x54, 0xfa, 0x85, 0xba, 0x3d,
0xca, 0x5e, 0x9b, 0x9f, 0x0a, 0x15, 0x79, 0x2b, 0x4e, 0xd4, 0xe5, 0xac, 0x73, 0xf3, 0xa7, 0x57,
0x07, 0x70, 0xc0, 0xf7, 0x8c, 0x80, 0x63, 0x0d, 0x67, 0x4a, 0xde, 0xed, 0x31, 0xc5, 0xfe, 0x18,
0xe3, 0xa5, 0x99, 0x77, 0x26, 0xb8, 0xb4, 0x7c, 0x11, 0x44, 0x92, 0xd9, 0x23, 0x20, 0x89, 0x2e,
0x37, 0x3f, 0xd1, 0x5b, 0x95, 0xbc, 0xcf, 0xcd, 0x90, 0x87, 0x97, 0xb2, 0xdc, 0xfc, 0xbe, 0x61,
0xf2, 0x56, 0xd3, 0xab, 0x14, 0x2a, 0x5d, 0x9e, 0x84, 0x3c, 0x39, 0x53, 0x47, 0x6d, 0x41, 0xa2,
0x1f, 0x2d, 0x43, 0xd8, 0xb7, 0x7b, 0xa4, 0x76, 0xc4, 0x17, 0x49, 0xec, 0x7f, 0x0c, 0x6f, 0xf6,
0x6c, 0xa1, 0x3b, 0x52, 0x29, 0x9d, 0x55, 0xaa, 0xfb, 0x60, 0x86, 0xb1, 0xbb, 0xcc, 0x3e, 0x5a,
0xcb, 0x59, 0x5f, 0xb0, 0x9c, 0xa9, 0xa0, 0x51, 0x0b, 0xf5, 0x16, 0xeb, 0x7a, 0x75, 0x2c, 0xd7,
0x4f, 0xae, 0xd5, 0xe9, 0xe6, 0xe7, 0xad, 0xe8, 0x74, 0xd6, 0xf4, 0xea, 0xa8, 0x50, 0x58, 0xaf
] // Galios field exponent table
var gexp = [
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1d, 0x3a, 0x74, 0xe8, 0xcd, 0x87, 0x13, 0x26,
0x4c, 0x98, 0x2d, 0x5a, 0xb4, 0x75, 0xea, 0xc9, 0x8f, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0,
0x9d, 0x27, 0x4e, 0x9c, 0x25, 0x4a, 0x94, 0x35, 0x6a, 0xd4, 0xb5, 0x77, 0xee, 0xc1, 0x9f, 0x23,
0x46, 0x8c, 0x05, 0x0a, 0x14, 0x28, 0x50, 0xa0, 0x5d, 0xba, 0x69, 0xd2, 0xb9, 0x6f, 0xde, 0xa1,
0x5f, 0xbe, 0x61, 0xc2, 0x99, 0x2f, 0x5e, 0xbc, 0x65, 0xca, 0x89, 0x0f, 0x1e, 0x3c, 0x78, 0xf0,
0xfd, 0xe7, 0xd3, 0xbb, 0x6b, 0xd6, 0xb1, 0x7f, 0xfe, 0xe1, 0xdf, 0xa3, 0x5b, 0xb6, 0x71, 0xe2,
0xd9, 0xaf, 0x43, 0x86, 0x11, 0x22, 0x44, 0x88, 0x0d, 0x1a, 0x34, 0x68, 0xd0, 0xbd, 0x67, 0xce,
0x81, 0x1f, 0x3e, 0x7c, 0xf8, 0xed, 0xc7, 0x93, 0x3b, 0x76, 0xec, 0xc5, 0x97, 0x33, 0x66, 0xcc,
0x85, 0x17, 0x2e, 0x5c, 0xb8, 0x6d, 0xda, 0xa9, 0x4f, 0x9e, 0x21, 0x42, 0x84, 0x15, 0x2a, 0x54,
0xa8, 0x4d, 0x9a, 0x29, 0x52, 0xa4, 0x55, 0xaa, 0x49, 0x92, 0x39, 0x72, 0xe4, 0xd5, 0xb7, 0x73,
0xe6, 0xd1, 0xbf, 0x63, 0xc6, 0x91, 0x3f, 0x7e, 0xfc, 0xe5, 0xd7, 0xb3, 0x7b, 0xf6, 0xf1, 0xff,
0xe3, 0xdb, 0xab, 0x4b, 0x96, 0x31, 0x62, 0xc4, 0x95, 0x37, 0x6e, 0xdc, 0xa5, 0x57, 0xae, 0x41,
0x82, 0x19, 0x32, 0x64, 0xc8, 0x8d, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xdd, 0xa7, 0x53, 0xa6,
0x51, 0xa2, 0x59, 0xb2, 0x79, 0xf2, 0xf9, 0xef, 0xc3, 0x9b, 0x2b, 0x56, 0xac, 0x45, 0x8a, 0x09,
0x12, 0x24, 0x48, 0x90, 0x3d, 0x7a, 0xf4, 0xf5, 0xf7, 0xf3, 0xfb, 0xeb, 0xcb, 0x8b, 0x0b, 0x16,
0x2c, 0x58, 0xb0, 0x7d, 0xfa, 0xe9, 0xcf, 0x83, 0x1b, 0x36, 0x6c, 0xd8, 0xad, 0x47, 0x8e, 0x00
] // Working buffers:
// data input and ecc append, image working buffer, fixed part of image, run lengths for badness
var strinbuf = []
var eccbuf = []
var qrframe = []
var framask = []
var rlens = []
// Control values - width is based on version, last 4 are from table.
var version, width, neccblk1, neccblk2, datablkw, eccblkwid
var ecclevel = 2
// set bit to indicate cell in qrframe is immutable. symmetric around diagonal
function setmask (x, y) {
var bt
if (x > y) {
bt = x
x = y
y = bt
}
// y*y = 1+3+5...
bt = y
bt *= y
bt += y
bt >>= 1
bt += x
framask[bt] = 1
} // enter alignment pattern - black to qrframe, white to mask (later black frame merged to mask)
function putalign (x, y) {
var j qrframe[x + width * y] = 1
for (j = -2; j < 2; j++) {
qrframe[(x + j) + width * (y - 2)] = 1
qrframe[(x - 2) + width * (y + j + 1)] = 1
qrframe[(x + 2) + width * (y + j)] = 1
qrframe[(x + j + 1) + width * (y + 2)] = 1
}
for (j = 0; j < 2; j++) {
setmask(x - 1, y + j)
setmask(x + 1, y - j)
setmask(x - j, y - 1)
setmask(x + j, y + 1)
}
} //= =======================================================================
// Reed Solomon error correction
// exponentiation mod N
function modnn (x) {
while (x >= 255) {
x -= 255
x = (x >> 8) + (x & 255)
}
return x
} var genpoly = [] // Calculate and append ECC data to data block. Block is in strinbuf, indexes to buffers given.
function appendrs (data, dlen, ecbuf, eclen) {
var i, j, fb for (i = 0; i < eclen; i++) { strinbuf[ecbuf + i] = 0 }
for (i = 0; i < dlen; i++) {
fb = glog[strinbuf[data + i] ^ strinbuf[ecbuf]]
if (fb !== 255) {
for (j = 1; j < eclen; j++) { strinbuf[ecbuf + j - 1] = strinbuf[ecbuf + j] ^ gexp[modnn(fb + genpoly[eclen - j])] }
} else {
for (j = ecbuf; j < ecbuf + eclen; j++) { strinbuf[j] = strinbuf[j + 1] }
}
strinbuf[ecbuf + eclen - 1] = fb === 255 ? 0 : gexp[modnn(fb + genpoly[0])]
}
} //= =======================================================================
// Frame data insert following the path rules // check mask - since symmetrical use half.
function ismasked (x, y) {
var bt
if (x > y) {
bt = x
x = y
y = bt
}
bt = y
bt += y * y
bt >>= 1
bt += x
return framask[bt]
} //= =======================================================================
// Apply the selected mask out of the 8.
function applymask (m) {
var x, y, r3x, r3y switch (m) {
case 0:
for (y = 0; y < width; y++) {
for (x = 0; x < width; x++) {
if (!((x + y) & 1) && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
case 1:
for (y = 0; y < width; y++) {
for (x = 0; x < width; x++) {
if (!(y & 1) && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
case 2:
for (y = 0; y < width; y++) {
for (r3x = 0, x = 0; x < width; x++, r3x++) {
if (r3x === 3) { r3x = 0 }
if (!r3x && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
case 3:
for (r3y = 0, y = 0; y < width; y++, r3y++) {
if (r3y === 3) { r3y = 0 }
for (r3x = r3y, x = 0; x < width; x++, r3x++) {
if (r3x === 3) { r3x = 0 }
if (!r3x && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
case 4:
for (y = 0; y < width; y++) {
for (r3x = 0, r3y = ((y >> 1) & 1), x = 0; x < width; x++, r3x++) {
if (r3x === 3) {
r3x = 0
r3y = !r3y
}
if (!r3y && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
case 5:
for (r3y = 0, y = 0; y < width; y++, r3y++) {
if (r3y === 3) { r3y = 0 }
for (r3x = 0, x = 0; x < width; x++, r3x++) {
if (r3x === 3) { r3x = 0 }
if (!((x & y & 1) + !(!r3x | !r3y)) && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
case 6:
for (r3y = 0, y = 0; y < width; y++, r3y++) {
if (r3y === 3) { r3y = 0 }
for (r3x = 0, x = 0; x < width; x++, r3x++) {
if (r3x === 3) { r3x = 0 }
if (!(((x & y & 1) + (r3x && (r3x === r3y))) & 1) && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
case 7:
for (r3y = 0, y = 0; y < width; y++, r3y++) {
if (r3y === 3) { r3y = 0 }
for (r3x = 0, x = 0; x < width; x++, r3x++) {
if (r3x === 3) { r3x = 0 }
if (!(((r3x && (r3x === r3y)) + ((x + y) & 1)) & 1) && !ismasked(x, y)) { qrframe[x + y * width] ^= 1 }
}
}
break
}
} // Badness coefficients.
var N1 = 3
var N2 = 3
var N3 = 40
var N4 = 10 // Using the table of the length of each run, calculate the amount of bad image
// - long runs or those that look like finders; called twice, once each for X and Y
function badruns (length) {
var i
var runsbad = 0
for (i = 0; i <= length; i++) {
if (rlens[i] >= 5) { runsbad += N1 + rlens[i] - 5 }
}
// BwBBBwB as in finder
for (i = 3; i < length - 1; i += 2) {
if (rlens[i - 2] === rlens[i + 2] &&
rlens[i + 2] === rlens[i - 1] &&
rlens[i - 1] === rlens[i + 1] &&
rlens[i - 1] * 3 === rlens[i] &&
// white around the black pattern? Not part of spec
(rlens[i - 3] === 0 || // beginning
i + 3 > length || // end
rlens[i - 3] * 3 >= rlens[i] * 4 || rlens[i + 3] * 3 >= rlens[i] * 4)
) { runsbad += N3 }
}
return runsbad
} // Calculate how bad the masked image is - blocks, imbalance, runs, or finders.
function badcheck () {
var x, y, h, b, b1
var thisbad = 0
var bw = 0 // blocks of same color.
for (y = 0; y < width - 1; y++) {
for (x = 0; x < width - 1; x++) {
if ((qrframe[x + width * y] && qrframe[(x + 1) + width * y] &&
qrframe[x + width * (y + 1)] && qrframe[(x + 1) + width * (y + 1)]) || // all black
!(qrframe[x + width * y] || qrframe[(x + 1) + width * y] ||
qrframe[x + width * (y + 1)] || qrframe[(x + 1) + width * (y + 1)])) {
thisbad += N2
}
}
} // X runs
for (y = 0; y < width; y++) {
rlens[0] = 0
for (h = b = x = 0; x < width; x++) {
if ((b1 = qrframe[x + width * y]) === b) { rlens[h]++ } else { rlens[++h] = 1 }
b = b1
bw += b ? 1 : -1
}
thisbad += badruns(h)
} // black/white imbalance
if (bw < 0) { bw = -bw } var big = bw
var count = 0
big += big << 2
big <<= 1
while (big > width * width) {
big -= width * width
count++
}
thisbad += count * N4 // Y runs
for (x = 0; x < width; x++) {
rlens[0] = 0
for (h = b = y = 0; y < width; y++) {
if ((b1 = qrframe[x + width * y]) === b) { rlens[h]++ } else { rlens[++h] = 1 }
b = b1
}
thisbad += badruns(h)
}
return thisbad
} function genframe (instring) {
var x, y, k, t, v, i, j, m // find the smallest version that fits the string
t = instring.length
version = 0
do {
version++
k = (ecclevel - 1) * 4 + (version - 1) * 16
neccblk1 = eccblocks[k++]
neccblk2 = eccblocks[k++]
datablkw = eccblocks[k++]
eccblkwid = eccblocks[k]
k = datablkw * (neccblk1 + neccblk2) + neccblk2 - 3 + (version <= 9)
if (t <= k) { break }
} while (version < 40) // FIXME - insure that it fits insted of being truncated
width = 17 + 4 * version // allocate, clear and setup data structures
v = datablkw + (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2
for (t = 0; t < v; t++) { eccbuf[t] = 0 }
strinbuf = instring.slice(0) for (t = 0; t < width * width; t++) { qrframe[t] = 0 } for (t = 0; t < (width * (width + 1) + 1) / 2; t++) { framask[t] = 0 } // insert finders - black to frame, white to mask
for (t = 0; t < 3; t++) {
k = 0
y = 0
if (t === 1) { k = (width - 7) }
if (t === 2) { y = (width - 7) }
qrframe[(y + 3) + width * (k + 3)] = 1
for (x = 0; x < 6; x++) {
qrframe[(y + x) + width * k] = 1
qrframe[y + width * (k + x + 1)] = 1
qrframe[(y + 6) + width * (k + x)] = 1
qrframe[(y + x + 1) + width * (k + 6)] = 1
}
for (x = 1; x < 5; x++) {
setmask(y + x, k + 1)
setmask(y + 1, k + x + 1)
setmask(y + 5, k + x)
setmask(y + x + 1, k + 5)
}
for (x = 2; x < 4; x++) {
qrframe[(y + x) + width * (k + 2)] = 1
qrframe[(y + 2) + width * (k + x + 1)] = 1
qrframe[(y + 4) + width * (k + x)] = 1
qrframe[(y + x + 1) + width * (k + 4)] = 1
}
} // alignment blocks
if (version > 1) {
t = adelta[version]
y = width - 7
for (;;) {
x = width - 7
while (x > t - 3) {
putalign(x, y)
if (x < t) { break }
x -= t
}
if (y <= t + 9) { break }
y -= t
putalign(6, y)
putalign(y, 6)
}
} // single black
qrframe[8 + width * (width - 8)] = 1 // timing gap - mask only
for (y = 0; y < 7; y++) {
setmask(7, y)
setmask(width - 8, y)
setmask(7, y + width - 7)
}
for (x = 0; x < 8; x++) {
setmask(x, 7)
setmask(x + width - 8, 7)
setmask(x, width - 8)
} // reserve mask-format area
for (x = 0; x < 9; x++) { setmask(x, 8) }
for (x = 0; x < 8; x++) {
setmask(x + width - 8, 8)
setmask(8, x)
}
for (y = 0; y < 7; y++) { setmask(8, y + width - 7) } // timing row/col
for (x = 0; x < width - 14; x++) {
if (x & 1) {
setmask(8 + x, 6)
setmask(6, 8 + x)
} else {
qrframe[(8 + x) + width * 6] = 1
qrframe[6 + width * (8 + x)] = 1
}
} // version block
if (version > 6) {
t = vpat[version - 7]
k = 17
for (x = 0; x < 6; x++) {
for (y = 0; y < 3; y++, k--) {
if (1 & (k > 11 ? version >> (k - 12) : t >> k)) {
qrframe[(5 - x) + width * (2 - y + width - 11)] = 1
qrframe[(2 - y + width - 11) + width * (5 - x)] = 1
} else {
setmask(5 - x, 2 - y + width - 11)
setmask(2 - y + width - 11, 5 - x)
}
}
}
} // sync mask bits - only set above for white spaces, so add in black bits
for (y = 0; y < width; y++) {
for (x = 0; x <= y; x++) {
if (qrframe[x + width * y]) { setmask(x, y) }
}
} // convert string to bitstream
// 8 bit data to QR-coded 8 bit data (numeric or alphanum, or kanji not supported)
v = strinbuf.length // string to array
for (i = 0; i < v; i++) { eccbuf[i] = strinbuf.charCodeAt(i) }
strinbuf = eccbuf.slice(0) // calculate max string length
x = datablkw * (neccblk1 + neccblk2) + neccblk2
if (v >= x - 2) {
v = x - 2
if (version > 9) { v-- }
} // shift and repack to insert length prefix
i = v
if (version > 9) {
strinbuf[i + 2] = 0
strinbuf[i + 3] = 0
while (i--) {
t = strinbuf[i]
strinbuf[i + 3] |= 255 & (t << 4)
strinbuf[i + 2] = t >> 4
}
strinbuf[2] |= 255 & (v << 4)
strinbuf[1] = v >> 4
strinbuf[0] = 0x40 | (v >> 12)
} else {
strinbuf[i + 1] = 0
strinbuf[i + 2] = 0
while (i--) {
t = strinbuf[i]
strinbuf[i + 2] |= 255 & (t << 4)
strinbuf[i + 1] = t >> 4
}
strinbuf[1] |= 255 & (v << 4)
strinbuf[0] = 0x40 | (v >> 4)
}
// fill to end with pad pattern
i = v + 3 - (version < 10)
while (i < x) {
strinbuf[i++] = 0xec
// buffer has room if (i === x) break;
strinbuf[i++] = 0x11
} // calculate and append ECC // calculate generator polynomial
genpoly[0] = 1
for (i = 0; i < eccblkwid; i++) {
genpoly[i + 1] = 1
for (j = i; j > 0; j--) {
genpoly[j] = genpoly[j]
? genpoly[j - 1] ^ gexp[modnn(glog[genpoly[j]] + i)] : genpoly[j - 1]
}
genpoly[0] = gexp[modnn(glog[genpoly[0]] + i)]
}
for (i = 0; i <= eccblkwid; i++) { genpoly[i] = glog[genpoly[i]] } // use logs for genpoly[] to save calc step // append ecc to data buffer
k = x
y = 0
for (i = 0; i < neccblk1; i++) {
appendrs(y, datablkw, k, eccblkwid)
y += datablkw
k += eccblkwid
}
for (i = 0; i < neccblk2; i++) {
appendrs(y, datablkw + 1, k, eccblkwid)
y += datablkw + 1
k += eccblkwid
}
// interleave blocks
y = 0
for (i = 0; i < datablkw; i++) {
for (j = 0; j < neccblk1; j++) { eccbuf[y++] = strinbuf[i + j * datablkw] }
for (j = 0; j < neccblk2; j++) { eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))] }
}
for (j = 0; j < neccblk2; j++) { eccbuf[y++] = strinbuf[(neccblk1 * datablkw) + i + (j * (datablkw + 1))] }
for (i = 0; i < eccblkwid; i++) {
for (j = 0; j < neccblk1 + neccblk2; j++) { eccbuf[y++] = strinbuf[x + i + j * eccblkwid] }
}
strinbuf = eccbuf // pack bits into frame avoiding masked area.
x = y = width - 1
k = v = 1 // up, minus
/* inteleaved data and ecc codes */
m = (datablkw + eccblkwid) * (neccblk1 + neccblk2) + neccblk2
for (i = 0; i < m; i++) {
t = strinbuf[i]
for (j = 0; j < 8; j++, t <<= 1) {
if (0x80 & t) { qrframe[x + width * y] = 1 }
do { // find next fill position
if (v) { x-- } else {
x++
if (k) {
if (y !== 0) { y-- } else {
x -= 2
k = !k
if (x === 6) {
x--
y = 9
}
}
} else {
if (y !== width - 1) { y++ } else {
x -= 2
k = !k
if (x === 6) {
x--
y -= 8
}
}
}
}
v = !v
} while (ismasked(x, y))
}
} // save pre-mask copy of frame
strinbuf = qrframe.slice(0)
t = 0 // best
y = 30000 // demerit
// for instead of while since in original arduino code
// if an early mask was "good enough" it wouldn't try for a better one
// since they get more complex and take longer.
for (k = 0; k < 8; k++) {
applymask(k) // returns black-white imbalance
x = badcheck()
if (x < y) { // current mask better than previous best?
y = x
t = k
}
if (t === 7) { break } // don't increment i to a void redoing mask
qrframe = strinbuf.slice(0) // reset for next pass
}
if (t !== k) { applymask(t) } // add in final mask/ecclevel bytes
y = fmtword[t + ((ecclevel - 1) << 3)]
// low byte
for (k = 0; k < 8; k++, y >>= 1) {
if (y & 1) {
qrframe[(width - 1 - k) + width * 8] = 1
if (k < 6) { qrframe[8 + width * k] = 1 } else { qrframe[8 + width * (k + 1)] = 1 }
}
}
// high byte
for (k = 0; k < 7; k++, y >>= 1) {
if (y & 1) {
qrframe[8 + width * (width - 7 + k)] = 1
if (k) { qrframe[(6 - k) + width * 8] = 1 } else { qrframe[7 + width * 8] = 1 }
}
} // return image
return qrframe
} var _canvas = null
var _size = null var api = { get ecclevel () {
return ecclevel
}, set ecclevel (val) {
ecclevel = val
}, get size () {
return _size
}, set size (val) {
_size = val
}, get canvas () {
return _canvas
}, set canvas (el) {
_canvas = el
}, getFrame: function (string) {
return genframe(string)
}, draw: function (string, canvas, size, ecc) {
ecclevel = ecc || ecclevel
canvas = canvas || _canvas if (!canvas) {
console.warn('No canvas provided to draw QR code in!')
return
} size = size || _size || Math.min(canvas.width, canvas.height) var frame = genframe(string)
var ctx = canvas.ctx
var px = Math.round(size / (width + 8)) var roundedSize = px * (width + 8)
var offset = Math.floor((size - roundedSize) / 2) size = roundedSize ctx.clearRect(0, 0, canvas.width, canvas.height)
ctx.setFillStyle('#000000') for (var i = 0; i < width; i++) {
for (var j = 0; j < width; j++) {
if (frame[j * width + i]) {
ctx.fillRect(px * (4 + i) + offset, px * (4 + j) + offset, px, px)
}
}
}
ctx.draw()
}
} module.exports = {
api: api
}
})()

使用同条形码一样,引入时可放一起

var qrcode = require('./qrcode')

function convertlength (length) {
return Math.round(wx.getSystemInfoSync().windowWidth * length / 750)
} function qrc (id, code, width, height) {
qrcode.api.draw(code, {
ctx: wx.createCanvasContext(id),
width: convertlength(width),
height: convertlength(height)
})
} module.exports = {
qrcode: qrc
}

.

JS 条形码插件--JsBarcode 在小程序中使用的更多相关文章

  1. 在微信小程序中使用富文本转化插件wxParse

    在微信小程序中我们往往需要展示一些丰富的页面内容,包括图片.文本等,基本上要求能够解析常规的HTML最好,由于微信的视图标签和HTML标签不一样,但是也有相对应的关系,因此有人把HTML转换做成了一个 ...

  2. js自动生成条形码插件-JsBarcode

    JsBarcode.html <!DOCTYPE html> <html lang="en"> <head> <meta charset= ...

  3. 监控微信小程序中的慢HTTP请求

    摘要: 请求时间太长,影响用户体验,使用 Fundebug 监控慢请求. Fundebug 的微信小程序监控插件在 0.5.0 版本已经支持监控 HTTP 请求错误,在小程序中通过wx.request ...

  4. 在微信小程序中使用redux

    本文主要讲述,在微信小程序中如何使用redux DEMO 需要解决的问题 如何在小程序中引入redux状态管理库,及它相关的插件? 微信小程序没有清晰的异步api,便于thunkMiddleware处 ...

  5. 高大上的微信小程序中渲染html内容—技术分享

    大部分Web应用的富文本内容都是以HTML字符串的形式存储的,通过HTML文档去展示HTML内容自然没有问题.但是,在微信小程序(下文简称为「小程序」)中,应当如何渲染这部分内容呢? 解决方案 wxP ...

  6. 网页或微信小程序中使元素占满整个屏幕高度

    在项目中经常要用到一个容器元素占满屏幕高度和宽度,然后再在这个容器元素里放置其他元素. 宽度很简单就是width:100% 但是高度呢,我们知道的是height:100%必须是在父元素的高度给定了的情 ...

  7. 微信小程序中rpx与rem单位使用

    原作者: 小小小   来自: 授权地址 本文讲解rpx和rem应用于微信小程序,如果你还没有入门,建议先从下面看起: 微信小程序官方文档web app变革之remrpx单位官方文档rpx单位基础介绍 ...

  8. 微信小程序中转义字符的处理

    在微信小程序开发过程中,有时候会用到常用的一些特殊字符如:‘<’.‘>’.‘&’.‘空格’等,微信小程序同样支持对转义字符的处理,下面提供两种方法用来处理微信小程序中转义字符的处理 ...

  9. 微信小程序中用户登录和登录态维护

    提供用户登录以及维护用户的登录状态,是一个拥有用户系统的软件应用普遍需要做的事情.像微信这样的一个社交平台,如果做一个小程序应用,我们可能很少会去做一个完全脱离和舍弃连接用户信息的纯工具软件. 让用户 ...

随机推荐

  1. python之list和tuple

    https://www.cnblogs.com/evablogs/p/6691743.html list和tuple区别: 相同:均为有序集合 异同:list可变,tuple一旦初始化则不可变 lis ...

  2. 写一函数,用来求表达式1+2+3+.....+n的值,并编写主函数

    Description 写一函数,用来求表达式1+2+3+.....+n的值,并编写主函数.n由键盘输入. Input 输入一个整数 Output 输出表达式的值 Sample Input 5 Sam ...

  3. CentOS7 升级 gvim 到 8.x 版本

    因为 CentOS7 在默认情况下,通过 yum 安装的 vim-X11.x86_64 版本为 7.x 版本,对 Youcompleteme 支持不好.故需要升级到 8.x 版本. 以下记录 gvim ...

  4. CentOS7.x搭建时间同步服务器

    关于chrony Chrony是一个开源的自由软件,像CentOS7或基于RHEL 7操作系统,已经是默认服务,默认配置文件在 /etc/chrony.conf 它能保持系统时间与时间服务器(NTP) ...

  5. EntityFramework 6.x和EntityFramework Core必须需要MultipleActiveResultSets?

    前言 本节我们来探讨到底需不需要在连接字符串上加上MultipleActiveResultSets = true ?,若您有更深层次的理解欢迎留下您的脚印. EntityFramework 6.x和E ...

  6. 企业出口退税申报系统的Sqlite数据库破解及读写

    QQ:564955427 原始出处:https://www.cnblogs.com/Charltsing/p/TSSB.html 最近一些朋友反映龙图的企业出口退税申报系统的Sqlite数据库改变了加 ...

  7. [题解]NOIP2018(普及组)T1标题统计(title)

    NOIP2018(普及组)T1标题统计(title) 题解 [代码(AC)] #include <iostream> #include <cstdio> #include &l ...

  8. H(X|Y)的推到过程

  9. 工具(4): Git自助手册

    目录: ** 0x01 基础教程/0x02 分支流程/0x03 提交日志/0x04 变化比较/0x05 团队协作/0x06 高级用法/0x07 常见问题(FAQ)/0x08 掌握Git的秘诀 0x01 ...

  10. jQuery在页面加载的时候自动调用某个函数的方法

    第一种:$(document).ready(function(){ func(xxx)//执行函数}); 第二种:$(function(){ func(xxx)//执行函数}); 第三种:jQuery ...