关于javascript:JavaScript-二进制十六进制

在JavaScript外部的默认状况下，二进制、十六进制、八进制字面量数值，都会主动转为十进制进行运算。

0x22 // 34
0b111 // 7
0o33 // 27
0x22 + 0b111 // 41
0o33 + 12 // 39
(0x33).toString() // 51
(0x33).valueOf() // 51
除了十进制是Javascript默认的数字进制以外，其余三种进制形式平时应用较少，次要在解决底层数据、字节编码或者位运算等时候才会碰到。

进制转换
本文将次要探讨进制转换时的问题。
JavaScript 提供了原生函数，进行十进制与其余各进制之间的互相转换。
其中，从其余进制转换成十进制，有三种形式：parseInt()，Number()，+(一元运算符)。这三种形式都只能转换整数。
从十进制转换成其余进制，能够应用 Number.prototype.toString()。反对小数。

parseInt(str, radix)
第一个参数是须要解析的字符串；其余进制不加前缀。
第二个参数是一个进制基数，示意转换时按什么进制来了解这个字符串，默认值10，示意转十进制。
第二个参数如果非数字，则主动转数字，如无奈转称数字则疏忽该参数；是数字时，必须是 2-36 的整数，超出该范畴，返回 NaN。

parseInt('1111', 2) // 15
parseInt('1234', 8) // 668
parseInt('18af', 16) // 6319
parseInt('1111') // 1111
如果不传入第二参数，则 parseInt 会默认应用十进制来解析字符串；然而，如果字符串以 0x 结尾，会被认为是十六进制数。
而其余进制的字符串，0o21(八进制)，0b11(二进制) 不会以该进制基数主动转换，而是失去 0。
所以，在应用 parseInt 进行进制转换时，为了保障运行后果的正确性和稳定性，第二个参数不能省略。

parseInt('0x21') // 33
parseInt('0o21') // 0
parseInt('0b11') // 0
parseInt('111', 'add') // 111
parseInt('111', '787') // NaN
如果须要解析的字符串中存在对于以后进制基数有效的字符，则会从最高位取无效字符进行转换，没无效字符则返回NaN。

parseInt('88kk', 16) // 136，=== 0x88
parseInt('kk', 16) // NaN
Number()
能够把字符串转为数字，反对其余进制的字符串，默认转成十进制数字。
字符串中如果存在有效的进制字符时，返回 NaN。
记住，须要应用进制前缀，0b，0o，0x。

Number('0b11100') // 28
Number('0o33') // 27
Number('0x33') //51

Number('0x88kk') // NaN
+(一元运算符)
与 Number() 一样，能够把字符串转为数字，反对其余进制的字符串，默认转成十进制数字。
字符串中如果存在有效的进制字符时，返回 NaN。
也须要应用进制前缀。

+'0b11100' // 28
+'0o33' // 27
+'0x33' //51

+'0x88kk' // NaN
能够看到，根本和 Number() 是一样的，都在实质上是对数字的一种转换解决。

Number.prototype.toString(radix)
它反对传入一个进制基数，用于将数字转换成对应进制的字符串，它反对转换小数。
未指定默认值为 10，基数参数的范畴 2-36，超过范畴，报错：RangeError。

15..toString(2) // 1111
585..toString(8) // 1111
4369..toString(16) // 1111
(11.25).toString(2) // 1011.01
自定义转换
除了这些原生函数以外，也能够本人实现进制数字之间的转换函数。
依据相应的规定，就能够实现十进制与二进制、十六进制之间的转换的一些办法。

十进制与十六进制转换
以下代码是针对整数在十进制与十六进制之间的转换，依据根本规定进行换算。
十六进制是以 0-9、a-f 进行形容数字的一种形式，其中 0-9 取自身数字的值，而 a-f 则取 10-15 的值。
且字母不辨别大小写。

function int2Hex (num = 0) {
if (num === 0) {

return '0'

}
const HEXS = '0123456789abcdef'
let hex
while (num) {

hex = HEXS.charAt(num % 16) + hexnum = Math.floor(num / 16)

}
return hex
}
function hex2Int (hex = '') {
if (typeof hex !== 'string' || hex === '') {

return NaN

}
const hexs = [...hex.toLowerCase()]
let resInt = 0
for (let i = 0; i < hexs.length; i++) {

const hv = hexs[i]let num = hv.charCodeAt() < 58 ? +hv : ((code - 97) + 10)resInt = resInt * 16 + num

}
return resInt
}
如果要转换八进制，实际上与十六进制很相似，只需依据八进制的数值范畴进行局部改变即可。八进制个别应用非常少，不独自列出。

上面将重点介绍二进制转换的相干常识，包含小数的二进制示意与转换。

十进制和二进制转换
在十进制与二进制的转换中，咱们将思考小数，了解小数是如何在这两者之间进行转换。
先选定一个数字，比方：11.125 ，咱们看下该数字在二进制里的示意：

(11.125).toString(2) // 1011.001
能够看到，11.125 的二进制示意为：1011.001。上面将以这个数字为例进行转换操作。

十进制数字转换成二进制
首先须要理解的是，二进制小数示意办法是如何得来的：

整数局部，用二进制示意能够如此计算，数字 11：
11 / 2 ———— 1
5 / 2 ———— 1
2 / 2 ———— 0
1 / 2 ———— 1
整数局部的规定，失去的后果是从下往上，倒着排 1011 就是二进制的 11。

小数用二进制示意能够如此计算，小数 0.125：
例如十进制的 0.125
0.125 × 2 = 0.25 ———— 0
0.25 × 2 = 0.5 ———— 0
0.5 × 2 = 1 ———— 1
只有等于1时才完结，如果后果不等于1将会始终循环上来。
小数局部的规定，失去的后果是从上往下，顺着排 0.001 就是二进制的 0.125。

整数 + 小数，所以 11.125 的二进制示意形式：1011.001。
依据以上整数和小数离开计算的规定，就能够得出十进制转二进制的函数，如下：

function c10to2 (num) {
// 整数
const numInteger = Math.floor(num)
// 小数
const numDecimal = num - numInteger

let integers = []
if (numInteger === 0) {

integers = ['0']

} else {

let integerVal = numIntegerwhile(integerVal !== 1) {  integers.push(integerVal % 2 === 0 ? '0' : '1')  integerVal = Math.floor(integerVal / 2)}integers.push('1')

}
const resInteger = integers.reverse().join('')

let decimals = []
if (numDecimal) {

let decimalVal = numDecimal// 最多取49位的长度let count = 49while (decimalVal !== 1 && count > 0) {  decimalVal = decimalVal * 2  if (decimalVal >= 1) {    decimals.push('1')    if (decimalVal > 1) {      decimalVal = decimalVal - 1    }  } else {    decimals.push('0')  }  count--}

}
const resDecimal = decimals.join('')

return resInteger + (resDecimal ? ('.' + resDecimal) : '')
}
小数在转换成二进制时，会存在有限循环的问题，下面的代码里截取了前49个值。
所以，这里就会引出了一个问题，就是常见的一个数字精度问题：0.1 + 0.2 != 0.3。

0.1+ 0.2 != 0.3
间接看一下 0.1 转二进制：
0.1 × 2 = 0.2
0.2 × 2 = 0.4
0.4 × 2 = 0.8
0.8 × 2 = 1.6
0.6 × 2 = 1.2
0.2 × 2 = 0.4 // 循环开始
0.4 × 2 = 0.8
0.8 × 2 = 1.6
0.6 × 2 = 1.2
...
...
有限循环

0.2 转二进制：
0.2 × 2 = 0.4
0.4 × 2 = 0.8
0.8 × 2 = 1.6
0.6 × 2 = 1.2
0.2 × 2 = 0.4 // 循环开始
0.4 × 2 = 0.8
0.8 × 2 = 1.6
0.6 × 2 = 1.2
...
...
有限循环

因为无奈失去1，能够发现无限十进制小数， 0.1 转换成了有限二进制小数 0.00011001100...，0.2 转成了 0.001100110011...。
因为有限循环，必然会导致精度失落，正好 0.1 + 0.2 计算失去的数字在失落精度后的最初一位不为0，所以导致后果为：0.30000000000000004。
如果截取精度后最初一位为0，那天然就不存在后果不相等的状况，如 0.1 + 0.6 === 0.7，事实上，0.1和0.6转二进制后都会失落精度，但截取到的数值都是0，所以相等。
同样不相等的还设有 0.1 + 0.7 !== 0.8等等。
所以是计算时转二进制的精度失落，才导致的 0.1 + 0.2 !== 0.3。

在 JavaScript 中所有数值都以 IEEE-754 规范的 64 bit 双精度浮点数进行存储的。
IEEE 754 规范的 64 位双精度浮点数的小数局部最多反对53位二进制位。
因浮点数小数位的限度而须要先截断二进制数字，再转换为十进制，所以在进行算术计算时会产生误差。

这里能看到，如果十进制小数要被转化为无限二进制小数，那么它计算后的小数第一位数必然要是 5 结尾才行(因为只有 0.5 × 2 能力变为整数)。

二进制数字转换成十进制
办法是：将二进制分成整数和小数两局部，别离进行转换，而后再组合成后果的十进制数值。

整数局部：这里间接应用 parseInt 函数，parseInt('1011', 2) => 11。

小数局部：如 1011.001 的小数位 001，应用下表的计算形式。

小数局部	0	0	1
基数的位数次幂	2-1	2-2	2^-3
每位与基数乘积	0 × (2^-1)	0 × (2-2)	1×(2-3)
每位乘积后果	0	0	0.125

最初的后果是每位乘积后果相加：0+0+0.125 = 0.125。

整数与小数合起来，就失去了 1011.001 的十进制数字：11.125。

依据规定，代码实现如下所示：

function c2To10 (binaryStr = '') {
if (typeof binaryStr !== 'string' || binaryStr === '') {

return NaN

}
const [ binIntStr, binDecStr ] = binaryStr.split('.')
let binDecimal = 0
if (binDecStr) {

binDecimal = [...binDecStr].reduce((res, val, index) => {  res += Number(val) * (2 ** (-(index + 1)))  return res}, 0)

}
return parseInt(binIntStr, 2) + binDecimal
}