Fatal编程技术网
  • javascript/
  • 在JavaScript中，如何在不同的基之间转换数字？

在JavaScript中，如何在不同的基之间转换数字？

javascript

在JavaScript中，如何在不同的基之间转换数字？,javascript,Javascript,我想在不同的基数之间转换数字，比如十六进制和十进制 示例：如何将十六进制8F转换为十进制？指定要用作参数的基数 注意：这只适用于将基数2-36转换为十进制和小值 parseInt(string, radix) parseInt("80", 10) // results in 80 parseInt("80", 16) // results in 128 // etc 关于“小”一词，parseInt（“6f”，32）很好（=207），但任何其他稍大一点的也会是207，6f1，6f11 AP

我想在不同的基数之间转换数字，比如十六进制和十进制

示例：如何将十六进制
8F
转换为十进制？

指定要用作参数的基数

注意：这只适用于将基数2-36转换为十进制和小值

parseInt(string, radix) 

parseInt("80", 10) // results in 80
parseInt("80", 16) // results in 128
// etc
关于“小”一词，
parseInt（“6f”，32）
很好（=207），
但任何其他稍大一点的也会是207，
6f1
，
6f11

API

要将十六进制字符串转换为数字：

  • 字符串：必需。要分析的字符串

  • 基数：可选。表示要使用的数字系统的数字（从2到36）

要将数字转换为十六进制字符串：

  • 基数：可选。指定希望数字显示为的基数
基数值示例：

  • 2-数字将显示为二进制值
  • 8-数字将显示为八进制值
  • 16-数字将显示为十六进制值
示例用法

整数值到十六进制：

var i=10；
console.log（i.toString（16））使用parseInt函数：


var noInBase10 = parseInt('8F',16);



我编写了一个函数，将JavaScript字符串从一个基转换为另一个基，并将原始基和新基指定为参数



函数convertFromBaseToBase（str、fromBase、toBase）{
var num=parseInt（str，fromBase）；
返回num.toString（toBase）；
}

警报（从基本状态转换为基本状态（10,2,10））嗯，我做了一个函数，可以从基数10转换到任意基数。（这取决于数组
A
中有多少个字符串，如果超过+10，符号就用光了），当我发现你可以在不到10个字符的时间内找到它时，我几乎哭了

添加书签并作为URL插入此。。。我已经用了很长时间，但是很私人的方式。至少，我可以使用高于36的底座。你可以自己添加更多的符号，但如果你愿意，我可以为你制作



var X=prompt（“选择您的号码”）；
var Y=提示（“选择您的基础”）；
var Z=[]；
var M=-1；
变量A=[“A”、“B”、“C”、“D”、“E”、“F”、“G”、“H”、“I”、“J”、“K”、“L”、“M”、“N”、“O”、“P”、“Q”、“R”、“S”、“T”、“U”、“V”、“W”、“X”、“Y”、“Z”]；
var B=函数（）{
对于（i=X；0=10）{
Z.push（A[i%Y-10]）；
}否则{
Z.推力（i%Y）；
} 
M=M+1；
} 
对于（j=M；j>=0；j--）{
文件编写（Z[j]）；
} 
};

B（）；//调用函数
通常我使用此函数从不同的基进行转换

例如，对于以下两种情况，它都返回“11111111”：
convertBase（“ff”，16，2）或convertBase（0xFF，16，2）


我来到这个岗位需要从10进制转换到62进制，反之亦然。虽然这里的解决方案很棒，
parseInt
和
toString
只支持基数2到36。因此，如果有人发现自己处于与我相似的位置，需要基数2到62，我将我的解决方案粘贴在下面





函数convertBase（值，从\u基到\u基）{
变量范围='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/'。拆分（''；
var from_range=range.slice（0，from_base）；
var to_range=range.slice（0，to_base）；
var dec_value=value.split（“”）.reverse（）.reduce（函数（进位、数字、索引）{
if（从_range.indexOf（digit）==-1）抛出新错误（'Invalid digit`'+digit+'`for base'+从_base+'.'）；
返回进位+=从_range.indexOf（数字）*（Math.pow（从_base，index））；
}, 0);
var新值=“”；
而（dec_值>0）{
新的_值=到_范围[dec_值%到_基数]+新的_值；
dec_值=（dec_值-（dec_值%对_基））/对_基；
}
返回新的|u值| |“0”；

}
下图可能会有所帮助。请注意，要从基数16转换为基数2，需要先转换为基数10，然后再转换为基数2


您自己创建base2转换的递归方法。
如上用户所述

设n=13；console.log（n.toString（2））将导致13从基数10转换为基数2

但是如果你想编程的话。我已经写了一个递归方法来做同样的事情。只需除以2，然后计算余数



/@author Tarandeep Singh:：创建了从基10到基2的递归转换器
//@日期：2017-04-11
//将基数10转换为基数2，我们应该反转输出
//例如base10to2（10）=“0101”justdores=base10to2（10）.split（“”）.reverse（）.join（）；
函数base10to2（val，res=''）{
如果（val>=2）{
res+=''+val%2；
返回base10to2（val=Math.floor（val/2），res）；
}否则{
res+=''+1
返回res；
}
}
设n=13；
var result=base10to2（n）.split（“”）.reverse（）.join（）；

write（`Converting${n}to Base2是${result}`）您还可以将十六进制数转换为十进制数，如下所示：


var a="8F";
var b=a.split("");
var result=0;var hex_multiplier=1;
for(var i=0;i<b.length;i++){
    result +=parseInt(b[i],16)*hex_multiplier;
    hex_multiplier *=16;
}
console.log(result);



var a=“8F”；
var b=a.拆分（“”）；
var结果=0；var hex_乘数=1；
对于（var i=0；i检查完整项以转换为不同的基


/**


*在JavaScript中从/转换为二进制/十进制/十六进制
* 
*版权所有2012-2015，Shamshul
*根据麻省理工学院许可证获得许可
* 
*/

（功能（）{

})（本条）

/*
*用法示例：
*ConvertBase.bin2dec（'1111'）；//'15'
*ConvertBase.dec2hex（'82'）；/'52'
*ConvertBase.hex2bin（'e2'）；/'11100010'
*ConvertBase.dec2bin（'153'）；/'10011001'
*ConvertBase.hex2dec（'1FE4ED63D55FA51E'）；/'22982722903156000'
*ConvertBase.oct2dec（'777'）；//'511'
*ConvertBase.dec2oct（'551'）；//'1047'
*/
您可以在某些情况下使用：



函数binaryToDecimal

var convertBase = function(val, base1, base2) {
    if (typeof(val) == "number") {
        return parseInt(String(val)).toString(base2);
    } else {
        return parseInt(val.toString(), base1).toString(base2)
    };
}



var a="8F";
var b=a.split("");
var result=0;var hex_multiplier=1;
for(var i=0;i<b.length;i++){
    result +=parseInt(b[i],16)*hex_multiplier;
    hex_multiplier *=16;
}
console.log(result);



/**



var ConvertBase = function (num) {
    return {
        from : function (baseFrom) {
            return {
                to : function (baseTo) {
                    return parseInt(num, baseFrom).toString(baseTo);
                }
            };
        }
    };
};

// binary to decimal
ConvertBase.bin2dec = function (num) {
    return ConvertBase(num).from(2).to(10);
};

// binary to hexadecimal
ConvertBase.bin2hex = function (num) {
    return ConvertBase(num).from(2).to(16);
};

// decimal to binary
ConvertBase.dec2bin = function (num) {
    return ConvertBase(num).from(10).to(2);
};

// decimal to hexadecimal
ConvertBase.dec2hex = function (num) {
    return ConvertBase(num).from(10).to(16);
};

// hexadecimal to binary
ConvertBase.hex2bin = function (num) {
    return ConvertBase(num).from(16).to(2);
};

// hexadecimal to decimal
ConvertBase.hex2dec = function (num) {
    return ConvertBase(num).from(16).to(10);
};
//Octal to Decimal
ConvertBase.oct2dec = function (num) {
    return ConvertBase(num).from(8).to(10);
};

 //Decimal to Octal
ConvertBase.dec2oct = function (num) {
    return ConvertBase(num).from(10).to(8);
};

this.ConvertBase = ConvertBase;



function convertBase(str, fromBase, toBase) {

    const DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/";

    const add = (x, y, base) => {
        let z = [];
        const n = Math.max(x.length, y.length);
        let carry = 0;
        let i = 0;
        while (i < n || carry) {
            const xi = i < x.length ? x[i] : 0;
            const yi = i < y.length ? y[i] : 0;
            const zi = carry + xi + yi;
            z.push(zi % base);
            carry = Math.floor(zi / base);
            i++;
        }
        return z;
    }

    const multiplyByNumber = (num, x, base) => {
        if (num < 0) return null;
        if (num == 0) return [];

        let result = [];
        let power = x;
        while (true) {
            num & 1 && (result = add(result, power, base));
            num = num >> 1;
            if (num === 0) break;
            power = add(power, power, base);
        }

        return result;
    }

    const parseToDigitsArray = (str, base) => {
        const digits = str.split('');
        let arr = [];
        for (let i = digits.length - 1; i >= 0; i--) {
            const n = DIGITS.indexOf(digits[i])
            if (n == -1) return null;
            arr.push(n);
        }
        return arr;
    }

    const digits = parseToDigitsArray(str, fromBase);
    if (digits === null) return null;

    let outArray = [];
    let power = [1];
    for (let i = 0; i < digits.length; i++) {
        digits[i] && (outArray = add(outArray, multiplyByNumber(digits[i], power, toBase), toBase));
        power = multiplyByNumber(fromBase, power, toBase);
    }

    let out = '';
    for (let i = outArray.length - 1; i >= 0; i--)
        out += DIGITS[outArray[i]];

    return out;
}



console.log(convertBase("5a2a9c826c75045be9ba8fbffc80c6f25a2a9c826c75045be9ba8fbffc80c6f2",16,64));
// Returns: 5EGD89ItghrWrGfL/O0NL9qaFO2r7k4m+CWzX/YwcrO

console.log(convertBase("5EGD89ItghrWrGfL/O0NL9qaFO2r7k4m+CWzX/YwcrO",64,16));
// Returns: 5a2a9c826c75045be9ba8fbffc80c6f25a2a9c826c75045be9ba8fbffc80c6f2



function BASE() {
  /**
   * BASE n converter doing all the radix combinations between Base2 and Base256
   * @param  {String}               str         input number
   * @param  {Number|String|Array}  fromBase    input number system radix (Number, e.g. 64), convention name (String, e.g. 'Bitcoin') or range (Array)
   * @param  {Number|String|Array}  toBASE      output number system radix (Number), convention name (String) or range (Array e.g. ['0123456789'])
   * @return {String}                           output number
   */
    this.convert = function (str, fromBase, toBASE)
    {
      if(typeof(fromBase)=='object') { this.fromSymbols = fromBase[0] } else this.fromSymbols = this.getsymbols(fromBase);
      if(typeof(toBASE)  =='object') { this.toSymbols = toBASE[0] } else this.toSymbols = this.getsymbols(toBASE);
      fromBase = this.fromSymbols.length; toBASE = this.toSymbols.length;

      // PARSE INPUT DIGITS ARRAY
      for(var _a = [0], str = str.split(''); str.length > 0 && _a[_a.push(this.fromSymbols.indexOf(str.pop())) - 1] >= 0;);
      var _d = _a.shift() + _a[_a.length-1]>=0 ? _a : null; if (_d === null) return null;

      // BASE CONVERSION
      for (var _n = 0,_a = [],_p = [1]; _n < _d.length; _n++) { _a = add(_a, mul(_d[_n], _p, toBASE), toBASE); _p = mul(fromBase, _p, toBASE) }

      // PARSE OUTPUT DIGITS ARRAY
      for (var _n = _a.length - 1, _o = ''; _n >= 0; _o += this.toSymbols[_a[_n--]]);
      return _o.length==0?this.toSymbols[0]:_o;
    }

    this.symbols = {
        32:function(){return this["base32hex"]},
        36:["[0-9][A-Z]"],
        45:function(){return this["qr-alnum"]},
        58:function(){return this["Bitcoin"]},
        64:["[A-Z][a-z][0-9]+/"],
        85:function(){return this["RFC 1924"]},
        91:["[A-Z][a-z][0-9]!#$%&()*+,./:;<=>?@[]^_`{|}~\""],
        94:["[!-~]"],
    "geohash":  ["[0-9][b-h]jkmn[p-z]"],                      // base 32
    "RFC 4648": ["[A-Z][2-7]"],                               // base 32
    "base32hex": ["[0-9][A-V]"],                              // base 32
    "qr-alnum":["[0-9][A-Z] $%*+-./:"],                       // base 45
    "Bitcoin":  ["[1-9][A-H]JKLMN[P-Z][a-k][m-z]"],           // base 58
    "RFC 1924": ["[0-9][A-Z][a-z]!#$%&()*+-;<=>?@^_`{|}~"]    // base 85
    }

    this.getsymbols = function(index) {
      if(typeof(this.symbols[index])=="undefined") this.symbols[index] = index<95?this.rng(index<64?"[0-9][A-Z][a-z]+":"[A-Z][a-z][0-9][!-/][:-@][[-`][{-~]").substring(0,index):this.rng("[\x00-\xff]").substring(256-index,256);
      if(typeof(this.symbols[index])=="function")  this.symbols[index] = this.symbols[index]();             // process references
      if(typeof(this.symbols[index])=="object")    this.symbols[index] = this.rng(this.symbols[index][0]);  // process range_replace
      return this.symbols[index];
    }

    this.rng = function(_s) {
      var _a = _s.match(/\[.-.\]/); if(_a==null) return _s; else { _a=[_a[0].charCodeAt(1),_a[0].charCodeAt(3)];
      return this.rng(_s.replace(RegExp("\\[(\\x"+("0"+_a[0].toString(16)).slice(-2)+"-\\x"+_a[1].toString(16)+")\\]","g")
      ,String.fromCharCode(..." ".repeat(_a[1]-_a[0]+1).split("").map((_e,_i)=>_i+_a[0])) )) }
    }

    this.selftest = function() {
      var _a={}; for(var _o in this.symbols) _a[_o] = this.getsymbols(_o).length; // built-in symbols
      for(_o=2;_o<=95;_o++) _a[_o] = this.getsymbols(_o).length; _a[256]=256;     // symbol range 2-95 + 256 (96-255 is similar)
      var _s = "",_a = Object.keys(_a).sort(function(a,b){return _a[a]-_a[b]});   // sort merged list
      for(var _i in _a) {                                                         // iterate number systems
        _o = {fromBase:10, toBASE:_a[_i]}; var _r = this.convert("",10,_o.toBASE)
        _s += "\r\n\oBASE.convert(n, '"+_o.fromBase+"', '"+_o.toBASE+"') ["+this.fromSymbols+"] ["+this.toSymbols+"]\r\n"
        for(var _n=0;_n<(this.fromSymbols.length+2);_n++) {                       // iterate numbers
          _r = this.convert(String(_n),_o.fromBase,_o.toBASE)
          _s += _n+(String(_n)==this.convert(_r,_o.toBASE,_o.fromBase)?">":"?")+"["+_r+"] ";
        }
      }
      return _s
    }

    var add = function(x, y, base) {
        var _m = Math.max(x.length, y.length);
        for(var _c = _n = 0,_r = []; _n < _m || _c; _c = Math.floor(_z / base)) {
          var _z = _c + (_n < x.length ? x[_n] : 0) + (_n < y.length ? y[_n] : 0);
          var _n =  _r.push(_z % base);
        }
        return _r;
    }

    var mul = function(x, pow, base) {
        for(var _r = x < 0 ? null : []; x > 0; x = x >> 1) {
          if(x & 1) _r = add(_r, pow, base);
          pow = add(pow, pow, base);
        }
        return _r;
    }
}



function to_base(base, num) {
    const largest_power = ~~(Math.log(num) / Math.log(base));
    const result = [];
    for (let pow = largest_power; pow >= 0; pow--) {
        const digit = ~~(num / base ** pow);
        num -= digit * base ** pow;
        result.push(digit);
    }
    return result;
}

to_base(2, 13) // [1, 1, 0, 1]
to_base(10, 458) // [4, 5, 8]
to_base(32, 1024) // [1, 0, 0]
to_base(32, 1023) // [31, 31]