Wie kann ich einen String in Bytearray mit JavaScript konvertieren? Die Ausgabe sollte dem folgenden C # -Code entsprechen.

UnicodeEncoding encoding = new UnicodeEncoding();
byte[] bytes = encoding.GetBytes(AnyString);

Da UnicodeEncoding standardmäßig UTF-16 mit Little-Endianness ist.

Bearbeiten: Ich muss die vom Bytearray generierte Client-Seite mit der auf der Server-Seite generierten Client-Seite mit dem obigen C # -Code abgleichen.

In C # läuft dies

UnicodeEncoding encoding = new UnicodeEncoding();
byte[] bytes = encoding.GetBytes("Hello");

Erstellt ein Array mit

72,0,101,0,108,0,108,0,111,0

Für ein Zeichen, dessen Code größer als 255 ist, sieht es so aus

Wenn Sie ein sehr ähnliches Verhalten in JavaScript wünschen, können Sie dies tun (v2 ist eine etwas robustere Lösung, während die Originalversion nur für 0x00 ~ 0xff funktioniert).

var str = "Hello竜";
var bytes = []; // char codes
var bytesv2 = []; // char codes

for (var i = 0; i < str.length; ++i) {
  var code = str.charCodeAt(i);
  
  bytes = bytes.concat([code]);
  
  bytesv2 = bytesv2.concat([code & 0xff, code / 256 >>> 0]);
}

// 72, 101, 108, 108, 111, 31452
console.log('bytes', bytes.join(', '));

// 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 220, 122
console.log('bytesv2', bytesv2.join(', '));

Wenn Sie nach einer Lösung suchen, die in node.js funktioniert, können Sie Folgendes verwenden:

var myBuffer = [];
var str = 'Stack Overflow';
var buffer = new Buffer(str, 'utf16le');
for (var i = 0; i < buffer.length; i++) {
    myBuffer.push(buffer[i]);
}

console.log(myBuffer);

Ich nehme an, C # und Java erzeugen Arrays mit gleichen Bytes. Wenn Sie Nicht-ASCII-Zeichen haben, reicht es nicht aus, eine zusätzliche 0 hinzuzufügen. Mein Beispiel enthält einige Sonderzeichen:

var str = "Hell ö € Ω 𝄞";
var bytes = [];
var charCode;

for (var i = 0; i < str.length; ++i)
{
    charCode = str.charCodeAt(i);
    bytes.push((charCode & 0xFF00) >> 8);
    bytes.push(charCode & 0xFF);
}

alert(bytes.join(' '));
// 0 72 0 101 0 108 0 108 0 32 0 246 0 32 32 172 0 32 3 169 0 32 216 52 221 30

Ich weiß nicht, ob C # Stückliste (Byte Order Marks) platziert, aber bei Verwendung von UTF-16 String.getBytesfügt Java die folgenden Bytes hinzu: 254 255.

String s = "Hell ö € Ω ";
// now add a character outside the BMP (Basic Multilingual Plane)
// we take the violin-symbol (U+1D11E) MUSICAL SYMBOL G CLEF
s += new String(Character.toChars(0x1D11E));
// surrogate codepoints are: d834, dd1e, so one could also write "\ud834\udd1e"

byte[] bytes = s.getBytes("UTF-16");
for (byte aByte : bytes) {
    System.out.print((0xFF & aByte) + " ");
}
// 254 255 0 72 0 101 0 108 0 108 0 32 0 246 0 32 32 172 0 32 3 169 0 32 216 52 221 30

Bearbeiten:

Ein Sonderzeichen (U + 1D11E) wurde hinzugefügt. MUSICAL SYMBOL G CLEF (außerhalb von BPM, also nicht nur 2 Bytes in UTF-16, sondern 4.

Aktuelle JavaScript-Versionen verwenden intern "UCS-2", sodass dieses Symbol 2 normale Zeichen einnimmt.

Ich bin mir nicht sicher, aber wenn charCodeAtwir es verwenden, erhalten wir anscheinend genau die Ersatzcodepunkte, die auch in UTF-16 verwendet werden, sodass Nicht-BPM-Zeichen korrekt behandelt werden.

Dieses Problem ist absolut nicht trivial. Dies kann von den verwendeten JavaScript-Versionen und Engines abhängen. Wenn Sie also zuverlässige Lösungen wünschen, sollten Sie sich Folgendes ansehen:

• https://github.com/koichik/node-codepoint/
• http://mathiasbynens.be/notes/javascript-escapes
• Mozilla Developer Network: charCodeAt
• BigEndian gegen LittleEndian

Der einfachste Weg im Jahr 2018 sollte TextEncoder sein, aber das zurückgegebene Element ist kein Byte-Array, sondern Uint8Array. (Und nicht alle Browser unterstützen es)

let utf8Encode = new TextEncoder();
utf8Encode.encode("eee")
> Uint8Array [ 101, 101, 101 ]

UTF-16-Byte-Array

JavaScript codiert Zeichenfolgen wie die von C # als UTF-16 , UnicodeEncodingsodass die Byte-Arrays genau mit übereinstimmen charCodeAt()und jedes zurückgegebene Byte-Paar in zwei separate Bytes aufteilen sollten, wie in:

function strToUtf16Bytes(str) {
  const bytes = [];
  for (ii = 0; ii < str.length; ii++) {
    const code = str.charCodeAt(ii); // x00-xFFFF
    bytes.push(code & 255, code >> 8); // low, high
  }
  return bytes;
}

Beispielsweise:

strToUtf16Bytes('🌵'); 
// [ 60, 216, 53, 223 ]

Wenn Sie jedoch ein UTF-8-Byte-Array erhalten möchten, müssen Sie die Bytes transkodieren.

UTF-8-Byte-Array

Die Lösung fühlt sich nicht trivial an, aber ich habe den folgenden Code in einer stark frequentierten Produktionsumgebung mit großem Erfolg verwendet ( Originalquelle ).

Für den interessierten Leser habe ich außerdem meine Unicode-Helfer veröffentlicht , die mir helfen, mit Zeichenfolgenlängen zu arbeiten, die von anderen Sprachen wie PHP gemeldet werden.

/**
 * Convert a string to a unicode byte array
 * @param {string} str
 * @return {Array} of bytes
 */
export function strToUtf8Bytes(str) {
  const utf8 = [];
  for (let ii = 0; ii < str.length; ii++) {
    let charCode = str.charCodeAt(ii);
    if (charCode < 0x80) utf8.push(charCode);
    else if (charCode < 0x800) {
      utf8.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));
    } else if (charCode < 0xd800 || charCode >= 0xe000) {
      utf8.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));
    } else {
      ii++;
      // Surrogate pair:
      // UTF-16 encodes 0x10000-0x10FFFF by subtracting 0x10000 and
      // splitting the 20 bits of 0x0-0xFFFFF into two halves
      charCode = 0x10000 + (((charCode & 0x3ff) << 10) | (str.charCodeAt(ii) & 0x3ff));
      utf8.push(
        0xf0 | (charCode >> 18),
        0x80 | ((charCode >> 12) & 0x3f),
        0x80 | ((charCode >> 6) & 0x3f),
        0x80 | (charCode & 0x3f),
      );
    }
  }
  return utf8;
}

Inspiriert von @ hgoebls Antwort. Sein Code ist für UTF-16 und ich brauchte etwas für US-ASCII. Hier ist eine vollständigere Antwort zu US-ASCII, UTF-16 und UTF-32.

/**@returns {Array} bytes of US-ASCII*/
function stringToAsciiByteArray(str)
{
    var bytes = [];
   for (var i = 0; i < str.length; ++i)
   {
       var charCode = str.charCodeAt(i);
      if (charCode > 0xFF)  // char > 1 byte since charCodeAt returns the UTF-16 value
      {
          throw new Error('Character ' + String.fromCharCode(charCode) + ' can\'t be represented by a US-ASCII byte.');
      }
       bytes.push(charCode);
   }
    return bytes;
}
/**@returns {Array} bytes of UTF-16 Big Endian without BOM*/
function stringToUtf16ByteArray(str)
{
    var bytes = [];
    //currently the function returns without BOM. Uncomment the next line to change that.
    //bytes.push(254, 255);  //Big Endian Byte Order Marks
   for (var i = 0; i < str.length; ++i)
   {
       var charCode = str.charCodeAt(i);
       //char > 2 bytes is impossible since charCodeAt can only return 2 bytes
       bytes.push((charCode & 0xFF00) >>> 8);  //high byte (might be 0)
       bytes.push(charCode & 0xFF);  //low byte
   }
    return bytes;
}
/**@returns {Array} bytes of UTF-32 Big Endian without BOM*/
function stringToUtf32ByteArray(str)
{
    var bytes = [];
    //currently the function returns without BOM. Uncomment the next line to change that.
    //bytes.push(0, 0, 254, 255);  //Big Endian Byte Order Marks
   for (var i = 0; i < str.length; i+=2)
   {
       var charPoint = str.codePointAt(i);
       //char > 4 bytes is impossible since codePointAt can only return 4 bytes
       bytes.push((charPoint & 0xFF000000) >>> 24);
       bytes.push((charPoint & 0xFF0000) >>> 16);
       bytes.push((charPoint & 0xFF00) >>> 8);
       bytes.push(charPoint & 0xFF);
   }
    return bytes;
}

UTF-8 hat eine variable Länge und ist nicht enthalten, da ich die Codierung selbst schreiben müsste. UTF-8 und UTF-16 sind variabel lang. UTF-8, UTF-16 und UTF-32 haben eine Mindestanzahl von Bits, wie der Name schon sagt. Wenn ein UTF-32-Zeichen einen Codepunkt von 65 hat, bedeutet dies, dass es 3 führende Nullen gibt. Der gleiche Code für UTF-16 hat jedoch nur 1 führende 0. US-ASCII hingegen hat eine feste Breite von 8 Bit, was bedeutet, dass es direkt in Bytes übersetzt werden kann.

String.prototype.charCodeAtGibt eine maximale Anzahl von 2 Bytes zurück und stimmt genau mit UTF-16 überein. Für UTF-32 String.prototype.codePointAtwird jedoch benötigt, was Teil des ECMAScript 6 (Harmony) -Vorschlags ist. Da charCodeAt 2 Bytes zurückgibt, was mehr mögliche Zeichen sind, als US-ASCII darstellen kann, wird die Funktion stringToAsciiByteArrayin solchen Fällen ausgelöst, anstatt das Zeichen in zwei Hälften zu teilen und eines oder beide Bytes zu verwenden.

Beachten Sie, dass diese Antwort nicht trivial ist, da die Zeichenkodierung nicht trivial ist. Welche Art von Byte-Array Sie möchten, hängt davon ab, welche Zeichencodierung diese Bytes darstellen sollen.

Javascript hat die Möglichkeit, entweder UTF-16 oder UCS-2 intern zu verwenden. Da es jedoch Methoden gibt, die sich wie UTF-16 verhalten, verstehe ich nicht, warum ein Browser UCS-2 verwenden würde. Siehe auch: https://mathiasbynens.be/notes/javascript-encoding

Ja, ich weiß, dass die Frage 4 Jahre alt ist, aber ich brauchte diese Antwort für mich.

Da ich die Antwort nicht kommentieren kann, würde ich auf Jin Izzraeels Antwort aufbauen

var myBuffer = [];
var str = 'Stack Overflow';
var buffer = new Buffer(str, 'utf16le');
for (var i = 0; i < buffer.length; i++) {
    myBuffer.push(buffer[i]);
}

console.log(myBuffer);

indem Sie sagen, dass Sie dies verwenden könnten, wenn Sie einen Node.js-Puffer in Ihrem Browser verwenden möchten.

https://github.com/feross/buffer

Daher ist der Einwand von Tom Stickel nicht gültig, und die Antwort ist in der Tat eine gültige Antwort.

String.prototype.encodeHex = function () {
    return this.split('').map(e => e.charCodeAt())
};

String.prototype.decodeHex = function () {    
    return this.map(e => String.fromCharCode(e)).join('')
};

Die beste Lösung, die ich vor Ort gefunden habe (obwohl höchstwahrscheinlich grob), wäre:

String.prototype.getBytes = function() {
    var bytes = [];
    for (var i = 0; i < this.length; i++) {
        var charCode = this.charCodeAt(i);
        var cLen = Math.ceil(Math.log(charCode)/Math.log(256));
        for (var j = 0; j < cLen; j++) {
            bytes.push((charCode << (j*8)) & 0xFF);
        }
    }
    return bytes;
}

Obwohl ich bemerke, dass diese Frage seit über einem Jahr hier ist.

Ich weiß, dass die Frage fast 4 Jahre alt ist, aber das hat bei mir reibungslos funktioniert:

String.prototype.encodeHex = function () {
  var bytes = [];
  for (var i = 0; i < this.length; ++i) {
    bytes.push(this.charCodeAt(i));
  }
  return bytes;
};

Array.prototype.decodeHex = function () {    
  var str = [];
  var hex = this.toString().split(',');
  for (var i = 0; i < hex.length; i++) {
    str.push(String.fromCharCode(hex[i]));
  }
  return str.toString().replace(/,/g, "");
};

var str = "Hello World!";
var bytes = str.encodeHex();

alert('The Hexa Code is: '+bytes+' The original string is:  '+bytes.decodeHex());

Wenn Sie nur mit Zeichenfolgen und ohne Array arbeiten möchten, können Sie Folgendes verwenden:

String.prototype.encodeHex = function () {
  var bytes = [];
  for (var i = 0; i < this.length; ++i) {
    bytes.push(this.charCodeAt(i));
  }
  return bytes.toString();
};

String.prototype.decodeHex = function () {    
  var str = [];
  var hex = this.split(',');
  for (var i = 0; i < hex.length; i++) {
    str.push(String.fromCharCode(hex[i]));
  }
  return str.toString().replace(/,/g, "");
};

var str = "Hello World!";
var bytes = str.encodeHex();

alert('The Hexa Code is: '+bytes+' The original string is:  '+bytes.decodeHex());

Hier ist dieselbe Funktion, die @BrunoLM veröffentlicht hat und die in eine String-Prototypfunktion konvertiert wurde:

String.prototype.getBytes = function () {
  var bytes = [];
  for (var i = 0; i < this.length; ++i) {
    bytes.push(this.charCodeAt(i));
  }
  return bytes;
};

Wenn Sie die Funktion als solche definieren, können Sie die Methode .getBytes () für eine beliebige Zeichenfolge aufrufen:

var str = "Hello World!";
var bytes = str.getBytes();

Sie brauchen keinen Unterstrich, verwenden Sie einfach die integrierte Karte:

var string = 'Hello World!';

document.write(string.split('').map(function(c) { return c.charCodeAt(); }));