How do you convert numbers between different bases in JavaScript?

[chinmay.sahoo]

Use the parseInt() function, that takes a string as the first parameter, and the base as a second
parameter. So to convert hexadecimal 3F to decimal, use parseInt ("3F", 16);

[TomClarke]

In JavaScript, you can convert numbers between different bases using the built-in methods `parseInt()` and `toString()`. The `parseInt()` function allows you to convert a string representing a number in a specific base to a decimal number. The syntax for using `parseInt()` for base conversion is as follows:

parseInt(string, radix)


Here, `string` is the input string representing the number in a specific base, and `radix` is the base of the number. For example, to convert a binary number (base 2) represented as a string to a decimal number, you would use:

let binaryNumber = "1010";
let decimalNumber = parseInt(binaryNumber, 2);
console.log(decimalNumber); // Output: 10


Conversely, the `toString()` method allows you to convert a decimal number to a string representing the number in a specific base. The syntax for using `toString()` for base conversion is as follows:

number.toString(radix)


Here, `number` is the decimal number you want to convert, and `radix` is the base to which you want to convert the number. For example, to convert a decimal number to a hexadecimal (base 16) string, you would use:

let decimalNumber = 255;
let hexadecimalString = decimalNumber.toString(16);
console.log(hexadecimalString); // Output: "ff"


Another approach to converting numbers between different bases in JavaScript involves the use of bitwise operators. For example, to convert a decimal number to binary, you can use the `toString(2)` method or the `toString(radix)` method as mentioned earlier. However, you can also achieve this using bitwise operators.

Here's an example of converting a decimal number to binary using bitwise operators:

function decimalToBinary(decimalNumber) {
  return (decimalNumber >>> 0).toString(2);
}

let decimalNumber = 10;
let binaryString = decimalToBinary(decimalNumber);
console.log(binaryString); // Output: "1010"


In this example, the unsigned right shift operator (`>>> 0`) is used to perform the conversion to an unsigned 32-bit integer, and then `toString(2)` is used to convert it to a binary string.

Similarly, you can use bitwise operations to convert a binary number to a decimal number. Here's an example:

function binaryToDecimal(binaryString) {
  return parseInt(binaryString, 2);
}

let binaryNumber = "1010";
let decimalNumber = binaryToDecimal(binaryNumber);
console.log(decimalNumber); // Output: 10

In JavaScript, you can also create your own custom functions to perform base conversion for numbers. For instance, to convert a decimal number to any other base, you can use the following function:

function decimalToBase(decimalNumber, base) {
  let result = '';
  while (decimalNumber > 0) {
    result = (decimalNumber % base).toString() + result;
    decimalNumber = Math.floor(decimalNumber / base);
  }
  return result;
}

let decimalNumber = 42;
let binaryNumber = decimalToBase(decimalNumber, 2);
console.log(binaryNumber); // Output: "101010"


In this example, the `decimalToBase` function takes a decimal number and the desired base as parameters and returns a string representing the number in the specified base.

Similarly, you can create a function to convert a number from any base to decimal. Here's an example of converting a binary number to decimal using a custom function:

function baseToDecimal(number, base) {
  return parseInt(number, base);
}

let binaryNumber = "101010";
let decimalNumber = baseToDecimal(binaryNumber, 2);
console.log(decimalNumber); // Output: 42


you can also use the `Number` object to perform base conversions. The `parseInt()` method of the `Number` object can be used to convert a string representing a number in a specific base to a decimal number.

For example, to convert a hexadecimal number (base 16) to a decimal number, you can use the following:

let hexadecimalNumber = "1A";
let decimalNumber = Number.parseInt(hexadecimalNumber, 16);
console.log(decimalNumber); // Output: 26


This approach provides an alternative way to perform base conversions using the `Number` object's method.

Additionally, if you want to pad the converted number with leading zeros to ensure a specific length, you can use the `toString()` method along with the `padStart()` method. Here's an example of converting a decimal number to a padded binary string:

let decimalNumber = 5;
let binaryString = decimalNumber.toString(2).padStart(8, '0');
console.log(binaryString); // Output: "00000101"


In this example, `padStart(8, '0')` ensures that the binary string is at least 8 characters long, padding with leading zeros if necessary.