Fatal编程技术网
  • javascript/
  • 在JavaScript中将数字转换为基数64的最快方法？

在JavaScript中将数字转换为基数64的最快方法？

javascript

在JavaScript中将数字转换为基数64的最快方法？,javascript,Javascript,在JavaScript中，您可以将数字转换为字符串表示形式，具体如下： (12345).toString(36) // "9ix" …您可以将其转换回常规数字，如下所示： parseInt("9ix", 36) // 12345 36是可以指定的最高基数。它显然使用字符0-9和a-z作为数字（总共36个） 我的问题：将数字转换为64进制表示的最快方法是什么（例如，对于额外的28位数字，使用a-Z，以及-和） 更新：有四个人发布了回复，说这个问题重复了，或者说我在找Base64。我不是 “”

在JavaScript中，您可以将数字转换为字符串表示形式，具体如下：

(12345).toString(36) // "9ix"
…您可以将其转换回常规数字，如下所示：

parseInt("9ix", 36) // 12345
36是可以指定的最高基数。它显然使用字符
0-9
和
a-z
作为数字（总共36个）

我的问题：将数字转换为64进制表示的最快方法是什么（例如，对于额外的28位数字，使用
a-Z
，以及
-
和
）

更新：有四个人发布了回复，说这个问题重复了，或者说我在找Base64。我不是

“”是一种用简单的ASCII字符集对二进制数据进行编码的方法，以确保通过网络等进行传输的安全性（这样纯文本系统就不会篡改二进制数据）

这不是我要问的。我问的是如何将数字转换为基数为64的字符串表示形式。（JavaScript的
toString（radix）
会自动为任何最大为36的基数执行此操作；我需要一个自定义函数来获取基数64。）

更新2：以下是一些输入和输出示例

0   → "0"
1   → "1"
9   → "9"
10  → "a"
35  → "z"
61  → "Z"
62  → "-"
63  → "_"
64  → "10"
65  → "11"
128 → "20"
etc.
在mozilla或webkit浏览器中，您可以使用btoa（）和atob（）对base64进行编码和解码。

好的，您可以使用任何Javascript base64库：也许可以回答它

编辑：二进制数据本质上只是一个字节序列。如果假设字节表示单个数字，则可以将字节序列表示为基64字符串。对它们进行解码，然后对字节进行一些简单的数学运算，得到一个数字。将数字转换为字节序列并编码以获得字符串。似乎很合理，除非您以某种方式投资于字符串中使用的特定字符。

以下是数字（而不是字节数组）解决方案的草图：）

仅适用于正数，忽略小数部分，并且没有真正测试——只是一个草图

Base64 = {

    _Rixits :
//   0       8       16      24      32      40      48      56     63
//   v       v       v       v       v       v       v       v      v
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/",
    // You have the freedom, here, to choose the glyphs you want for 
    // representing your base-64 numbers. The ASCII encoding guys usually
    // choose a set of glyphs beginning with ABCD..., but, looking at
    // your update #2, I deduce that you want glyphs beginning with 
    // 0123..., which is a fine choice and aligns the first ten numbers
    // in base 64 with the first ten numbers in decimal.

    // This cannot handle negative numbers and only works on the 
    //     integer part, discarding the fractional part.
    // Doing better means deciding on whether you're just representing
    // the subset of javascript numbers of twos-complement 32-bit integers 
    // or going with base-64 representations for the bit pattern of the
    // underlying IEEE floating-point number, or representing the mantissae
    // and exponents separately, or some other possibility. For now, bail
    fromNumber : function(number) {
        if (isNaN(Number(number)) || number === null ||
            number === Number.POSITIVE_INFINITY)
            throw "The input is not valid";
        if (number < 0)
            throw "Can't represent negative numbers now";

        var rixit; // like 'digit', only in some non-decimal radix 
        var residual = Math.floor(number);
        var result = '';
        while (true) {
            rixit = residual % 64
            // console.log("rixit : " + rixit);
            // console.log("result before : " + result);
            result = this._Rixits.charAt(rixit) + result;
            // console.log("result after : " + result);
            // console.log("residual before : " + residual);
            residual = Math.floor(residual / 64);
            // console.log("residual after : " + residual);

            if (residual == 0)
                break;
            }
        return result;
    },

    toNumber : function(rixits) {
        var result = 0;
        // console.log("rixits : " + rixits);
        // console.log("rixits.split('') : " + rixits.split(''));
        rixits = rixits.split('');
        for (var e = 0; e < rixits.length; e++) {
            // console.log("_Rixits.indexOf(" + rixits[e] + ") : " + 
                // this._Rixits.indexOf(rixits[e]));
            // console.log("result before : " + result);
            result = (result * 64) + this._Rixits.indexOf(rixits[e]);
            // console.log("result after : " + result);
        }
        return result;
    }
}

Base64={
_脱欧：
//   0       8       16      24      32      40      48      56     63
//v v v v v v v v
“0123456789ABCDEFGHIjklmnopqrstuvxyzabCDEFGHIjklmnopqrstuvxyz+/”，
//在这里，您可以自由选择所需的字形
//代表您的基64数字。ASCII编码的人通常
//选择一组以ABCD…开头的图示符，但是，请查看
//您的更新#2，我推断您需要以
//0123…，这是一个很好的选择，它与前十个数字对齐
//以64为基数，前十个数字以十进制表示。
//这不能处理负数，只能在
//整数部分，丢弃小数部分。
//做得更好意味着决定你是否只是代表
//两个补32位整数的javascript数的子集
//或者使用base-64表示法来表示
//基础IEEE浮点数，或表示尾数
//或者其他一些可能性。现在，保释
fromNumber:函数（数字）{
如果（isNaN（数字（数字））| |数字===null||
数字===数字。正（无穷大）
抛出“输入无效”；
如果（数字<0）
抛出“现在不能表示负数”；
var rixit；//类似于“digit”，仅在某些非十进制基数中
var剩余=数学楼层（编号）；
var结果=“”；
while（true）{
rixit=剩余的%64
//log（“rixit:+rixit”）；
//console.log（“前面的结果：+result”）；
结果=这个。_Rixits.charAt（rixit）+结果；
//console.log（“结果在：+结果之后”）；
//控制台日志（“剩余前：”+剩余）；
剩余=数学楼层（剩余/64）；
//控制台日志（“剩余后：”+剩余）；
如果（残差==0）
打破
}
返回结果；
},
toNumber:函数（rixits）{
var结果=0；
//log（“rixits:+rixits”）；
//console.log（“rixits.split（“”）：“+rixits.split（“”））；
rixits=rixits.split（“”）；
对于（var e=0；e
更新：这里有一些（非常轻量级的）上述测试，用于在有console.log的NodeJs中运行

function testBase64(x) {
    console.log("My number is " + x);
    var g = Base64.fromNumber(x);
    console.log("My base-64 representation is " + g);
    var h = Base64.toNumber(g);
    console.log("Returning from base-64, I get " + h);
    if (h !== Math.floor(x))
        throw "TEST FAILED";
}

testBase64(0);
try {
    testBase64(-1);
    }
catch (err) {
    console.log("caught >>>>>>  " + err);
    }
try {
    testBase64(undefined);
    }
catch (err) {
    console.log("caught >>>>>>  " + err);
    }
try {
    testBase64(null);
    }
catch (err) {
    console.log("caught >>>>>>  " + err);
    }
try {
    testBase64(Number.NaN);
    }
catch (err) {
    console.log("caught >>>>>>  " + err);
    }
try {
    testBase64(Number.POSITIVE_INFINITY);
    }
catch (err) {
    console.log("caught >>>>>>  " + err);
    }
try {
    testBase64(Number.NEGATIVE_INFINITY);
    }
catch (err) {
    console.log("caught >>>>>>  " + err);
    }

for(i=0; i<100; i++)
    testBase64(Math.random()*1e14);

函数testBase64（x）{
console.log（“我的号码是”+x）；
var g=Base64.从编号（x）；
log（“我的base-64表示为”+g）；
var h=Base64.toNumber（g）；
log（“从base-64返回，我得到”+h）；
如果（h！==数学楼层（x））
抛出“测试失败”；
}
testBase64（0）；
试一试{
testBase64（-1）；
}
捕捉（错误）{
console.log（“捕获>>>>”+错误）；
}
试一试{
testBase64（未定义）；
}
捕捉（错误）{
console.log（“捕获>>>>”+错误）；
}
试一试{
testBase64（空）；
}
捕捉（错误）{
console.log（“捕获>>>>”+错误）；
}
试一试{
testBase64（Number.NaN）；
}
捕捉（错误）{
console.log（“捕获>>>>”+错误）；
}
试一试{
testBase64（数字正无穷大）；
}
捕捉（错误）{
console.log（“捕获>>>>”+错误）；
}
试一试{
testBase64（数字负无穷大）；
}
捕捉（错误）{
console.log（“捕获>>>>”+错误）；
}

对于（i=0；i，这里有一个不同的假设


function base64(value) {
  if (typeof(value) === 'number') {
    return base64.getChars(value, '');
  }

  if (typeof(value) === 'string') {
    if (value === '') { return NaN; }
    return value.split('').reverse().reduce(function(prev, cur, i) {
      return prev + base64.chars.indexOf(cur) * Math.pow(64, i);
    }, 0);
  }
}

base64.chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";

base64.getChars = function(num, res) {
  var mod = num % 64,
      remaining = Math.floor(num / 64),
      chars = base64.chars.charAt(mod) + res;

  if (remaining <= 0) { return chars; }
  return base64.getChars(remaining, chars);
};



函数base64（值）{
如果（类型（值）=“数字”）{
返回base64.getChars（值为“”）；
}
如果（类型（值）=“字符串”）{
如果（值==''）{返回Na

const STR64:Array = ('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/').split( '' );

// TRANSFORM NUMBERS BETWEEN radix 10 AND radix 64
/** Methods based on answers shared in:
* @url   http://stackoverflow.com/questions/6213227/fastest-way-to-convert-a-number-to-radix-64-in-javascript
*/

// METHODS 
/** to64String: Method to transform a radix 10 number to radix 64 number (as string)
* @param input   Number for transform to radix 64 (as String)
* @param current String data (don't needed in request)
* @return String Number in radix 64 as String;
*
* @based http://stackoverflow.com/users/383780/monocle
* @based base64( Method for number to string - NOT string part )
*/
function to64String( input:Number, current:String = '' ):String
{
    if ( input < 0 && current.length == 0 ){
        input = input * - 1;
    }
    var modify:Number = input % 64;
    var remain:Number = Math.floor( input / 64 );
    var result:String = STR64[ modify ] + current;
    return ( remain <= 0 ) ? result : to64String( remain, result );
}

/** to64Parse: Method for transform a number in radix 64 (as string) in radix 10 number
* @param input   Number in radix 64 (as String) to transform in radix 10
* @return Number in radix 10
*
* @based http://stackoverflow.com/users/520997/reb-cabin
* @based Base64.toNumber( Method for string to number )
*/
function to64Parse ( input:String ):Number
{
    var result:Number = 0;
    var toProc:Array  = input.split( '' );
    var e:String;
    for ( e in toProc ){
        result = ( result * 64 ) + STR64.indexOf( toProc[ e ] );
    }
    return result;
}

// TEST
var i:int = 0;
var max:Number = 1000000000000;
var min:Number = 0;
for ( i == 0; i < 20; i++ ){
    var num:Number = ( Math.ceil( Math.random() * ( max - min + 1 ) ) + min );
    var s64:String = to64String( num );
    var ret:Number = to64Parse ( s64 );
    trace( i + '\t# ' + num + '\t' + s64 + '\t' + ret + '\t' + ( ret == num ) )
}

// TEST RESULT
/*
0   # 808936734685  LxYYv/d 808936734685    true
1   # 931332556532  NjXvwb0 931332556532    true
2   # 336368837395  E5RJSMT 336368837395    true
3   # 862123347820  Mi6jk9s 862123347820    true
4   # 174279278611  CiT2sAT 174279278611    true
5   # 279361353722  EELO/f6 279361353722    true
6   # 435602995568  GVr9jlw 435602995568    true
7   # 547163526063  H9lfNOv 547163526063    true
8   # 188017380425  CvGtYxJ 188017380425    true
9   # 720098771622  KepO0Km 720098771622    true
10  # 408089106903  F8EAZnX 408089106903    true
11  # 293941423763  ERwRi6T 293941423763    true
12  # 383302396164  Fk+mmkE 383302396164    true
13  # 695998940618  KIMxQXK 695998940618    true
14  # 584515331314  IgX1CTy 584515331314    true
15  # 528965753970  Hso0Nxy 528965753970    true
16  # 5324317143    E9WqHX  5324317143      true
17  # 772389841267  LPWBalz 772389841267    true
18  # 954212692102  N4rgjCG 954212692102    true
19  # 867031893694  MnfIMa+ 867031893694    true
*/



Base64 = (function () {
    var digitsStr = 
    //   0       8       16      24      32      40      48      56     63
    //   v       v       v       v       v       v       v       v      v
        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-";
    var digits = digitsStr.split('');
    var digitsMap = {};
    for (var i = 0; i < digits.length; i++) {
        digitsMap[digits[i]] = i;
    }
    return {
        fromInt: function(int32) {
            var result = '';
            while (true) {
                result = digits[int32 & 0x3f] + result;
                int32 >>>= 6;
                if (int32 === 0)
                    break;
            }
            return result;
        },
        toInt: function(digitsStr) {
            var result = 0;
            var digits = digitsStr.split('');
            for (var i = 0; i < digits.length; i++) {
                result = (result << 6) + digitsMap[digits[i]];
            }
            return result;
        }
    };
})();



Base64.fromInt(-2147483648); // gives "200000"
Base64.toInt("200000"); // gives -2147483648



var base = ['Q', 'W', 'E', 'R', 'T', 'Y', 'I', 'O', 'U'];
new PowerRadix([1, 0], 10).toArray(base); // ['W', 'Q'] 
new PowerRadix('10', 10).toArray(base);   // ['W', 'Q'] 
new PowerRadix(10, 10).toArray(base);     // ['W', 'Q'] 

new PowerRadix([1, 0], 10).toString(base); // "WQ" 
new PowerRadix('10', 10).toString(base);   // "WQ" 
new PowerRadix(10, 10).toString(base);     // "WQ"



new PowerRadix('ba', ['a', 'b']); // base 2 source radix, uses 'a' = 0 & 'b' = 1 character set.
new PowerRadix('ba', ['a', 'b']).toString(10); // returns "2"



private String toShortString(BigInteger value, String language) {
    StringBuilder stringBuilder = new StringBuilder();
    BigInteger length = BigInteger.valueOf(language.length());
    while (value.compareTo(BigInteger.ZERO) > 0){
        int index = value.mod(length).intValue();
        stringBuilder.append(language.charAt(index));
        value = value.divide(length);
    }
    return stringBuilder.reverse().toString();
}



    BigInteger value = BigInteger.valueOf(2).pow(128); 
    System.out.println(value);
    System.out.println(value.toString(16));
    System.out.println(toShortString(value, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()-=_+"));



var base64 = Buffer.from([i>>24,i>>16,i>>8,i]).toString('base64').substr(0,6);



const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

// binary to string lookup table
const b2s = alphabet.split('');

// string to binary lookup table
// 123 == 'z'.charCodeAt(0) + 1
const s2b = new Array(123);
for (let i = 0; i < alphabet.length; i++) {
  s2b[alphabet.charCodeAt(i)] = i;
}

// number to base64
const ntob = (number) => {
  if (number < 0) return `-${ntob(-number)}`;

  let lo = number >>> 0;
  let hi = (number / 4294967296) >>> 0;

  let right = '';
  while (hi > 0) {
    right = b2s[0x3f & lo] + right;
    lo >>>= 6;
    lo |= (0x3f & hi) << 26;
    hi >>>= 6;
  }

  let left = '';
  do {
    left = b2s[0x3f & lo] + left;
    lo >>>= 6;
  } while (lo > 0);

  return left + right;
};

// base64 to number
const bton = (base64) => {
  let number = 0;
  const sign = base64.charAt(0) === '-' ? 1 : 0;

  for (let i = sign; i < base64.length; i++) {
    number = number * 64 + s2b[base64.charCodeAt(i)];
  }

  return sign ? -number : number;
};



var endex = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";
function encode(intcode){
    if(intcode < endex.length){
        return endex[intcode];
    }else{
        return encode(Math.floor(intcode/endex.length)) + endex[intcode%endex.length];
    }
}
function decode(charcode){
    if(charcode.length < 2){
        return endex.indexOf(charcode);
    }else{
        return (decode(charcode.slice(0, -1)) * endex.length) + endex.indexOf(charcode.slice(-1));
    }
}