Come ottenere una stringa binaria da ArrayBuffer?

Question

Qual è il modo per ottenere una stringa binaria da ArrayBuffer in JavaScript?

Non voglio codificare i byte, solo ottenere la rappresentazione binaria come String.

Grazie in anticipo!

Answer 1

function string2Bin(s) { 
    var b = new Array(); 
    var last = s.length; 
    for (var i = 0; i < last; i++) { 
    var d = s.charCodeAt(i); 
    if (d < 128) 
     b[i] = dec2Bin(d); 
    else { 
     var c = s.charAt(i); 
     alert(c + ' is NOT an ASCII character'); 
     b[i] = -1; 
    } 
    } 
    return b; 
} 

function dec2Bin(d) { 
    var b = ''; 
    for (var i = 0; i < 8; i++) { 
    b = (d%2) + b; 
    d = Math.floor(d/2); 
    } 
    return b; 
} 

Answer 2

Questo vi darà una stringa binaria da un array tipizzato

var bitsPerByte = 8; 
var array = new Uint8Array([0, 50, 100, 170, 200, 255]); 
var string = ""; 

function repeat(str, num) { 
    if (str.length === 0 || num <= 1) { 
     if (num === 1) { 
      return str; 
     } 

     return ''; 
    } 

    var result = '', 
     pattern = str; 

    while (num > 0) { 
     if (num & 1) { 
      result += pattern; 
     } 

     num >>= 1; 
     pattern += pattern; 
    } 

    return result; 
} 

function lpad(obj, str, num) { 
    return repeat(str, num - obj.length) + obj; 
} 

Array.prototype.forEach.call(array, function (element) { 
    string += lpad(element.toString(2), "0", bitsPerByte); 
}); 

console.log(string); 

uscita è

000000000011001001100100101010101100100011111111 

Su jsfiddle

O forse ti stai chiedendo su questo?

function ab2str(buf) { 
    return String.fromCharCode.apply(null, new Uint16Array(buf)); 
} 

Nota: che l'utilizzo apply in questo modo significa che si può colpire la limitazione argomento (alcuni elementi 16000 o così), e quindi si dovrà scorrere gli elementi dell'array invece.

Su html5rocks

Answer 3

Il codice seguente costantemente convertire un ArrayBuffer ad un String e viceversa senza perdere o l'aggiunta di eventuali ulteriori byte.

function ArrayBufferToString(buffer) { 
    return BinaryToString(String.fromCharCode.apply(null, Array.prototype.slice.apply(new Uint8Array(buffer)))); 
} 

function StringToArrayBuffer(string) { 
    return StringToUint8Array(string).buffer; 
} 

function BinaryToString(binary) { 
    var error; 

    try { 
     return decodeURIComponent(escape(binary)); 
    } catch (_error) { 
     error = _error; 
     if (error instanceof URIError) { 
      return binary; 
     } else { 
      throw error; 
     } 
    } 
} 

function StringToBinary(string) { 
    var chars, code, i, isUCS2, len, _i; 

    len = string.length; 
    chars = []; 
    isUCS2 = false; 
    for (i = _i = 0; 0 <= len ? _i < len : _i > len; i = 0 <= len ? ++_i : --_i) { 
     code = String.prototype.charCodeAt.call(string, i); 
     if (code > 255) { 
      isUCS2 = true; 
      chars = null; 
      break; 
     } else { 
      chars.push(code); 
     } 
    } 
    if (isUCS2 === true) { 
     return unescape(encodeURIComponent(string)); 
    } else { 
     return String.fromCharCode.apply(null, Array.prototype.slice.apply(chars)); 
    } 
} 

function StringToUint8Array(string) { 
    var binary, binLen, buffer, chars, i, _i; 
    binary = StringToBinary(string); 
    binLen = binary.length; 
    buffer = new ArrayBuffer(binLen); 
    chars = new Uint8Array(buffer); 
    for (i = _i = 0; 0 <= binLen ? _i < binLen : _i > binLen; i = 0 <= binLen ? ++_i : --_i) { 
     chars[i] = String.prototype.charCodeAt.call(binary, i); 
    } 
    return chars; 
} 

ho provato per round-tripping i seguenti valori in questa jsfiddle: http://jsfiddle.net/potatosalad/jrdLV/

(String) "abc" -> (ArrayBuffer) -> (String) "abc" 
(String) "aΩc" -> (ArrayBuffer) -> (String) "aΩc" 
(Uint8Array) [0,1,255] -> (ArrayBuffer) -> (String) -> (Uint8Array) [0,1,255] 
(Uint16Array) [0,1,256,65535] -> (ArrayBuffer) -> (String) -> (Uint16Array) [0,1,256,65535] 
(Uint32Array) [0,1,256,65536,4294967295] -> (ArrayBuffer) -> (String) -> (Uint32Array) [0,1,256,65536,4294967295]