Aprende a convertir una cadena binaria en un valor legible por humanos o un valor legible por humanos en una cadena binaria con Javascript.

Cómo convertir una cadena de texto binaria en una cadena de t exto legible y viceversa con JavaScript

Un código binario es una representación de un texto, instrucciones del procesador de computadora u otros datos que utilizan un sistema de dos símbolos, a menudo el sistema de números binarios es 0 y 1. El código binario asigna un patrón de dígitos binarios (bits) a cada carácter, instrucción , etc. Por ejemplo, una cadena binaria de ocho bits puede representar cualquiera de los 256 valores posibles y, por lo tanto, puede representar una variedad de elementos diferentes. Aunque con otros lenguajes la conversión de una cadena a su notación binaria no es tan rápida y fácil con lenguajes como Python o C++ (usando bitset<8>), aún se puede lograr con 3 o 4 líneas de código.

En este artículo, aprenderá cómo convertir una cadena en su valor binario y un valor binario en una cadena legible por humanos usando Javascript.

Pruebas

En este artículo, compartiremos con usted un par de métodos que convierten cadenas legibles en su representación binaria o cadenas binarias en cadenas legibles. Para verificar si esos métodos funcionan como se esperaba, vamos a probar el método en cada objeto almacenado en la siguiente variable TestBlock:

var TestBlock = [
    {
        binary: "01010010 01100101 01100001 01101100 00100000 01110000 01110010 01101111 01100111 01110010 01100001 01101101 01110011 00100000 01100100 01101111 01101110 00100111 01110100 00100000 01100101 01100001 01110100 00100000 01100011 01100001 01100011 01101000 01100101 00101110",
        text: "Real programs don't eat cache."
    },
    {
        binary: "010011010110111101110011011101  0000100000011100000111010101100010011011000110100101100011001000   000110010001101111011011010110000101101001011011100010000001110011011011110110011001110100011101110110000101110010011001010010000001101001011100110010000001100110011100100110010101100101001011000010000001100001011101000010000001101100011001010                         1100001011100110111010000100000011000010111010000100     000011001100110100101110010011100110   11101000010000001100111011011000110000101101110011000110110010100101110",
        text: "Most public domain software is free, at least at first glance."
    },
    {
        binary: "010101000110100     00110111101110011011001010010000001110111011010000110111100100000011001000110111 1001000000110111 00110111101110100001000000111010101101110011001000110010101110010011100110111010001100001011011100110010000100 00001010101011011100110100101111000001000000110000101110010011001010010000001100011011011110110111001100100011001010110110101101110011001010110  0100001000000111010001101111001000000111001001100101011010010110111001110110011001010110111001 110100 00100000011010010111010000101100001000000111000001101111011011110111001001101100011110010010111000100000001011010010110100100000010010000110010101101110011100100111100    10010000001010011011100000110010101101110011000110110010101110010",
        text: "Those who do not understand Unix are condemned to reinvent it, poorly. -- Henry Spencer"
    },
    {
        binary: "01000110010011110101001001010100 0101001001000001010011100010000001101001011100110010000001100110011011110111001000100000011100000110100101110000011001010010000001110011011101000111001001100101011100110111001100100000011001100111001001100101011000010110101101110011001000000110000101101110011001000010000001100011011100 1001111001011100110111010001100001011011000110110001101111011001110111001001100001011100000110100001111001001000000111011101100101011001010110111001101001011001010111001100101110",
        text: "FORTRAN is for pipe stress freaks and crystallography weenies."
    },
    {
        binary: "00101111 01100101 01100001 01110010 01110100 01101000 00100000 01101001 011100    11 00100000 00111001 00111000 00100101 00100000 01100110 01110101 01101100 01101  100 00100000 00101110 00101110 00101110 00100000 01110000 01101100 01100101 01100001 01110011 01100101 00100000 01100100 01100101 01101100 01100101 01110100 01100101 00100000 01100001 0110 1110 011110  01 01101111 01101110 01100101 00100000 01111001 01101111 01110101 00100000 01100011 01100001 01101110 00101110   ",
        text: "/earth is 98% full ... please delete anyone you can."
    }
];

Habiendo dicho eso, ¡comencemos!

Cadena legible a binario

Para convertir una cadena legible por humanos a su valor binario, use la siguiente función:

/**
 * Función que convierte una cadena en su representación binaria
 * 
 * @see https://gist.github.com/eyecatchup/6742657
 * @author https://github.com/eyecatchup
 */
function stringToBinary(str, spaceSeparatedOctets) {
    function zeroPad(num) {
        return "00000000".slice(String(num).length) + num;
    }

    return str.replace(/[\s\S]/g, function(str) {
        str = zeroPad(str.charCodeAt().toString(2));
        return !1 == spaceSeparatedOctets ? str : str + " "
    });
};

Y puedes usarlo fácilmente:

// "01001000 01100101 01101100 01101100 01101111 00100000 01000010 01101001 01101110 01100001 01110010 01111001 00100000 01010111 01101111 01110010 01101100 01100100"
stringToBinary("Hello Binary World");

Pero, ¿cómo funciona este código? La cadena proporcionada El charCodeAtmétodo devuelve el Unicode del primer carácter de una cadena. El toString()método analiza su primer argumento e intenta devolver una representación de cadena en la raíz especificada (base). Para radixes superiores a 10, las letras del alfabeto indican números mayores que 9. Por ejemplo, para números hexadecimales (base 16), se utilizan de la a a la f.

Si proporciona los segundos parámetros ( spaceSeparatedOctets) a 0, entonces la cadena no estará "impresa de forma bonita" (los octetos no estarán separados). La prueba para el stringToBinarymétodo es la siguiente (tenga en cuenta que el método stringToBinary agrega un carácter vacío al final de la cadena devuelta, por lo que es recomendable utilizar el método trim para eliminarlo):

var testsSuccesfullyExecuted = 0;
var testErrors = [];

TestBlock.forEach(function(item , index){
    var processedBinaryString = item.binary;
    // Elimina los espacios de la cadena binaria.
    processedBinaryString = processedBinaryString.replace(/\s+/g, '');
     // Binario de impresión bonito (correcto) (agregue un espacio cada 8 caracteres)
    processedBinaryString = processedBinaryString.match(/.{1,8}/g).join(" ");

    // Eliminar espacios al final de la cadena generada stringToBinary
    if(stringToBinary(item.text).trim() == processedBinaryString){
        console.log("Test ${"+ index +"} passes");
        testsSuccesfullyExecuted++;
    }else{
        testErrors.push(index);
    }
});

if(testsSuccesfullyExecuted == TestBlock.length){
    console.log("Test suite succesfully executed with no errors");
}else{
    console.error("Test failed with : " + JSON.stringify(testErrors));
}

Proporcionando la siguiente salida en la consola:

Test ${0} passes
Test ${1} passes
Test ${2} passes
Test ${3} passes
Test ${4} passes
Test suite succesfully executed with no errors

Con un benchmark estándar ejecutado en una computadora personal con las siguientes especificaciones:

  • Windows 10 Pro de 64 bits (10.0, compilación 14393) - Versión de Chrome 56.0.2924.87 (64 bits)
  • CPU Intel (R) Core (TM) i7-7700 a 3,60 GHz (8 CPU), ~ 3,6 GHz
  • 8192 MB de RAM

La función stringToBinary necesitó 1322.53 milisegundos para ejecutar la prueba 10K veces con una ejecución promedio por tarea de 0.13194000000025843 milisegundos.

Cadena binaria a legible

Para convertir una cadena binaria en una cadena legible, puede utilizar cualquiera de los 2 métodos siguientes binaryToStringbinaryAgent:

Opción 1

Esta función elimina todos los espacios vacíos de la cadena y la dividirá en bloques de 8 caracteres que se unirán en una sola cadena. Entonces el metodo String.fromCharCode hara el trabajo por ti:

function binaryToString(str) {
    // Removes the spaces from the binary string
    str = str.replace(/\s+/g, '');
    // Pretty (correct) print binary (add a space every 8 characters)
    str = str.match(/.{1,8}/g).join(" ");

    var newBinary = str.split(" ");
    var binaryCode = [];

    for (i = 0; i < newBinary.length; i++) {
        binaryCode.push(String.fromCharCode(parseInt(newBinary[i], 2)));
    }
    
    return binaryCode.join("");
}

Y el uso:

// Both of them return: "Hello Binary World"
binaryToString("0100100001100101011011000110110001101111001000000100001001101001011011100110000101110010011110010010000001010111011011110111001001101100011001000010000000100001");
binaryToString("01001000 01100101 01101100 01101100 01101111 00100000 01000010 01101001 01101110 01100001 01110010 01111001 00100000 01010111 01101111 01110010 01101100 01100100 00100000 00100001");

El código de prueba para binaryToString es el siguiente:

var testsSuccesfullyExecuted = 0;
var testErrors = [];

TestBlock.forEach(function(item , index){
    if(binaryToString(item.binary) == item.text){
        console.log("Test ${"+ index +"} passes");
        testsSuccesfullyExecuted++;
    }else{
        testErrors.push(index);
    }
});

if(testsSuccesfullyExecuted == TestBlock.length){
    console.log("Test suite succesfully executed with no errors");
}else{
    console.error("Test failed with : " + JSON.stringify(testErrors));
}

La siguiente prueba generará el siguiente contenido en la consola:

Test ${0} passes
Test ${1} passes
Test ${2} passes
Test ${3} passes
Test ${4} passes
Test suite succesfully executed with no errors

Opcion 2

De la misma forma que lo hace la primera función, se eliminarán todos los espacios vacíos y la cadena se dividirá en bloques de 8 caracteres para finalmente unirse.

function binaryAgent(str) {
     // Removes the spaces from the binary string
     str = str.replace(/\s+/g, '');
     // Pretty (correct) print binary (add a space every 8 characters)
     str = str.match(/.{1,8}/g).join(" ");

     return str.split(" ").map(function (elem) {
         return String.fromCharCode(parseInt(elem, 2));
     }).join("");
}

Y el uso:

// Both of them return: "Hello Binary World"
binaryAgent("0100100001100101011011000110110001101111001000000100001001101001011011100110000101110010011110010010000001010111011011110111001001101100011001000010000000100001");
binaryAgent("01001000 01100101 01101100 01101100 01101111 00100000 01000010 01101001 01101110 01100001 01110010 01111001 00100000 01010111 01101111 01110010 01101100 01100100 00100000 00100001");

El código de prueba para binaryAgent es el siguiente:

var testsSuccesfullyExecuted = 0;
var testErrors = [];

TestBlock.forEach(function(item , index){
    if(binaryAgent(item.binary) == item.text){
        console.log("Test ${"+ index +"} passes");
        testsSuccesfullyExecuted++;
    }else{
        testErrors.push(index);
    }
});

if(testsSuccesfullyExecuted == TestBlock.length){
    console.log("Test suite succesfully executed with no errors");
}else{
    console.error("Test failed with : " + JSON.stringify(testErrors));
}

La siguiente prueba generará el siguiente contenido en la consola:

Test ${0} passes
Test ${1} passes
Test ${2} passes
Test ${3} passes
Test ${4} passes
Test suite succesfully executed with no errors

Punto de referencia

El resultado de un benchmark estándar (ejecutado 10K veces) con una computadora personal con las siguientes especificaciones:

  • Windows 10 Pro de 64 bits (10.0, compilación 14393) - Versión de Chrome 56.0.2924.87 (64 bits)
  • CPU Intel (R) Core (TM) i7-7700 a 3,60 GHz (8 CPU), ~ 3,6 GHz
  • 8192 MB de RAM

ha generado el siguiente resultado:

Method Total time (MS) Average time (MS) / Task
binaryToString (Option 1) 1068.54 0.10662899999999208
binaryAgent (Option 2) 1304.80 0.13019300000001968

Como puede ver, el primer método es un poco más rápido que el segundo.

Que te diviertas ❤️!


Interesado en la programación desde los 14 años, Carlos es un programador autodidacta, fundador y autor de la mayoría de los artículos de Our Code World.

Conviertete en un programador más sociable

Patrocinadores