是否有一种普遍接受的技术可以有效地将JavaScript字符串转换为ArrayBuffers，反之亦然？具体来说，我希望能够将ArrayBuffer的内容写入localStorage并将其读回。
答案 0 :(得分：169)
尽管使用Blob / FileReader的Dennis和gengkev解决方案有效，但我不建议采用这种方法。它是一个简单问题的异步方法，它比直接解决方案慢得多。我在html5rocks中发布了一个简单且（更快）解决方案的帖子： http://updates.html5rocks.com/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
解决方案是：
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;
}
修改
Encoding API helps solving the string conversion问题。查看Html5Rocks.com上Jeff Posnik对上述原始文章的回复。
摘录：
使用Encoding API可以轻松地在原始字节和本机JavaScript字符串之间进行转换，无论您需要使用哪种标准编码。
<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>
答案 1 :(得分：82)
2016年更新 - 五年后，规范中有新方法（请参阅下面的支持），使用正确的编码在字符串和类型化数组之间进行转换。
TextEncoder接口表示特定方法的编码器， 这是一种特定的字符编码，例如utf-8，编码器将代码点流作为输入和 发出一个字节流。iso-8859-2，koi8，cp1261，gbk，...
自上述内容改为注释：（同上）
注意：Firefox，Chrome和Opera曾经支持编码 utf-8以外的类型（例如utf-16，iso-8859-2，koi8，cp1261和 GBK）。截至Firefox 48 [...]，Chrome 54 [...]和Opera 41，没有 除了utf-8之外，还有其他编码类型可供选择 规范。*
*）Updated specs（W3）和here（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范围之外的字符，则它们将被编码为两个字节而不是一个字节。
对于一般用途，您可以对localStorage等内容使用UTF-16编码。
同样，相反的过程uses the TextDecoder：
TextDecoder接口表示特定方法的解码器， 这是一种特定的字符编码，例如utf-8，iso-8859-2，koi8，cp1261，gbk，...解码器将字节流作为输入并发出 一串代码点。
可以找到所有可用的解码类型here。
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));
替代这些是使用StringView library（许可为lgpl-3.0），其目标是：
- 为字符串创建一个类似C的接口（即一个字符代码数组 - 一个JavaScript中的ArrayBufferView），基于 JavaScript ArrayBuffer接口
- 创建一个高度可扩展的库，任何人都可以通过向对象StringView.prototype添加方法来扩展它。
- 为类似字符串的对象创建方法集合（从现在起：stringViews），它们严格地用于数字数组 而不是创建新的不可变JavaScript字符串
- 使用除JavaScript的默认UTF-16 DOMStrings之外的Unicode编码
提供更多灵活性。但是，在现代浏览器中内置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
答案 2 :(得分：70)
您可以使用由Encoding standard填充的stringencoding library中的TextEncoder和TextDecoder来将字符串转换为ArrayBuffers和从ArrayBuffers转换字符串：
var uint8array = new TextEncoder().encode(string);
var string = new TextDecoder(encoding).decode(uint8array);
答案 3 :(得分：35)
Blob比String.fromCharCode(null,array);
但如果数组缓冲区太大，则会失败。我找到的最佳解决方案是使用String.fromCharCode(null,array);并将其拆分为不会破坏堆栈的操作，但一次比单个char更快。
大型阵列缓冲区的最佳解决方案是：
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;
}
我发现这比使用blob快20倍。它也适用于超过100mb的大字符串。
答案 4 :(得分：20)
基于gengkev的答案，我为两种方式创建了函数，因为BlobBuilder可以处理String和ArrayBuffer：
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"
}
)
}
)
答案 5 :(得分：14)
我建议不要使用
var binaryString = String.fromCharCode.apply(null, new Uint8Array(arrayBuffer));
因为它
Maximum call stack size exceeded错误）如果您确实需要使用同步解决方案，请使用
之类的内容var
binaryString = '',
bytes = new Uint8Array(arrayBuffer),
length = bytes.length;
for (var i = 0; i < length; i++) {
binaryString += String.fromCharCode(bytes[i]);
}
它与前一个一样慢，但工作正常。在编写本文时，似乎没有针对该问题的快速同步解决方案（本主题中提到的所有库对其同步功能使用相同的方法）。
但我真正建议的是使用Blob + FileReader方法
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' }));
}
唯一的缺点（并非全部）是异步。它比以前的解决方案强8-10倍！ （一些细节：对于我的环境的同步解决方案，对于2.4Mb缓冲区需要950-1050毫秒，但对于相同数量的数据，使用FileReader的解决方案的时间大约为100-120毫秒。我已经测试了两个同步解决方案在100Kb的缓冲区上它们几乎同时使用，因此使用'apply'时循环速度并不慢。）
顺便说一下：How to convert ArrayBuffer to and from String作者比较像我这样的两种方法并得到完全相反的结果（his test code is here）为什么会有如此不同的结果？可能是因为他的测试字符串长达1Kb（他称之为“veryLongStr”）。我的缓冲区是一个非常大的JPEG图像，大小为2.4Mb。
答案 6 :(得分：13)
与此处的解决方案不同，我需要转换为/从UTF-8数据转换。为此，我使用（un）escape /（en）decodeURIComponent技巧编写了以下两个函数。它们非常浪费内存，分配编码的utf8字符串长度的9倍，尽管这些应该由gc恢复。只是不要将它们用于100mb文本。
function utf8AbFromStr(str) {
var strUtf8 = unescape(encodeURIComponent(str));
var ab = new Uint8Array(strUtf8.length);
for (var i = 0; i < strUtf8.length; i++) {
ab[i] = strUtf8.charCodeAt(i);
}
return ab;
}
function strFromUtf8Ab(ab) {
return decodeURIComponent(escape(String.fromCharCode.apply(null, ab)));
}
检查它是否有效：
strFromUtf8Ab(utf8AbFromStr('latinкирилицаαβγδεζηあいうえお'))
-> "latinкирилицаαβγδεζηあいうえお"
答案 7 :(得分：12)
（更新请参阅此答案的下半部分，我希望（有希望）提供更完整的解决方案。）
我也遇到过这个问题，下面的内容适用于FF 6（单向）：
var buf = new ArrayBuffer( 10 );
var view = new Uint8Array( buf );
view[ 3 ] = 4;
alert(Array.prototype.slice.call(view).join(""));
不幸的是，当然，您最终会得到数组中值的ASCII文本表示，而不是字符。但它仍然（应该）比循环更有效。
例如。对于上面的示例，结果是0004000000，而不是几个空字符＆amp; a chr（4）。
修改
查看 MDC here后，您可以ArrayBuffer创建Array，如下所示：
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;
要回答原始问题，您可以转换ArrayBuffer＆lt; - ＆gt; String如下：
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，用于将原始Unicode String转换为ArrayBuffer（仅适用于ASCII /单字节字符）
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 ]);
以上允许您从ArrayBuffer - ＆gt;开始String＆amp;再次回到ArrayBuffer，其中字符串可以存储在例如。 .localStorage：）
希望这有帮助，
丹
答案 8 :(得分：7)
我发现我遇到了这种方法的问题，主要是因为我试图将输出写入文件并且它没有正确编码。由于JS似乎使用UCS-2编码（source，source），我们需要进一步扩展此解决方案，这是我的增强解决方案，对我有用。
我对通用文本没有任何困难，但是当它归结为阿拉伯语或韩语时，输出文件没有所有字符，而是显示错误字符
文件输出：
","10k unit":"",Follow:"Õ©íüY‹","Follow %{screen_name}":"%{screen_name}U“’Õ©íü",Tweet:"ĤüÈ","Tweet %{hashtag}":"%{hashtag} ’ĤüÈY‹","Tweet to %{name}":"%{name}U“xĤüÈY‹"},ko:{"%{followers_count} followers":"%{followers_count}…X \Ì","100K+":"100Ì tÁ","10k unit":"Ì è",Follow:"\°","Follow %{screen_name}":"%{screen_name} Ø \°X0",K:"œ",M:"1Ì",Tweet:"¸","Tweet %{hashtag}":"%{hashtag}
<强>原始
","10k unit":"万",Follow:"フォローする","Follow %{screen_name}":"%{screen_name}さんをフォロー",Tweet:"ツイート","Tweet %{hashtag}":"%{hashtag} をツイートする","Tweet to %{name}":"%{name}さんへツイートする"},ko:{"%{followers_count} followers":"%{followers_count}명의 팔로워","100K+":"100만 이상","10k unit":"만 단위",Follow:"팔로우","Follow %{screen_name}":"%{screen_name} 님 팔로우하기",K:"천",M:"백만",Tweet:"트윗","Tweet %{hashtag}":"%{hashtag}
我从dennis' solution和this post找到了信息。
这是我的代码：
function encode_utf8(s) {
return unescape(encodeURIComponent(s));
}
function decode_utf8(s) {
return decodeURIComponent(escape(s));
}
function ab2str(buf) {
var s = String.fromCharCode.apply(null, new Uint8Array(buf));
return decode_utf8(decode_utf8(s))
}
function str2ab(str) {
var s = encode_utf8(str)
var buf = new ArrayBuffer(s.length);
var bufView = new Uint8Array(buf);
for (var i=0, strLen=s.length; i<strLen; i++) {
bufView[i] = s.charCodeAt(i);
}
return bufView;
}
这允许我将内容保存到文件而不会出现编码问题。
工作原理： 它基本上采用组成UTF-8字符的单个8字节块并将它们保存为单个字符（因此以这种方式构建的UTF-8字符可以由1-4个这些字符组成）。 UTF-8以长度为1到4个字节的格式对字符进行编码。我们在这里做的是在URI组件中编码sting，然后获取该组件并将其转换为相应的8字节字符。通过这种方式，我们不会丢失超过1个字节长的UTF8字符所提供的信息。
答案 9 :(得分：4)
嗯，这是一种有点复杂的做同样事情的方式：
var string = "Blah blah blah", output;
var bb = new (window.BlobBuilder||window.WebKitBlobBuilder||window.MozBlobBuilder)();
bb.append(string);
var f = new FileReader();
f.onload = function(e) {
// do whatever
output = e.target.result;
}
f.readAsArrayBuffer(bb.getBlob());
编辑：BlobBuilder长期以来一直被弃用，以支持Blob构造函数，当我第一次写这篇文章时，它不存在。这是一个更新版本。 （是的，这一直是进行转换的一种非常愚蠢的方式，但它只是为了好玩！）
var string = "Blah blah blah", output;
var f = new FileReader();
f.onload = function(e) {
// do whatever
output = e.target.result;
};
f.readAsArrayBuffer(new Blob([string]));
答案 10 :(得分：4)
ES2015：
a=Uint8Array.from(s,(x)=>x.charCodeAt(0))
Uint8Array（33）[2,1 134,140,186,82,70,108,182,233,40,143,247,29,76,245,206,29,87,48,160,78， 225,242,56,236,201,80,80,152,118,92,144,48
s=String.fromCharCode.apply(null,a)
“ºRFl¶é（÷LõÎW0Náò8ìÉPPv\ 0”
答案 11 :(得分：4)
如果您使用了巨大的数组示例arr.length=1000000
您可以使用此代码来避免堆栈回调问题
function ab2str(buf) {
var bufView = new Uint16Array(buf);
var unis =""
for (var i = 0; i < bufView.length; i++) {
unis=unis+String.fromCharCode(bufView[i]);
}
return unis
}
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;
}
答案 12 :(得分：3)
使用mangini的解决方案进行转换，从ArrayBuffer转换为String - ab2str（这是我发现的最优雅，最实用的 - 谢谢！），我遇到了一些问题处理大型数组。更多的是，调用String.fromCharCode.apply(null, new Uint16Array(buf));会引发错误：
arguments array passed to Function.prototype.apply is too large。
为了解决它（绕过），我决定以块的形式处理输入ArrayBuffer。所以修改后的解决方案是：
function ab2str(buf) {
var str = "";
var ab = new Uint16Array(buf);
var abLen = ab.length;
var CHUNK_SIZE = Math.pow(2, 16);
var offset, len, subab;
for (offset = 0; offset < abLen; offset += CHUNK_SIZE) {
len = Math.min(CHUNK_SIZE, abLen-offset);
subab = ab.subarray(offset, offset+len);
str += String.fromCharCode.apply(null, subab);
}
return str;
}
块大小设置为2^16，因为这是我发现在我的开发环境中工作的大小。设置较高的值会导致重复出现相同的错误。可以通过将CHUNK_SIZE变量设置为其他值来更改它。有一个偶数是很重要的。
关于性能的注意事项 - 我没有对此解决方案进行任何性能测试。但是，由于它基于以前的解决方案，并且可以处理大型数组，因此我认为没有理由不使用它。
欢迎提出任何意见（ - ：
答案 13 :(得分：2)
见这里：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays/StringView （基于JavaScript ArrayBuffer接口的字符串的类C接口）
答案 14 :(得分：2)
>>> result = [([1,2,3],4),([7,8,9],10)]
>>> list(map(lambda x: x[0]+[x[1]] , result))
[[1, 2, 3, 4], [7, 8, 9, 10]]
答案 15 :(得分：1)
atob（）返回的“本机”二进制字符串是每个字符1个字节的数组。
所以我们不应该在字符中存储2个字节。
var arrayBufferToString = function(buffer) {
return String.fromCharCode.apply(null, new Uint8Array(buffer));
}
var stringToArrayBuffer = function(str) {
return (new Uint8Array([].map.call(str,function(x){return x.charCodeAt(0)}))).buffer;
}
答案 16 :(得分：1)
对于node.js以及使用https://github.com/feross/buffer的浏览器
function ab2str(buf: Uint8Array) {
return Buffer.from(buf).toString('base64');
}
function str2ab(str: string) {
return new Uint8Array(Buffer.from(str, 'base64'))
}
注意：这里的解决方案对我不起作用。我需要支持node.js和浏览器，只需将UInt8Array序列化为字符串即可。我可以将其序列化为一个数字[]，但会占用不必要的空间。使用该解决方案，因为它是base64，所以我不必担心编码。万一其他人遇到同样的问题...我的两分钱
答案 17 :(得分：1)
就
const buffer = thisReturnsBuffers();
const blob = new Blob([buffer], {type: 'text/plain; charset=utf-8'});
blob.text().then(text => console.log(text));
或
const stringVal = "string here";
const blob = new Blob([stringVal], {type: 'text/plain; charset=utf-8'});
blob.arrayBuffer().then(buffer => console.log(buffer));
你们为什么要把这弄得这么复杂？
答案 18 :(得分：0)
var decoder = new TextDecoder ();
var string = decoder.decode (arrayBuffer);
请参阅https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder/decode
答案 19 :(得分：0)
BlobBuilder早已被Blob对象弃用。比较Dennis＆＃39;中的代码。回答 - 使用BlobBuilder的地方 - 使用下面的代码：
function arrayBufferGen(str, cb) {
var b = new Blob([str]);
var f = new FileReader();
f.onload = function(e) {
cb(e.target.result);
}
f.readAsArrayBuffer(b);
}
请注意与已弃用的方法相比，它更清洁，更少臃肿...是的，这绝对值得考虑。
答案 20 :(得分：0)
我用过这个并且适合我。
function arrayBufferToBase64( buffer ) {
var binary = '';
var bytes = new Uint8Array( buffer );
var len = bytes.byteLength;
for (var i = 0; i < len; i++) {
binary += String.fromCharCode( bytes[ i ] );
}
return window.btoa( binary );
}
function base64ToArrayBuffer(base64) {
var binary_string = window.atob(base64);
var len = binary_string.length;
var bytes = new Uint8Array( len );
for (var i = 0; i < len; i++) {
bytes[i] = binary_string.charCodeAt(i);
}
return bytes.buffer;
}
答案 21 :(得分：0)
是：
const encstr = (`TextEncoder` in window) ? new TextEncoder().encode(str) : Uint8Array.from(str, c => c.codePointAt(0));
答案 22 :(得分：0)
假设您有一个arrayBuffer binaryStr：
let text = String.fromCharCode.apply(null, new Uint8Array(binaryStr));
，然后将文本分配给状态。
答案 23 :(得分：0)
以下是有效的 Typescript 实现：
bufferToString(buffer: ArrayBuffer): string {
return String.fromCharCode.apply(null, Array.from(new Uint16Array(buffer)));
}
stringToBuffer(value: string): ArrayBuffer {
let buffer = new ArrayBuffer(value.length * 2); // 2 bytes per char
let view = new Uint16Array(buffer);
for (let i = 0, length = value.length; i < length; i++) {
view[i] = value.charCodeAt(i);
}
return buffer;
}
在使用 crypto.subtle 时，我已将其用于许多操作。
答案 24 :(得分：0)
来自脚本：
function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = 65536 + ((u & 1023) << 10) | u1 & 1023
}
if (u <= 127) {
if (outIdx >= endIdx) break;
outU8Array[outIdx++] = u
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
outU8Array[outIdx++] = 192 | u >> 6;
outU8Array[outIdx++] = 128 | u & 63
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
outU8Array[outIdx++] = 224 | u >> 12;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63
} else {
if (outIdx + 3 >= endIdx) break;
outU8Array[outIdx++] = 240 | u >> 18;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63
}
}
outU8Array[outIdx] = 0;
return outIdx - startIdx
}
使用方式：
stringToUTF8Array('abs', new Uint8Array(3), 0, 4);
答案 25 :(得分：0)
最近我还需要为我的一个项目执行此操作，因此进行了深入研究，并从 Google 的开发者社区获得了一个结果，该结果以简单的方式说明了这一点：
用于 ArrayBuffer 到 String
function ab2str(buf) {
return String.fromCharCode.apply(null, new Uint16Array(buf));
}
// Here Uint16 can be different like Uinit8/Uint32 depending upon your buffer value type.
对于字符串到 ArrayBuffer
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;
}
//Same here also for the Uint16Array.
更多详细参考，您可以参考this blog by Google。