Comment convertir des nombres entre différentes bases en JavaScript ?

Question

Je voudrais convertir des nombres entre différentes bases, telles que hexadécimales et décimales.

Exemple : Comment convertir hexadécimal 8F en décimal ?

Answer 1

Vous pouvez essayer le code suivant, qui prend également en charge les nombres de précision arbitraires (supérieurs à 2^53).

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;
}

Utilisation :

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

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

Le code de base a été trouvé ici, je l'ai un peu amélioré pour supporter également jusqu'à la base 64.

Answer 2

Le schéma suivant peut vous aider. Notez que pour convertir de la base 16 à la base 2, vous devez d'abord convertir à la base 10, puis à la base 2.

Answer 3

Cette fonction génère un nombre décimal à n'importe quelle base de 2 à 36.(comme javascript)

Mais vous pouvez augmenter la base de plus de 36 simplement en ajoutant un nouveau caractère dans keys[] comme minuscule["a","b"]

function toBase(num, radix = 10) { // only i64 numbers
  var keys = ['', '', 2, 3, 4, 5, 6, 7, 8, 9, "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"];
  if (!(radix >= 2 && radix <= keys.length)) throw new RangeError("toBase() radix argument must be between 2 and " + keys.length)

  if (num < 0) var isNegative = true
  if (isNaN(num = Math.abs(+num))) return NaN

  let output = [];
  do {
    let index = num % radix;
    output.unshift(keys[index]);
    num = Math.trunc(num / radix);
  } while (num != 0);
  if (isNegative) output.unshift('-')
  return output.join("");
}

console.log(toBase("100",2))