Wie bekomme ich Binär-String von ArrayBuffer?

Question

Wie kann man eine binäre Zeichenfolge von ArrayBuffer in JavaScript erhalten?

Ich möchte nicht die Bytes codieren, nur die binäre Darstellung als String erhalten.

Vielen Dank im Voraus!

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

Dies gibt Ihnen eine binäre Zeichenfolge aus einer typisierten Array

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

Ausgang ist

000000000011001001100100101010101100100011111111 

Auf jsfiddle

Oder vielleicht über diese Sie fragen?

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

Anmerkung: Die apply auf diese Weise unter Verwendung bedeutet, dass man das Argument Einschränkung treffen kann (einige 16000 Elemente oder so), und dann werden Sie eine Schleife durch die Array-Elemente haben statt.

Auf html5rocks

Answer 3

Der folgende Code wird konsequent eine ArrayBuffer einen String und wieder zurück, ohne zu verlieren oder das Hinzufügen alle zusätzlichen Bytes konvertieren.

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; 
} 

Getestet habe ich es durch Round-Tripping folgende Werte in diesem 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]