Question

我已经尝试过

function binToDec(num) {
    let dec = 0; 
    for(let i = 0; i < num.length; i++) {
        if(num[num.length - (i + 1)] === '1') {
            dec += 2 ** i;
        }
    }
    return dec;
}

console.log(binToDec('1010'));

此代码不是我的代码，它可以工作，但是我想知道它如何将二进制数字转换为十进制，这对您很有帮助，您可以告诉我另一种方法。

我也尝试过

function binToDec(num) {
    let bin = parseInt(num, 2);
    return bin;
}
console.log(binToDec(1010));

我知道这也可以，但是我没有在寻找这个答案。

感谢您的帮助。

Answer 1

我只是从字符串的最后一个字符开始，然后将此位置的值添加到结果中。

string    dec
------  -------
 1010    0
    0    0
   1     0 + 2
  0      2
 1       2 + 8
------  ------
        10

function binToDec(num) {
    let dec = 0;
    for (let i = 0; i < num.length; i++) {
        if (num[num.length - (i + 1)] === '1') {
            dec += 2 ** i;
        }
    }
    return dec;
}

console.log(binToDec('1010')); // 10

另一种方法是从the的左侧开始，然后

将转换后的值乘以基数（2）和
添加字符串的值。

结果现在是转换后的数字。只要索引处的值转换为数字，该方法就适用于所有基数。

function binToDec(num) {
    let dec = 0;
    for (let i = 0; i < num.length; i++) {
        dec *= 2;
        dec += +num[i];
    }
    return dec;
}

console.log(binToDec('1101')); // 13

Answer 2

说明

以10为基数的工作原理。

909 = 900 + 9
    = (9 *   100) + (0 *    10) + (9 *     1)
    = (9 * 10**2) + (0 * 10**1) + (9 * 10**0)

如您所见，以10为底的自然数可以看作是一个总和，其中每个术语的形式为：

digit * base**digit_position

对于任何基地都是如此：

base 2 : 0b101 = (0b1 * 2**2) + (0b0 * 2**1) + (0b1 * 2**0)
base 16 : 0xF0F = (0xF * 16**2) + (0x0 * 16**1) + (0xF * 16**0)

因此，这里是自然数的可能抽象：

function natural_number (base, digits) {
  var sum = 0;
  for (var i = 0; i < digits.length; i++) {
    digit = digits[i];
    digit_position = digits.length - (i + 1);
    sum += digit * base**digit_position;
  }
  return sum;
}

> | natural_number(2, [1, 0, 1]) // 1 * 2**2 + 1 * 2**0
< | 5
> | natural_number(10, [1, 0, 1]) // 1 * 10**2 + 1 * 10**0
< | 101
> | natural_number(16, [1, 0, 1]) // 1 * 16**2 + 1 * 16**0
< | 257

您自己的函数仅采用二进制数（以2为底）。在这种情况下，digit可以为0或1。我们知道，将某物乘以0或1是没有用的，因此加法可以替换为：

if (digit === 1) {
  sum += 2**digit_position;
}

相当于：

if (num[num.length - (i + 1)] === '1') {
  dec += 2 ** i;
}

明白吗？：-）

替代

您对指数运算符（**）感到不满意吗？有一种解决方法。您是否注意到过，将数字乘以10就是向左移动数字一次？

909 * 10 = 9090

实际上，将数字向左移动归结为将该数字乘以其底数：

number *= base

对于任何基地都是如此：

base 2 : 0b11 * 2 = 0b110
base 16 : 0xBEE * 16 + 0xF = 0xBEE0 + 0xF = 0xBEEF

基于此，我们可以构建一种算法，将数字数组转换为数字。以10为底的[9,0,9]作为输入的执行轨迹如下所示：

init  |   0 | n = 0
add 9 |   9 | n += 9
shift |  90 | n *= 10
add 0 |  90 | n += 0
shift | 900 | n *= 10
add 9 | 909 | n += 9

这是一个可能的实现方式：

function natural_number (base, digits) {
  var n = 0;
  for (var i = 0; i < digits.length; i++) {
    n += digits[i];
    if (i + 1 < digits.length) {
      n *= base;
    }
  }
  return n;
}

当然，此功能的作用与以前相同，这是有充分理由的。确实，展开以10为底的计算for的{{1}}循环，您将得到：

[9,0,9]

然后扩展此表达式：

return ((0 + 9) * 10 + 0) * 10 + 9;

您知道前面讨论的方程式吗？：-）

奖金

反向功能：

((0 + 9) * 10 + 0) * 10 + 9
= (0 + 9) * 10 * 10 + 0 * 10 + 9
= 9 * 10 * 10 + 0 * 10 + 9
= 9 * 10**2 + 0 * 10**1 + 9 * 10**0

function explode_natural_number (base, number) {
  var remainder, exploded = [];
  while (number) {
    remainder = number % base;
    exploded.unshift(remainder);
    number = (number - remainder) / base;
  }
  return exploded.length ? exploded : [0];
}

字符串到数字和数字到字符串：

> | explode_natural_number(2, 5)
< | [1, 0, 1]
> | explode_natural_number(3, 5) // base 3 (5 = 1 * 3**1 + 2 * 3**0) :-)
< | [1, 2]
> | explode_natural_number(16, natural_number(16, [11, 14, 14, 15])) // 0xBEEF
< | [11, 14, 14, 15]

function parse_natural_number (number, base) {
  var ZERO = 48, A = 65; // ASCII codes
  return natural_number(base, number.split("").map(function (digit) {
    return digit.toUpperCase().charCodeAt(0);
  }).map(function (code) {
    return code - (code < A ? ZERO : A - 10);
  }));
}

function stringify_natural_number (number, base) {
  var ZERO = 48, A = 65; // ASCII codes
  return String.fromCharCode.apply(
    String, explode_natural_number(base, number).map(function (digit) {
      return digit + (digit < 10 ? ZERO : A - 10);
    })
  );
}

更多抽象级别以方便使用：

> | stringify_natural_number(parse_natural_number("48879", 10), 16)
< | "BEEF"
> | parse_natural_number("10", 8)
< | 8

function bin_to_dec (number) {
  return parse_natural_number(number, 2);
}

function oct_to_dec (number) {
  return parse_natural_number(number, 8);
}

function dec_to_dec (number) {
  return parse_natural_number(number, 10);
}

function hex_to_dec (number) {
  return parse_natural_number(number, 16);
}

function num_to_dec (number) {
  switch (number[0] + number[1]) {
    case "0b" : return bin_to_dec(number.slice(2));
    case "0x" : return hex_to_dec(number.slice(2));
    default : switch (number[0]) {
      case "0" : return oct_to_dec(number.slice(1));
      default : return dec_to_dec(number);
    }
  }
}

> | oct_to_dec("10")
< | 8
> | num_to_dec("010")
< | 8
> | 010 // :-)
< | 8

function dec_to_bin (number) {
  return stringify_natural_number(number, 2);
}

JavaScript程序将二进制转换为十进制并返回

2 个答案:

说明

替代

奖金