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

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

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"

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

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

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 ');

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

затем мы вызываем map на каждой из этих строк, например, "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

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

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

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

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!?"

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

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

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

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

  return sentence;
}

другой аналогичный ответ, если кто-то ищет это

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

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

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');

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

    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!

мое решение просто использует регулярное выражение для разделения байтов на массив, перебирает каждый байт, преобразует двоичный файл в 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");

Если вы ищете 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");