Comment convertir efficacement une chaîne de caractères en 0 et 1, et des 0 et 1 en chaîne de caractères ?

Question

J'écris une implémentation de bitstream en JavaScript pur. Je représente actuellement les bits sous forme de chaînes de "0" et de "1" - j'ai pensé que ce serait plus efficace que des tableaux de 0 et de 1 et je ne veux pas utiliser Uint32 - et j'ai besoin de convertir des chaînes vers et à partir de cette représentation. Voici ce que j'ai obtenu jusqu'à présent :

function uintToBitString(uint, bit_length) {
    var res = uint.toString(2);
    if (res.length > bit_length) {
        throw new Error("The number " + uint + " is too big to fit in " + 
                        bit_length + " bits");
    }
    if (res.length < bit_length) {
        res = Array(bit_length - res.length + 1).join("0") + res;
    }
    return res;
}

function stringToBinRep(val) {
    var bit_pieces = [];
    for (var i=0; i < val.length; i++) {
        bit_pieces[i] = uintToBitString(val.charCodeAt(i), 8);
    }
    return bit_pieces.join("");
}

function binRepToString(bits) {
    var charCodes = [];
    for (var i=0; i < bits.length; i += 8) {
        charCodes[i / 8] = parseInt(bits.slice(i, i+8), 2);
    }
    return String.fromCharCode.apply(String, charCodes);
}

Bien que je sois familier avec JavaScript, je ne suis pas très versé dans ce qui fait un code plus rapide par rapport à un code plus lent. Existe-t-il un moyen plus efficace de faire ce qui précède en utilisant uniquement du JavaScript pur ?

Answer 1

Une amélioration évidente de la uintToBitString serait comme

function uintToBitString(uint, bit_length) {
    var max = 1 << bit_length;
    if(uint >= max)
        throw new Error("The number " + uint + " is too big to fit in " + 
                        bit_length + " bits");
    return (uint | max).toString(2).substring(1);
}

Quant aux deux autres, je préfère utiliser String.replace là :

function stringToBinRep(val) {
    return val.replace(/./g, function($0) { 
        return uintToBitString($0.charCodeAt(0), 8)
    })
}

function binRepToString(bits) {
    return bits.replace(/.{8}/g, function($0) { 
        return String.fromCharCode(parseInt($0, 2))
    })
}

Cela dit, si les performances sont vraiment importantes, vous devriez utiliser des ints pour les manipulations de bits et non des chaînes 1/0.