JavaScript kullanarak bytearray'deki bir dizeyi nasıl dönüştürebilirim. Çıktı, aşağıdaki C # koduna eşdeğer olmalıdır.

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

UnicodeEncoding varsayılan olarak Little-Endianness ile UTF-16'dır.

Düzenleme: Bytearray tarafından oluşturulan istemci tarafını, yukarıdaki C # kodunu kullanarak sunucu tarafında oluşturulanla eşleştirme gereksinimim var.

C # bunu çalıştırıyor

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

İle bir dizi oluşturacak

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

Kod 255'ten büyük olan bir karakter için şöyle görünecektir

JavaScript'te çok benzer bir davranış istiyorsanız, bunu yapabilirsiniz (v2 biraz daha sağlam bir çözümdür, orijinal sürüm ise yalnızca 0x00 ~ 0xff için çalışacaktır)

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'de çalışan bir çözüm arıyorsanız, bunu kullanabilirsiniz:

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 # ve Java'nın eşit bayt dizileri ürettiğini düşünüyorum. ASCII olmayan karakterleriniz varsa, fazladan 0 eklemek yeterli değildir. Örneğim birkaç özel karakter içerir:

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 # 'nin BOM (Bayt Sırası İşaretleri) yerleştirip yerleştirmediğini bilmiyorum, ancak UTF-16 kullanılıyorsa, Java String.getBytesaşağıdaki baytları ekler: 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

Düzenle:

Özel bir karakter eklendi (U + 1D11E) MUSICAL SYMBOL G CLEF (BPM dışında, bu nedenle UTF-16'da sadece 2 bayt değil, 4.

Mevcut JavaScript sürümleri dahili olarak "UCS-2" kullanır, bu nedenle bu sembol 2 normal karakterlik yer kaplar.

Emin değilim ama kullanırken charCodeAt UTF-16'da da kullanılan yedek kod noktalarını tam olarak alıyoruz, bu nedenle BPM olmayan karakterler doğru şekilde işleniyor.

Bu sorun kesinlikle önemsiz değildir. Kullanılan JavaScript sürümlerine ve motorlarına bağlı olabilir. Dolayısıyla, güvenilir çözümler istiyorsanız, şunlara bir göz atmalısınız:

• https://github.com/koichik/node-codepoint/
• http://mathiasbynens.be/notes/javascript-escapes
• Mozilla Geliştirici Ağı: charCodeAt
• BigEndian ve LittleEndian

2018'deki en kolay yol TextEncoder olmalıdır, ancak döndürülen öğe bayt dizisi değil, Uint8Array'dir. (Ve tüm tarayıcılar bunu desteklemez)

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

UTF-16 Bayt Dizisi

JavaScript, dizeleri tıpkı C # 'ler gibi UTF-16 olarak kodlar UnicodeEncoding, bu nedenle bayt dizileri charCodeAt(), aşağıdaki gibi döndürülen her bayt çiftini kullanarak ve bölerek tam olarak eşleşmelidir :

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

Örneğin:

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

Bununla birlikte, UTF-8 bayt dizisi almak istiyorsanız, baytların kodunu dönüştürmelisiniz.

UTF-8 Bayt Dizisi

Çözüm biraz önemsiz gibi görünüyor, ancak aşağıdaki kodu yüksek trafikli bir üretim ortamında büyük bir başarıyla kullandım ( orijinal kaynak ).

Ayrıca, ilgilenen okuyucu için, PHP gibi diğer diller tarafından bildirilen dizi uzunluklarıyla çalışmama yardımcı olan unicode yardımcılarımı yayınladım .

/**
 * 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'ın cevabından esinlenilmiştir. Onun kodu UTF-16 için ve US-ASCII için bir şeye ihtiyacım vardı. İşte US-ASCII, UTF-16 ve UTF-32'yi kapsayan daha eksiksiz bir cevap.

/**@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 değişken uzunluktadır ve kodlamayı kendim yazmam gerektiğinden dahil edilmemiştir. UTF-8 ve UTF-16 değişken uzunluktadır. UTF-8, UTF-16 ve UTF-32, adlarından da anlaşılacağı gibi minimum sayıda bit içerir. Bir UTF-32 karakterinin kod noktası 65 ise, bu, başında 3 0 olduğu anlamına gelir. Ancak UTF-16 için aynı kodda yalnızca 1 önde 0 bulunur. Öte yandan US-ASCII sabit genişlikte 8 bittir, bu da doğrudan baytlara çevrilebileceği anlamına gelir.

String.prototype.charCodeAtmaksimum 2 bayt sayısı döndürür ve UTF-16 ile tam olarak eşleşir. Ancak String.prototype.codePointAt, ECMAScript 6 (Harmony) teklifinin bir parçası olan UTF-32 için gereklidir. CharCodeAt, US-ASCII'nin temsil edebileceğinden daha olası karakter olan 2 bayt döndürdüğünden, işlev stringToAsciiByteArraybu tür durumlarda karakteri ikiye bölmek ve baytlardan birini veya her ikisini birden almak yerine atar.

Karakter kodlaması önemsiz olmadığı için bu cevabın önemsiz olmadığını unutmayın. Ne tür bir bayt dizisi istediğiniz, bu baytların hangi karakter kodlamasını temsil etmesini istediğinize bağlıdır.

javascript, UTF-16 veya UCS-2'yi dahili olarak kullanma seçeneğine sahiptir, ancak UTF-16 gibi davranan yöntemlere sahip olduğundan, herhangi bir tarayıcının neden UCS-2 kullandığını anlamıyorum. Ayrıca bkz .: https://mathiasbynens.be/notes/javascript-encoding

Evet, sorunun 4 yaşında olduğunu biliyorum ama bu cevaba ihtiyacım vardı.

Cevaba yorum yapamayacağım için Jin Izzraeel'in cevabına dayanırdım.

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

Tarayıcınızda bir Node.js arabelleği kullanmak istiyorsanız bunu kullanabileceğinizi söyleyerek.

https://github.com/feross/buffer

Bu nedenle, Tom Stickel'in itirazı geçerli değil ve cevap gerçekten de geçerli bir cevap.

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

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

Yerinde bulduğum en iyi çözüm (büyük olasılıkla kaba olsa da):

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

Yine de bu sorunun bir yıldan fazla süredir burada olduğunu fark ettim.

Sorunun neredeyse 4 yaşında olduğunu biliyorum, ama benim için sorunsuz bir şekilde çalışan şu:

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

veya yalnızca dizelerle çalışmak istiyorsanız ve Array kullanmıyorsanız, şunları kullanabilirsiniz:

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

Burada, @BrunoLM'nin bir String prototip işlevine dönüştürülmüş olarak gönderdiği işlev:

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

İşlevi bu şekilde tanımlarsanız, herhangi bir dizede .getBytes () yöntemini çağırabilirsiniz:

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

Alt çizgiye ihtiyacınız yok, sadece yerleşik haritayı kullanın:

var string = 'Hello World!';

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