在小程序中的使用:

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. iBatis第五章:事务管理

    ---------------------------- 1.什么是事务 ------------------------------ 什么是事务? 需要注意的是,事务的概念不是针对某个特定的数据库的 ...

  2. Delphi中常用字符串处理函数

    .copy(str,pos,num) 从str字符串的pos处开始,截取num个字符的串返回. 假设str为,)=,)='def' .concat(str1,str2{,strn}) 把各自变量连接起 ...

  3. mssql server for docker on MacOs

    1. install 1.下载镜像 docker pull microsoft/mssql-server-linux 使用该命令就可以把数据库的docker镜像下载下来. 2.创建并运行容器 dock ...

  4. 简单shellcode编写

    0x00 介绍 Shellcode 是指经过精心设计的一串指令,一旦注入正在运行的应用程序中即可运行,常用于栈和基于堆的溢出.术语Shellcode意思指的便是用于启动一个命令Shell的已编写好的可 ...

  5. CDH集成Kafka,两种方式:离线、在线

    1.离线 先下载相应版本的kafka http://archive.cloudera.com/kafka/parcels/ 然后放置相应目录,如下图: 然后直接添加组件即可 2.在线 配置相应的kaf ...

  6. Activiti开发案例之代码生成工作流图片

    图例 环境 软件 版本 SpringBoot 1.5.10 activiti-spring-boot-starter-basic 6.0 生成代码 以下是简化代码: /** * 查看实例流程图,根据流 ...

  7. React 系列教程2:编写兰顿蚂蚁演示程序

    简介 最早接触兰顿蚂蚁是在做参数化的时候,那时候只感觉好奇,以为是很复杂的东西.因无意中看到生命游戏的 React 实现,所以希望通过兰顿蚂蚁的例子再学习一下 React. 兰顿蚂蚁的规则非常简单: ...

  8. jeecg字典表—报表配置(popup弹框)

    新建字典表 录入字典数据 新建报表配置 新建用于popup的表 字典Code中对应,用户接受popup返回的字段(按顺序写) 结果校验

  9. 基于 docker 的redis 主从+哨兵(快速部署)

    很简单(字多的步骤见:http://www.cnblogs.com/vipzhou/p/8580495.html) 1.直接启动3个容器 docker network create --subnet ...

  10. Python网络爬虫精要

    目的 学习如何从互联网上获取数据.数据科学必须掌握的技能之一. 本文所用到的第三方库如下: requests, parsel, selenium requests负责向网页发送HTTP请求并得到响应, ...