La conversion de tableau d'octets chaîne de caractères en javascript

Vous devez analyser chaque octet de retour à nombre de, et utiliser cette valeur pour obtenir un caractère, quelque chose comme ceci:

function bin2String(array) {
  var result = "";
  for (var i = 0; i < array.length; i++) {
    result += String.fromCharCode(parseInt(array[i], 2));
  }
  return result;
}

bin2String(["01100110", "01101111", "01101111"]); //"foo"

//Using your string2Bin function to test:
bin2String(string2Bin("hello world")) === "hello world";

Edit: Oui, votre string2Bin peut plus être rédigé peu de temps:

function string2Bin(str) {
  var result = [];
  for (var i = 0; i < str.length; i++) {
    result.push(str.charCodeAt(i).toString(2));
  }
  return result;
}

Mais en regardant la documentation est lié, je pense que le setBytesParameter méthode s'attend à ce que la goutte tableau contient les nombres décimaux, pas un chaîne de bits, de sorte que vous pouvez écrire quelque chose comme ceci:

function string2Bin(str) {
  var result = [];
  for (var i = 0; i < str.length; i++) {
    result.push(str.charCodeAt(i));
  }
  return result;
}

function bin2String(array) {
  return String.fromCharCode.apply(String, array);
}

string2Bin('foo'); //[102, 111, 111]
bin2String(string2Bin('foo')) === 'foo'; //true

Essayer le nouveau Texte de l'Encodage de l'API:

JS:

//create an array view of some valid bytes
let bytesView = new Uint8Array([104, 101, 108, 108, 111]);

console.log(bytesView);

//convert bytes to string
//encoding can be specfied, defaults to utf-8 which is ascii.
let str = new TextDecoder().decode(bytesView); 

console.log(str);

//convert string to bytes
//encoding can be specfied, defaults to utf-8 which is ascii.
let bytes2 = new TextEncoder().encode(str);

//look, they're the same!
console.log(bytes2);
console.log(bytesView);

Je pense que ce serait plus efficace:

function toBinString (arr) {
    var uarr = new Uint8Array(arr.map(function(x){return parseInt(x,2)}));
    var strings = [], chunksize = 0xffff;
    //There is a maximum stack size. We cannot call String.fromCharCode with as many arguments as we want
    for (var i=0; i*chunksize < uarr.length; i++){
        strings.push(String.fromCharCode.apply(null, uarr.subarray(i*chunksize, (i+1)*chunksize)));
    }
    return strings.join('');
}

Même si je suis un peu en retard, j'ai pensé qu'il serait intéressant pour les futurs utilisateurs de partager quelques one-liners implémentations que j'ai fait à l'aide d'ES6.

Une chose que je considère importantes en fonction de votre environnement ou/et de ce que vous allez faire avec les données est de conserver toute la valeur d'un octet. Par exemple, (5).toString(2) vous donnera 101, mais le binaire complet de conversion est en réalité 00000101, et c'est pourquoi vous pourriez avoir besoin pour créer un leftPad mise en œuvre pour remplir la chaîne d'octets avec des zéros. Mais vous ne pouvez pas besoin, comme d'autres réponses démontré.

Si vous exécutez l'extrait de code ci-dessous, vous pouvez voir le premier résultat de la conversion de la abc chaîne en un tableau d'octets et juste après la re-transformation de ce tableau à la chaîne correspondante.

JS:

//For each byte in our array, retrieve the char code value of the binary value
const binArrayToString = array => array.map(byte => String.fromCharCode(parseInt(byte, 2))).join('')

//Basic left pad implementation to ensure string is on 8 bits
const leftPad = str => str.length < 8 ? (Array(8).join('0') + str).slice(-8) : str

//For each char of the string, get the int code and convert it to binary. Ensure 8 bits.
const stringToBinArray = str => str.split('').map(c => leftPad(c.charCodeAt().toString(2)))

const array = stringToBinArray('abc')

console.log(array)
console.log(binArrayToString(array))

N'ai pas trouvé de solution qui fonctionne avec les caractères UTF-8. String.fromCharCode est bon jusqu'à ce que vous rencontrer 2 octets caractère.

Par exemple Hüser viendra comme [0x44,0x61,0x6e,0x69,0x65,0x6c,0x61,0x20,0x48,0xc3,0xbc,0x73,0x65,0x72]

Mais si vous allez à travers elle avec String.fromCharCode vous aurez Hüser comme chaque octet sera converti en char séparément.

Solution

Actuellement, je suis en utilisant la solution suivante:

function pad(n) { return (n.length < 2 ? '0' + n : n); }
function decodeUtf8(data) {
  return decodeURIComponent(
    data.map(byte => ('%' + pad(byte.toString(16)))).join('')
  );
}

Trop tard pour répondre, mais si votre entrée est en forme d'octets ASCII, alors vous pouvez essayer cette solution:

function convertArrToString(rArr){
 //Step 1: Convert each element to character
 let tmpArr = new Array();
 rArr.forEach(function(element,index){
    tmpArr.push(String.fromCharCode(element));
});
//Step 2: Return the string by joining the elements
return(tmpArr.join(""));
}

function convertArrToHexNumber(rArr){
  return(parseInt(convertArrToString(rArr),16));
}