Преобразование двоичного кода в текст с помощью javascript

Ответ 1

Используйте toString(2) для преобразования в двоичную строку. Например:

var input = document.getElementById("inputDecimal").value;
document.getElementById("outputBinary").value = parseInt(input).toString(2);

или parseInt(input,10), если вы знаете, что вход должен быть десятичным. В противном случае ввод "0x42" будет анализироваться как шестнадцатеричный, а не десятичный.

EDIT: просто перечитайте вопрос. Чтобы перейти от двоичного к тексту, используйте parseInt (input, 2).toString(10).

Все вышеперечисленное предназначено только для чисел. Например, 4 ↔ 0100. Если вы хотите 4 ↔ decimal 52 (его значение ASCII), используйте String.fromCharCode() (см. этот ответ).

EDIT 2: для каждого запроса, где все подходит, попробуйте следующее:

function BinToText() {
    var input = document.getElementById("inputBinary").value;
    document.getElementById("outputText").value = parseInt(input,2).toString(10);
}
...
<textarea autofocus class="inputBinary" id="inputBinary" onKeyUp="BinToText()"></textarea>
<textarea class="outputBinary" id="outputText" readonly></textarea>

Если вы поместите 0100 в inputBinary, вы должны получить 4 в outputText (не тестируется).

Ответ 2

Недавно я завершил упражнение, используя цикл for. Надеюсь, что это полезно:

function binaryAgent(str) {

var newBin = str.split(" ");
var binCode = [];

for (i = 0; i < newBin.length; i++) {
    binCode.push(String.fromCharCode(parseInt(newBin[i], 2)));
  }
return binCode.join("");
}
binaryAgent('01000001 01110010 01100101 01101110 00100111 01110100');
//translates to "Aren't"

EDIT: узнав больше JavaScript, я смог сократить решение:

function binaryAgent(str) {

var binString = '';

str.split(' ').map(function(bin) {
    binString += String.fromCharCode(parseInt(bin, 2));
  });
return binString;
}
binaryAgent('01000001 01110010 01100101 01101110 00100111 01110100');
//translates to "Aren't"

Ответ 3

Я знаю, что это поздно, я просто бросаю свои 2 цента, чтобы помочь сообществу. Я столкнулся с тем, что хотел, чтобы Binary преобразовывался в текст, и это то, что я придумал.

Надеюсь, что это поможет кому-то здесь.

function binaryToWords(str) { 
    if(str.match(/[10]{8}/g)){
        var wordFromBinary = str.match(/([10]{8}|\s+)/g).map(function(fromBinary){
            return String.fromCharCode(parseInt(fromBinary, 2) );
        }).join('');
        return console.log(wordFromBinary);
    }
}

binaryToWords('01000011 01101111 01100110 01100110 01100101 01100101 00100000 01101001 01110011 00100000 01100011 01101111 01101100 01100100 ');

Ответ 4

Подобно другому ответу, если кто-то все еще ищет это. первый split возвращает список строк, каждый из которых представляет двоичный символ .

Затем мы назовем отображение на каждой из этих строк, например, "11001111" или что-то еще, и вернем fromCharCode для этого элемента с вставкой parseInt. Затем положите .join() на общее возвращаемое значение, и оно должно работать.

function binaryAgent3(str) {

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

}

Исходная проблема: http://www.freecodecamp.com/challenges/binary-agents

Ответ 5

Вот код, который я написал, который преобразует двоичный код в строку. Единственное различие - оно короче и зависит от встроенных функций JS.

function binarytoString(str) {
  return str.split(/\s/).map(function (val){
    return String.fromCharCode(parseInt(val, 2));
  }).join("");
}

Ответ 6

Как насчет этого?

function binaryAgent(str) {
  var splitStr = str.split(" ");
  var newVar = splitStr.map(function(val) {
    return String.fromCharCode(parseInt(val,2).toString(10));
  });
  str = newVar.join("");
  return str;
}

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111"); // should return "Aren't bonfires fun!?"

Ответ 7

если вы ищете 1 линию решения.

function binary(str) {
return str.split(/\s/g).map((x) => x = String.fromCharCode(parseInt(x, 2))).join("");
}
//returns "one line"
binary("01101111 01101110 01100101 00100000 01101100 01101001 01101110 01100101");

Ответ 8

Это должно работать, и вам не нужно давать ему "симпатичный" двоичный файл.

function binaryToString(binary) {
  return binary.replace(/[01]{8}/g, function(v){ 
    return String.fromCharCode(parseInt(v, 2)); 
  });
}

Ответ 9

Мое решение очень похоже на карту, только я использовал сокращение. Разбейте его на массив, используйте сокращение, чтобы преобразовать символы и добавить их в новый массив и объединить новый массив.

function binaryAgent(str) {
  var sentence = str.split(" ").reduce(function(x, y){
    x.push(String.fromCharCode(parseInt(y, 2)));
    return x;
  }, []).join('');

  return sentence;
}

Ответ 10

Другой подобный ответ, если кто-то ищет этот

function binaryAgent(str) {

  var strArray = str.split(" ");
  var text ="";
  for(var i = 0 ; i<strArray.length ; i++){
    var char = parseInt(strArray[i],2).toString(10);
    char = String.fromCharCode(char);
    text += char;
  }
  return text;

}

binaryAgent("01101101 01100101 01110110");

Ответ 11

Проблема, которую я нашел в каждом провидентном решении, заключалась в том, что если двоичная строка не является "довольно печатной", она не преобразует ее в строку:

function binaryAgent(str) {
  var binString = '';

  str.split(' ').map(function(bin) {
      binString += String.fromCharCode(parseInt(bin, 2));
  });

  return binString;
}
// This displays "Aren't"
binaryAgent('01000001 01110010 01100101 01101110 00100111 01110100');
//But this not
binaryAgent('010000010111001001100101011011100010011101110100');

Быстрое решение состоит в том, чтобы удалить все пробелы из строки (если они есть, в противном случае команда разделить не работает) каждые 8 ​​символов:

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(" ");

  var binString = '';

  str.split(' ').map(function(bin) {
      binString += String.fromCharCode(parseInt(bin, 2));
  });

  return binString;
}

// Both display "Aren't"
binaryAgent('01000001 01110010 01100101 01101110 00100111 01110100');
binaryAgent('010000010111001001100101011011100010011101110100');

Ответ 12

Для тех, кто предпочитает forfor() вместо циклов, также работает следующее:

    function binaryToHuman(str) {
    // split string into an array so we can loop through it
    var newStr=str.split(" ");
    // declare a new array to later push "translated" values into
    var sArr=[];
    // loop through binary array, translate and push translated values into the new array
    newStr.forEach(function(item){
    sArr.push(String.fromCharCode(parseInt(item,2)));
    })

    // join the array back into a string
    return sArr.join("");
    }

    console.log(binaryToHuman("01001001 00100000 01101100 01101111 01110110 01100101 00100001"));
   // returns:
   // I love!

Ответ 13

Мое решение просто использует регулярное выражение для разделения байтов в массив, перебирает каждый байт, преобразует двоичный код в ascii и превращает его в строку в конце

function binaryAgent(str) {

  //Splits into an array
  var re = /\s/;
  var newArr=str.split(re)
  var answerArr =[];

  //Decimal Conversion
  for (let i=0; i<newArr.length; i++){
    answerArr.push(String.fromCharCode(parseInt(newArr[i],2)));
  }

  return answerArr.join('');


}

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");

Ответ 14

Это также операция, которую вы можете делегировать в прототипе String, хотя редко рекомендуется обновлять глобальный тип объекта.

/** Returns a converted binary string to text */
String.prototype.binaryToText = function() {
  return this
    .match(/.{1,8}/g)
    .join(' ')
    .split(' ')
    .reduce((a, c) => a += String.fromCharCode(parseInt(c, 2)), '');
}

const result = '01110101011100000010000001110110011011110111010001100101'.binaryToText();
console.log(result);

Ответ 15

Если вы знаете, что передается только двоичный файл, вы можете использовать эту функцию, которая имеет только одну простую строку:

function binaryAgent(str) {
  return str.split(" ").map(input => String.fromCharCode(parseInt(input,2).toString(10))).join("");

}

// Calling the function
binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");