2016 년 업데이트 -5 년이 지난 지금 사양에 새로운 인코딩 방법 (아래 지원 참조)이있어 적절한 인코딩을 사용하여 문자열과 유형 배열 사이를 변환합니다.

TextEncoder

는 다음을 TextEncoder나타냅니다 .

TextEncoder인터페이스 같은 특정 문자 인코딩하는 구체적인 방법에 대한 인코더를 나타내고 utf-8,iso-8859-2, koi8,
cp1261, gbk, … 인코더는 코드 포인트 스트림을 입력으로 사용하여 바이트 스트림을 생성합니다.

위의 내용이 기록 된 이후 변경 사항 : (ibid.)

참고 : Firefox, Chrome 및 Opera는 utf-8 이외의 인코딩 유형 (예 : utf-16, iso-8859-2, koi8, cp1261 및 gbk)을 지원했습니다. Firefox 48 […], Chrome 54 […] 및 Opera 41에서 사양과 일치시키기 위해 utf-8 이외의 다른 인코딩 유형은 사용할 수 없습니다. *

*) 업데이트 된 사양 (W3) 및 여기 (whatwg)

인스턴스를 만든 후에 TextEncoder는 문자열을 가져와 주어진 인코딩 매개 변수를 사용하여 인코딩합니다.

if (!("TextEncoder" in window))
  alert("Sorry, this browser does not support TextEncoder...");

var enc = new TextEncoder(); // always utf-8
console.log(enc.encode("This is a string converted to a Uint8Array"));

그런 다음 .buffer결과 Uint8Array에 매개 변수를 사용하여 ArrayBuffer필요한 경우 언더 레이 를 다른보기 로 변환하십시오 .

문자열의 문자가 인코딩 스키마를 준수하는지 확인하십시오. 예를 들어, 예제에서 UTF-8 범위를 벗어난 문자를 사용하는 경우 1 바이트가 아닌 2 바이트로 인코딩됩니다.

일반적으로 UTF-16 인코딩을 다음과 같은 용도로 사용합니다 localStorage.

TextDecoder

마찬가지로 반대 프로세스 는 다음을 사용합니다TextDecoder .

TextDecoder인터페이스는 특정 문자 인코딩, 추천되는 특정 방법하는 디코더 나타내고 utf-8, iso-8859-2, koi8,
cp1261, gbk, … 디코더 입력으로 바이트 스트림을 취하여 코드 포인트 스트림을 방출한다.

사용 가능한 모든 디코딩 유형은 여기 에서 찾을 수 있습니다 .

if (!("TextDecoder" in window))
  alert("Sorry, this browser does not support TextDecoder...");

var enc = new TextDecoder("utf-8");
var arr = new Uint8Array([84,104,105,115,32,105,115,32,97,32,85,105,110,116,
                          56,65,114,114,97,121,32,99,111,110,118,101,114,116,
                          101,100,32,116,111,32,97,32,115,116,114,105,110,103]);
console.log(enc.decode(arr));

MDN StringView 라이브러리

이에 대한 대안은 StringView라이브러리 (lgpl-3.0으로 라이센스)를 사용하는 것입니다. 목표는 다음과 같습니다.

• JavaScript ArrayBuffer 인터페이스를 기반으로 문자열에 대한 C와 같은 인터페이스 (즉, 문자 코드 배열-JavaScript의 ArrayBufferView)를 작성
• StringView.prototype 객체에 메소드를 추가하여 누구나 확장 할 수있는 확장 성이 뛰어난 라이브러리를 만드는 방법
• 불변의 새로운 JavaScript 캐릭터 라인을 생성하는 것이 아니라, 숫자의 배열로 엄격하게 동작하는 캐릭터 라인과 같은 객체에 대한 메소드의 콜렉션을 작성하는 (지금부터는 stringViews)
• JavaScript의 기본 UTF-16 DOMString 이외의 유니 코드 인코딩 작업

훨씬 더 많은 유연성을 제공합니다. 그러나 최신 브라우저에 TextEncoder/ TextDecoder가 내장되어있는 동안이 라이브러리에 링크하거나 내장해야 합니다.

지원하다

2018 년 7 월 기준 :

TextEncoder (실험, 표준 트랙)

 Chrome    | Edge      | Firefox   | IE        | Opera     | Safari
 ----------|-----------|-----------|-----------|-----------|-----------
     38    |     ?     |    19°    |     -     |     25    |     -

 Chrome/A  | Edge/mob  | Firefox/A | Opera/A   |Safari/iOS | Webview/A
 ----------|-----------|-----------|-----------|-----------|-----------
     38    |     ?     |    19°    |     ?     |     -     |     38

°) 18: Firefox 18 implemented an earlier and slightly different version
of the specification.

WEB WORKER SUPPORT:

Experimental, On Standard Track

 Chrome    | Edge      | Firefox   | IE        | Opera     | Safari
 ----------|-----------|-----------|-----------|-----------|-----------
     38    |     ?     |     20    |     -     |     25    |     -

 Chrome/A  | Edge/mob  | Firefox/A | Opera/A   |Safari/iOS | Webview/A
 ----------|-----------|-----------|-----------|-----------|-----------
     38    |     ?     |     20    |     ?     |     -     |     38

Data from MDN - `npm i -g mdncomp` by epistemex

답변

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

function str2ab(str) {
  var buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
  var bufView = new Uint16Array(buf);
  for (var i=0, strLen=str.length; i<strLen; i++) {
    bufView[i] = str.charCodeAt(i);
  }
  return buf;
}

<pre id="results"></pre>

<script>
  if ('TextDecoder' in window) {
    // The local files to be fetched, mapped to the encoding that they're using.
    var filesToEncoding = {
      'utf8.bin': 'utf-8',
      'utf16le.bin': 'utf-16le',
      'macintosh.bin': 'macintosh'
    };

    Object.keys(filesToEncoding).forEach(function(file) {
      fetchAndDecode(file, filesToEncoding[file]);
    });
  } else {
    document.querySelector('#results').textContent = 'Your browser does not support the Encoding API.'
  }

  // Use XHR to fetch `file` and interpret its contents as being encoded with `encoding`.
  function fetchAndDecode(file, encoding) {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', file);
    // Using 'arraybuffer' as the responseType ensures that the raw data is returned,
    // rather than letting XMLHttpRequest decode the data first.
    xhr.responseType = 'arraybuffer';
    xhr.onload = function() {
      if (this.status == 200) {
        // The decode() method takes a DataView as a parameter, which is a wrapper on top of the ArrayBuffer.
        var dataView = new DataView(this.response);
        // The TextDecoder interface is documented at http://encoding.spec.whatwg.org/#interface-textdecoder
        var decoder = new TextDecoder(encoding);
        var decodedString = decoder.decode(dataView);
        // Add the decoded file's text to the <pre> element on the page.
        document.querySelector('#results').textContent += decodedString + '\n';
      } else {
        console.error('Error while requesting', file, this);
      }
    };
    xhr.send();
  }
</script>

var uint8array = new TextEncoder().encode(string);
var string = new TextDecoder(encoding).decode(uint8array);

function arrayBufferToString(buffer){

    var bufView = new Uint16Array(buffer);
    var length = bufView.length;
    var result = '';
    var addition = Math.pow(2,16)-1;

    for(var i = 0;i<length;i+=addition){

        if(i + addition > length){
            addition = length - i;
        }
        result += String.fromCharCode.apply(null, bufView.subarray(i,i+addition));
    }

    return result;

}

function string2ArrayBuffer(string, callback) {
    var bb = new BlobBuilder();
    bb.append(string);
    var f = new FileReader();
    f.onload = function(e) {
        callback(e.target.result);
    }
    f.readAsArrayBuffer(bb.getBlob());
}

function arrayBuffer2String(buf, callback) {
    var bb = new BlobBuilder();
    bb.append(buf);
    var f = new FileReader();
    f.onload = function(e) {
        callback(e.target.result)
    }
    f.readAsText(bb.getBlob());
}

string2ArrayBuffer("abc",
    function (buf) {
        var uInt8 = new Uint8Array(buf);
        console.log(uInt8); // Returns `Uint8Array { 0=97, 1=98, 2=99}`

        arrayBuffer2String(buf,
            function (string) {
                console.log(string); // returns "abc"
            }
        )
    }
)

var binaryString = String.fromCharCode.apply(null, new Uint8Array(arrayBuffer));

var
  binaryString = '',
  bytes = new Uint8Array(arrayBuffer),
  length = bytes.length;
for (var i = 0; i < length; i++) {
  binaryString += String.fromCharCode(bytes[i]);
}

function readBinaryStringFromArrayBuffer (arrayBuffer, onSuccess, onFail) {
  var reader = new FileReader();
  reader.onload = function (event) {
    onSuccess(event.target.result);
  };
  reader.onerror = function (event) {
    onFail(event.target.error);
  };
  reader.readAsBinaryString(new Blob([ arrayBuffer ],
    { type: 'application/octet-stream' }));
}

var buf = new ArrayBuffer( 10 );
var view = new Uint8Array( buf );
view[ 3 ] = 4;
alert(Array.prototype.slice.call(view).join(""));

var arr = new Array(23);
// New Uint8Array() converts the Array elements
//  to Uint8s & creates a new ArrayBuffer
//  to store them in & a corresponding view.
//  To get at the generated ArrayBuffer,
//  you can then access it as below, with the .buffer property
var buf = new Uint8Array( arr ).buffer;

var buf, view, str;
buf = new ArrayBuffer( 256 );
view = new Uint8Array( buf );

view[ 0 ] = 7; // Some dummy values
view[ 2 ] = 4;

// ...

// 1. Buffer -> String (as byte array "list")
str = bufferToString(buf);
alert(str); // Alerts "7,0,4,..."

// 1. String (as byte array) -> Buffer    
buf = stringToBuffer(str);
alert(new Uint8Array( buf )[ 2 ]); // Alerts "4"

// Converts any ArrayBuffer to a string
//  (a comma-separated list of ASCII ordinals,
//  NOT a string of characters from the ordinals
//  in the buffer elements)
function bufferToString( buf ) {
    var view = new Uint8Array( buf );
    return Array.prototype.join.call(view, ",");
}
// Converts a comma-separated ASCII ordinal string list
//  back to an ArrayBuffer (see note for bufferToString())
function stringToBuffer( str ) {
    var arr = str.split(",")
      , view = new Uint8Array( arr );
    return view.buffer;
}

function rawStringToBuffer( str ) {
    var idx, len = str.length, arr = new Array( len );
    for ( idx = 0 ; idx < len ; ++idx ) {
        arr[ idx ] = str.charCodeAt(idx) & 0xFF;
    }
    // You may create an ArrayBuffer from a standard array (of values) as follows:
    return new Uint8Array( arr ).buffer;
}

// Alerts "97"
alert(new Uint8Array( rawStringToBuffer("abc") )[ 0 ]);