任意Base编码的实现NodeJS

本程序参考开源项目：​​https://github.com/cryptocoinjs/base-x​​

本程序还没有完全写完

BaseN：

let chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
let len = chars.length;
let charCodeMap = Buffer.alloc(256);
for (let i = 0; i < len; i++) {
    charCodeMap[chars.charAt(i).charCodeAt(0)] = i;
}
let first = chars[0];
let v1 = Math.log(256) / Math.log(len);
let v2 = 1 / v1;

const getBufferStart = b => {
    let start = 0;
    for (let i = 0; i < b.length; i++){
        if(b[i] !== 0){
            return start;
        }
        start++;
    }
    return start;
};
const setChars = chars => {

};
const encode = buf => {
    let start = getBufferStart(buf);
    let buf2 = Buffer.alloc(Math.ceil((buf.length - start) * v1));
    let p2 = buf2.length - 1;
    for (let i = start; i < buf.length; i++){
        let carry = buf[i];
        let p = buf2.length - 1;
        while(true) {
            carry += (256 * buf2[p]) >>> 0
            buf2[p] = (carry % len) >>> 0
            carry = (carry / len) >>> 0
            if(carry === 0 && p < p2){
                p2 = p;
                break;
            }
            p--;
        }
    }
    let str = first.repeat(start);
    start = getBufferStart(buf2);
    for (; start < buf2.length; start++){
        str += chars[buf2[start]];
    }
    return str;
};
const decode = str => {
    let p = 0;
    let start = 0;
    while (str[p] === first) {
        p++;
        start++;
    }
    let size = (((str.length - p) * v2) + 1) >>> 0;
    let buf = Buffer.alloc(size);
    let itemCount = 0;
    while (p < str.length) {
        let carry = charCodeMap[str.charCodeAt(p)];
        let i = 0;
        for (let end = size - 1; (carry !== 0 || i < itemCount) && (end !== -1); end--, i++) {
            carry += (len * buf[end]) >>> 0
            buf[end] = (carry % 256) >>> 0
            carry = (carry / 256) >>> 0
        }
        itemCount = i
        p++
    }
    var it4 = size - itemCount
    while (it4 !== size && buf[it4] === 0) {
        it4++
    }
    var vch = Buffer.allocUnsafe(start + (size - it4))
    vch.fill(0x00, 0, start)
    var j = start
    while (it4 !== size) {
        vch[j++] = buf[it4++]
    }
    return vch


    //return Buffer.concat([Buffer.alloc(start), buf.subarray(getBufferStart(buf))]);
};

setChars();

module.exports = {setChars, encode, decode};

BaseX：

'use strict'
function base (ALPHABET) {
  var BASE_MAP = new Uint8Array(256)
  for (var j = 0; j < BASE_MAP.length; j++) {
    BASE_MAP[j] = 255
  }
  for (var i = 0; i < ALPHABET.length; i++) {
    var x = ALPHABET.charAt(i)
    var xc = x.charCodeAt(0)
    BASE_MAP[xc] = i
  }
  var BASE = ALPHABET.length
  var LEADER = ALPHABET.charAt(0)
  var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up
  var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up
  function encode (source) {
    if (Array.isArray(source) || source instanceof Uint8Array) { source = Buffer.from(source) }
    if (source.length === 0) { return '' }
    // Skip & count leading zeroes.
    var zeroes = 0
    var length = 0
    var pbegin = 0
    var pend = source.length
    while (pbegin !== pend && source[pbegin] === 0) {
      pbegin++
      zeroes++
    }
    // Allocate enough space in big-endian base58 representation.
    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0
    var b58 = new Uint8Array(size)
    // Process the bytes.
    while (pbegin !== pend) {
      var carry = source[pbegin]
      // Apply "b58 = b58 * 256 + ch".
      var i = 0
      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
        carry += (256 * b58[it1]) >>> 0
        b58[it1] = (carry % BASE) >>> 0
        carry = (carry / BASE) >>> 0
      }
      length = i
      pbegin++
    }
    // Skip leading zeroes in base58 result.
    var it2 = size - length
    while (it2 !== size && b58[it2] === 0) {
      it2++
    }
    // Translate the result into a string.
    var str = LEADER.repeat(zeroes)
    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }
    return str
  }
  function decode (source) {
    var psz = 0
    var zeroes = 0
    var length = 0
    while (source[psz] === LEADER) {
      zeroes++
      psz++
    }
    var size = (((source.length - psz) * FACTOR) + 1) >>> 0
    var b256 = new Uint8Array(size)

    while (psz < source.length) {
      var carry = BASE_MAP[source.charCodeAt(psz)]
      var i = 0
      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
        carry += (BASE * b256[it3]) >>> 0
        b256[it3] = (carry % 256) >>> 0
        carry = (carry / 256) >>> 0
      }
      length = i
      psz++
    }
    var it4 = size - length
    while (it4 !== size && b256[it4] === 0) {
      it4++
    }
    var vch = Buffer.allocUnsafe(zeroes + (size - it4))
    vch.fill(0x00, 0, zeroes)
    var j = zeroes
    while (it4 !== size) {
      vch[j++] = b256[it4++]
    }
    return vch
  }
  return {
    encode,
    decode
  }
}
module.exports = base