ฉันจะแปลงสตริงใน bytearray โดยใช้ JavaScript ได้อย่างไร ผลลัพธ์ควรเทียบเท่ากับรหัส C # ด้านล่าง

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

เนื่องจาก UnicodeEncoding เป็นค่าเริ่มต้นของ UTF-16 ที่มี Little-Endianness

แก้ไข:ฉันมีข้อกำหนดในการจับคู่ฝั่งไคลเอ็นต์ที่สร้างโดย bytearray กับฝั่งเซิร์ฟเวอร์โดยใช้รหัส C # ด้านบน

ใน C # รันสิ่งนี้

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

จะสร้างอาร์เรย์ด้วย

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

สำหรับอักขระที่รหัสมากกว่า 255 จะมีลักษณะดังนี้

หากคุณต้องการพฤติกรรมที่คล้ายกันมากใน JavaScript คุณสามารถทำได้ (v2 เป็นโซลูชันที่มีประสิทธิภาพมากกว่าเล็กน้อยในขณะที่เวอร์ชันดั้งเดิมจะใช้งานได้กับ 0x00 ~ 0xff เท่านั้น)

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

หากคุณกำลังมองหาโซลูชันที่ใช้ได้ใน node.js คุณสามารถใช้สิ่งนี้:

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

ฉันคิดว่า C # และ Java สร้างอาร์เรย์ไบต์ที่เท่ากัน หากคุณมีอักขระที่ไม่ใช่ ASCII การเพิ่ม 0 เพิ่มเติมนั้นไม่เพียงพอตัวอย่างของฉันมีอักขระพิเศษบางตัว:

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

ฉันไม่รู้ว่า C # วาง BOM (Byte Order Marks) หรือไม่ แต่ถ้าใช้ UTF-16 Java String.getBytesจะเพิ่มไบต์ต่อไปนี้: 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

แก้ไข:

เพิ่มอักขระพิเศษ (U + 1D11E) MUSICAL SYMBOL G CLEF (นอก BPM ดังนั้นไม่เพียงแค่ 2 ไบต์ใน UTF-16 แต่ 4

JavaScript เวอร์ชันปัจจุบันใช้ "UCS-2" ภายในสัญลักษณ์นี้จึงใช้พื้นที่ 2 อักขระปกติ

ฉันไม่แน่ใจ แต่เมื่อใช้charCodeAtดูเหมือนว่าเราจะได้รับจุดรหัสตัวแทนที่ใช้ใน UTF-16 ดังนั้นอักขระที่ไม่ใช่ BPM จึงได้รับการจัดการอย่างถูกต้อง

ปัญหานี้ไม่สำคัญอย่างแน่นอน อาจขึ้นอยู่กับเวอร์ชันและเอ็นจิ้น JavaScript ที่ใช้ ดังนั้นหากคุณต้องการโซลูชันที่เชื่อถือได้คุณควรดูที่:

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

วิธีที่ง่ายที่สุดในปี 2018 ควรเป็นTextEncoderแต่องค์ประกอบที่ส่งคืนไม่ใช่อาร์เรย์ไบต์มันคือ Uint8Array (และไม่ใช่ทุกเบราว์เซอร์ที่รองรับ)

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

UTF-16 ไบต์อาร์เรย์

JavaScript เข้ารหัสสตริงเป็นUTF-16เช่นเดียวกับ C # UnicodeEncodingดังนั้นอาร์เรย์ไบต์ควรตรงกันทุกประการโดยใช้charCodeAt()และแยกคู่ไบต์ที่ส่งคืนแต่ละคู่ออกเป็น 2 ไบต์แยกกันดังใน:

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

ตัวอย่างเช่น:

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

อย่างไรก็ตามหากคุณต้องการรับอาร์เรย์ UTF-8 ไบต์คุณต้องแปลงรหัสไบต์

UTF-8 ไบต์อาร์เรย์

วิธีแก้ปัญหานี้ค่อนข้างไม่สำคัญ แต่ฉันใช้โค้ดด้านล่างในสภาพแวดล้อมการผลิตที่มีปริมาณการใช้งานสูงและประสบความสำเร็จอย่างมาก ( ต้นฉบับ )

นอกจากนี้สำหรับผู้อ่านที่สนใจฉันได้เผยแพร่ตัวช่วย Unicode ของฉันที่ช่วยฉันทำงานกับความยาวสตริงที่รายงานโดยภาษาอื่นเช่น PHP

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

แรงบันดาลใจจากคำตอบของ @ hgoebl รหัสของเขาคือ UTF-16 และฉันต้องการบางอย่างสำหรับ US-ASCII นี่คือคำตอบที่สมบูรณ์ยิ่งขึ้นซึ่งครอบคลุม US-ASCII, UTF-16 และ 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 เป็นความยาวตัวแปรและไม่รวมอยู่ด้วยเพราะฉันจะต้องเขียนการเข้ารหัสด้วยตัวเอง UTF-8 และ UTF-16 เป็นความยาวตัวแปร UTF-8, UTF-16 และ UTF-32 มีจำนวนบิตขั้นต่ำตามที่ชื่อระบุ หากอักขระ UTF-32 มีจุดรหัสเป็น 65 นั่นหมายความว่ามี 3 นำหน้า 0 แต่รหัสเดียวกันสำหรับ UTF-16 มีเพียง 1 นำหน้าเท่านั้นในทางกลับกัน US-ASCII คือความกว้างคงที่ 8 บิตซึ่งหมายความว่าสามารถแปลเป็นไบต์ได้โดยตรง

String.prototype.charCodeAtส่งคืนจำนวนสูงสุด 2 ไบต์และตรงกับ UTF-16 ทุกประการ อย่างไรก็ตามสำหรับ UTF-32 String.prototype.codePointAtเป็นสิ่งจำเป็นซึ่งเป็นส่วนหนึ่งของข้อเสนอ ECMAScript 6 (Harmony) เนื่องจาก charCodeAt ส่งคืน 2 ไบต์ซึ่งเป็นอักขระที่เป็นไปได้มากกว่าที่ US-ASCII สามารถแสดงได้ฟังก์ชันstringToAsciiByteArrayจะโยนในกรณีดังกล่าวแทนที่จะแบ่งอักขระออกเป็นครึ่งหนึ่งและใช้ไบต์อย่างใดอย่างหนึ่งหรือทั้งสองอย่าง

โปรดทราบว่าคำตอบนี้ไม่สำคัญเพราะการเข้ารหัสอักขระไม่ใช่เรื่องสำคัญ ชนิดของอาร์เรย์ไบต์ที่คุณต้องการขึ้นอยู่กับอักขระการเข้ารหัสที่คุณต้องการให้ไบต์เหล่านั้นเป็นตัวแทน

javascript มีตัวเลือกในการใช้ภายใน UTF-16 หรือ UCS-2 แต่เนื่องจากมีวิธีการที่เหมือนกับ UTF-16 ฉันไม่เห็นว่าทำไมเบราว์เซอร์ใด ๆ ถึงใช้ UCS-2 ดูเพิ่มเติมที่https://mathiasbynens.be/notes/javascript-encoding

ใช่ฉันรู้ว่าคำถามนี้มีอายุ 4 ปี แต่ฉันต้องการคำตอบนี้สำหรับตัวเอง

เนื่องจากฉันไม่สามารถแสดงความคิดเห็นเกี่ยวกับคำตอบได้ฉันจึงสร้างคำตอบของ Jin Izzraeel

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

โดยบอกว่าคุณสามารถใช้สิ่งนี้ได้หากคุณต้องการใช้บัฟเฟอร์ Node.js ในเบราว์เซอร์ของคุณ

https://github.com/feross/buffer

ดังนั้นการคัดค้านของ Tom Stickel จึงไม่ถูกต้องและคำตอบนั้นเป็นคำตอบที่ถูกต้อง

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

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

ทางออกที่ดีที่สุดที่ฉันคิดไว้ ณ จุดนั้น (แม้ว่าส่วนใหญ่จะเป็นน้ำมันดิบ) คือ:

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

แม้ว่าฉันสังเกตว่าคำถามนี้อยู่ที่นี่มานานกว่าหนึ่งปีแล้ว

ฉันรู้ว่าคำถามเกือบ 4 ปี แต่นี่คือสิ่งที่ทำงานได้อย่างราบรื่นกับฉัน:

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

หรือหากคุณต้องการทำงานกับสตริงเท่านั้นและไม่มี Array คุณสามารถใช้:

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

นี่คือฟังก์ชั่นเดียวกับที่ @BrunoLM โพสต์ที่แปลงเป็นฟังก์ชัน String ต้นแบบ:

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

หากคุณกำหนดฟังก์ชันดังกล่าวคุณสามารถเรียกใช้เมธอด. getBytes () บนสตริงใดก็ได้:

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

คุณไม่จำเป็นต้องมีขีดล่างเพียงแค่ใช้แผนที่ในตัว:

var string = 'Hello World!';

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