Làm cách nào để chuyển đổi một chuỗi trong bytearray bằng JavaScript. Đầu ra phải tương đương với mã C # bên dưới.

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

Vì UnicodeEncoding được mặc định là UTF-16 với Little-Endianness.

Chỉnh sửa: Tôi có yêu cầu khớp phía máy khách được tạo bytearray với phía máy khách được tạo ở phía máy chủ bằng cách sử dụng mã C # ở trên.

Trong C # chạy cái này

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

Sẽ tạo một mảng với

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

Đối với một ký tự có mã lớn hơn 255, nó sẽ trông như thế này

Nếu bạn muốn một hành vi tương tự trong JavaScript, bạn có thể thực hiện việc này (v2 là giải pháp mạnh mẽ hơn một chút, trong khi phiên bản gốc sẽ chỉ hoạt động với 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(', '));

Nếu bạn đang tìm kiếm một giải pháp hoạt động trong node.js, bạn có thể sử dụng điều này:

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

Tôi cho rằng C # và Java tạo ra các mảng byte bằng nhau. Nếu bạn có các ký tự không phải ASCII, thì không đủ để thêm một số 0. Ví dụ của tôi chứa một vài ký tự đặc biệt:

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

Tôi không biết C # có đặt BOM (Byte Order Marks) không, nhưng nếu sử dụng UTF-16, Java String.getBytessẽ thêm các byte sau: 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

Biên tập:

Đã thêm một ký tự đặc biệt (U + 1D11E) BIỂU TƯỢNG ÂM NHẠC G CLEF (bên ngoài BPM, vì vậy không chỉ lấy 2 byte trong UTF-16 mà còn 4 byte.

Các phiên bản JavaScript hiện tại sử dụng "UCS-2" trong nội bộ, vì vậy ký hiệu này chiếm khoảng cách của 2 ký tự bình thường.

Tôi không chắc nhưng khi sử dụng charCodeAt, có vẻ như chúng tôi nhận được chính xác điểm mã thay thế cũng được sử dụng trong UTF-16, vì vậy các ký tự không phải BPM được xử lý chính xác.

Vấn đề này hoàn toàn không tầm thường. Nó có thể phụ thuộc vào các phiên bản và công cụ JavaScript được sử dụng. Vì vậy, nếu bạn muốn có các giải pháp đáng tin cậy, bạn nên xem:

• https://github.com/koichik/node-codepoint/
• http://mathiasbynens.be/notes/javascript-escapes
• Mạng nhà phát triển Mozilla: charCodeAt
• BigEndian so với LittleEndian

Cách dễ nhất trong năm 2018 nên là TextEncoder nhưng phần tử trả về không phải là mảng byte, nó là Uint8Array. (Và không phải tất cả các trình duyệt đều hỗ trợ nó)

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

Mảng byte UTF-16

JavaScript mã hóa các chuỗi dưới dạng UTF-16 , giống như C # UnicodeEncoding, do đó, các mảng byte phải khớp chính xác bằng cách sử dụng charCodeAt()và tách mỗi cặp byte trả về thành 2 byte riêng biệt, như trong:

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

Ví dụ:

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

Tuy nhiên, nếu bạn muốn nhận một mảng UTF-8 byte, bạn phải chuyển mã các byte.

Mảng byte UTF-8

Giải pháp có vẻ hơi không tầm thường, nhưng tôi đã sử dụng mã bên dưới trong môi trường sản xuất có lưu lượng truy cập cao và thành công lớn ( nguồn gốc ).

Ngoài ra, đối với độc giả quan tâm, tôi đã xuất bản trình trợ giúp unicode của mình để giúp tôi làm việc với độ dài chuỗi được báo cáo bởi các ngôn ngữ khác như 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;
}

Lấy cảm hứng từ câu trả lời của @ hgoebl. Mã của anh ấy là UTF-16 và tôi cần thứ gì đó cho US-ASCII. Vì vậy, đây là câu trả lời đầy đủ hơn bao gồm US-ASCII, UTF-16 và 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 có độ dài thay đổi và không được bao gồm vì tôi sẽ phải tự viết mã hóa. UTF-8 và UTF-16 có độ dài thay đổi. UTF-8, UTF-16 và UTF-32 có số bit tối thiểu như tên của chúng chỉ ra. Nếu một ký tự UTF-32 có điểm mã là 65 thì điều đó có nghĩa là có 3 số 0 đứng đầu. Nhưng cùng một mã cho UTF-16 chỉ có 1 đầu 0. Mặt khác US-ASCII là 8-bit có độ rộng cố định có nghĩa là nó có thể được dịch trực tiếp sang byte.

String.prototype.charCodeAttrả về số lượng tối đa là 2 byte và khớp chính xác với UTF-16. Tuy nhiên đối với UTF-32String.prototype.codePointAt là cần thiết, là một phần của đề xuất ECMAScript 6 (Hài hòa). Vì charCodeAt trả về 2 byte là nhiều ký tự khả dĩ hơn US-ASCII có thể đại diện, nên hàm stringToAsciiByteArraysẽ ném vào các trường hợp như vậy thay vì chia đôi ký tự và lấy một hoặc cả hai byte.

Lưu ý rằng câu trả lời này là không tầm thường vì mã hóa ký tự là không tầm thường. Loại mảng byte bạn muốn phụ thuộc vào kiểu mã hóa ký tự bạn muốn các byte đó đại diện.

javascript có tùy chọn sử dụng nội bộ UTF-16 hoặc UCS-2 nhưng vì nó có các phương thức hoạt động giống như UTF-16 nên tôi không hiểu tại sao bất kỳ trình duyệt nào cũng sử dụng UCS-2. Cũng thấy: https://mathiasbynens.be/notes/javascript-encoding

Vâng, tôi biết câu hỏi đã có từ 4 năm trước nhưng tôi cần câu trả lời này cho chính mình.

Vì tôi không thể bình luận về câu trả lời, tôi sẽ xây dựng câu trả lời của 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);

bằng cách nói rằng bạn có thể sử dụng điều này nếu bạn muốn sử dụng bộ đệm Node.js trong trình duyệt của mình.

https://github.com/feross/buffer

Do đó, lời phản đối của Tom Stickel là không có cơ sở, và câu trả lời thực sự là một câu trả lời xác đáng.

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

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

Giải pháp tốt nhất mà tôi đưa ra tại chỗ (mặc dù rất có thể là thô thiển) sẽ là:

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

Mặc dù tôi nhận thấy câu hỏi này đã ở đây hơn một năm.

Tôi biết câu hỏi đã có từ gần 4 năm trước, nhưng đây là điều đã diễn ra suôn sẻ với tôi:

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

hoặc nếu bạn chỉ muốn làm việc với chuỗi và không có Mảng, bạn có thể sử dụng:

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

Đây là cùng một hàm mà @BrunoLM đã đăng được chuyển đổi thành một hàm nguyên mẫu Chuỗi:

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

Nếu bạn định nghĩa hàm như vậy, thì bạn có thể gọi phương thức .getBytes () trên bất kỳ chuỗi nào:

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

Bạn không cần gạch dưới, chỉ cần sử dụng bản đồ tích hợp sẵn:

var string = 'Hello World!';

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