资讯专栏INFORMATION COLUMN

ES6学习笔记5-编程风格、二进制数组和SIMD

kumfo / 1681人阅读

摘要:二进制数组由三类对象组成对象视图和视图。目前,视图一共包括种类型,每一种视图都是一种构造函数。位浮点数,长度个字节这个构造函数生成的数组,统称为视图。

编程风格 块级作用域

let 取代 var,在let和const之间,建议优先使用const,尤其是在全局环境,不应该设置变量,只应设置常量。

字符串

静态字符串一律使用单引号或反引号,不使用双引号。动态字符串使用反引号。

// good
const a = "foobar";
const b = `foo${a}bar`;
const c = "foobar";
解构赋值

使用数组成员对变量赋值时,优先使用解构赋值。

const arr = [1, 2, 3, 4];

// bad
const first = arr[0];
const second = arr[1];

// good
const [first, second] = arr;

函数的参数如果是对象的成员,优先使用解构赋值。

// bad
function getFullName(user) {
  const firstName = user.firstName;
  const lastName = user.lastName;
}

// good
function getFullName(obj) {
  const { firstName, lastName } = obj;
}

// best
function getFullName({ firstName, lastName }) {
}

如果函数返回多个值,优先使用对象的解构赋值,而不是数组的解构赋值。这样便于以后添加返回值,以及更改返回值的顺序。

对象

单行定义的对象,最后一个成员不以逗号结尾。多行定义的对象,最后一个成员以逗号结尾。

// good
const a = { k1: v1, k2: v2 };
const b = {
  k1: v1,
  k2: v2,
};

对象尽量静态化,一旦定义,就不得随意添加新的属性。如果添加属性不可避免,要使用Object.assign方法。

// bad
const a = {};
a.x = 3;

// if reshape unavoidable
const a = {};
Object.assign(a, { x: 3 });

// good
const a = { x: null };
a.x = 3;

对象的属性和方法,尽量采用简洁表达法,这样易于描述和书写。

var ref = "some value";

// bad
const atom = {
  ref: ref,

  value: 1,

  addValue: function (value) {
    return atom.value + value;
  },
};

// good
const atom = {
  ref,

  value: 1,

  addValue(value) {
    return atom.value + value;
  },
};
数组

使用扩展运算符(...)拷贝数组。使用Array.from方法,将类似数组的对象转为数组。

函数

立即执行函数可以写成箭头函数的形式。

(() => {
  console.log("Welcome to the Internet.");
})();

那些需要使用函数表达式的场合,尽量用箭头函数代替。因为这样更简洁,而且绑定了this。简单的、单行的、不会复用的函数,建议采用箭头函数。如果函数体较为复杂,行数较多,还是应该采用传统的函数写法。

不要在函数体内使用arguments变量,使用rest运算符(...)代替。使用默认值语法设置函数参数的默认值。

// bad
function concatenateAll() {
  const args = Array.prototype.slice.call(arguments);
  return args.join("");
}

// good
function concatenateAll(...args) {
  return args.join("");
}
Map结构

只有模拟现实世界的实体对象时,才使用Object。如果只是需要key: value的数据结构,使用Map结构。因为Map有内建的遍历机制。

Class

总是用Class,取代需要prototype的操作。使用extends实现继承。

模块

坚持使用Module语法,使用import和export。如果模块只有一个输出值,就使用export default,如果模块有多个输出值,就不使用export default,export default与普通的export不要同时使用。

如果模块默认输出一个函数,函数名的首字母应该小写。如果模块默认输出一个对象,对象名的首字母应该大写。

ESLint的使用

ESLint是一个语法规则和代码风格的检查工具,可以用来保证写出语法正确、风格统一的代码。

二进制数组

二进制数组(ArrayBuffer对象、TypedArray视图和DataView视图)是 JavaScript 操作二进制数据的一个接口。它并不是真正的数组,而是类似数组的对象

二进制数组由三类对象组成:ArrayBuffer对象、TypedArray视图和DataView视图。
ArrayBuffer对象代表原始的二进制数据,TypedArray视图用来读写简单类型的二进制数据,DataView视图用来读写复杂类型的二进制数据。

TypedArray视图支持的数据类型一共有9种(DataView视图支持除Uint8C以外的其他8种)。

很多浏览器操作的API,用到了二进制数组操作二进制数据,下面是其中的几个。

File API

XMLHttpRequest

Fetch API

Canvas

WebSockets

ArrayBuffer对象

ArrayBuffer对象代表储存二进制数据的一段内存,它不能直接读写,只能通过视图(TypedArray视图和DataView视图)来读写,视图的作用是以指定格式解读二进制数据。

ArrayBuffer也是一个构造函数,可以分配一段可以存放数据的连续内存区域。

var buf = new ArrayBuffer(32);//生成了一段32字节的内存区域,每个字节的值默认都是0
//DataView视图的创建,需要提供ArrayBuffer对象实例作为参数。
var dataView = new DataView(buf);
dataView.getUint8(0) //0

TypedArray视图,与DataView视图的一个区别是,它不是一个构造函数,而是一组构造函数,代表不同的数据格式。

var buffer = new ArrayBuffer(12);

var x1 = new Int32Array(buffer);
x1[0] = 1;
var x2 = new Uint8Array(buffer);
x2[0]  = 2;

x1[0] // 2

上面代码对同一段内存,分别建立两种视图:32位带符号整数(Int32Array构造函数)和8位不带符号整数(Uint8Array构造函数)。由于两个视图对应的是同一段内存,一个视图修改底层内存,会影响到另一个视图。

TypedArray视图的构造函数,除了接受ArrayBuffer实例作为参数,还可以接受普通数组作为参数,直接分配内存生成底层的ArrayBuffer实例,并同时完成对这段内存的赋值。

var typedArray = new Uint8Array([0,1,2]);
typedArray.length // 3

typedArray[0] = 5;
typedArray // [5, 1, 2]
ArrayBuffer.prototype.byteLength

ArrayBuffer.prototype.byteLength返回所分配的内存区域的字节长度。如果要分配的内存区域很大,有可能分配失败(因为没有那么多的连续空余内存),所以有必要检查是否分配成功。

var buffer = new ArrayBuffer(32);
if (buffer.byteLength === 32) {
  // 成功
} else {
  // 失败
}
ArrayBuffer.prototype.slice()

ArrayBuffer.prototype.slice()允许将内存区域的一部分,拷贝生成一个新的ArrayBuffer对象。slice方法接受两个参数,第一个参数表示拷贝开始的字节序号(含该字节),第二个参数表示拷贝截止的字节序号(不含该字节)。如果省略第二个参数,则默认到原ArrayBuffer对象的结尾。

除了slice方法,ArrayBuffer对象不提供任何直接读写内存的方法,只允许在其上方建立视图,然后通过视图读写。

ArrayBuffer.isView()

ArrayBuffer.isView() 返回一个布尔值,表示参数是否为TypedArray实例或DataView实例。

TypedArray视图

ArrayBuffer对象作为内存区域,可以存放多种类型的数据。同一段内存,不同数据有不同的解读方式,这就叫做“视图”(view)。ArrayBuffer有两种视图,一种是TypedArray视图,另一种是DataView视图。前者的数组成员都是同一个数据类型,后者的数组成员可以是不同的数据类型。

目前,TypedArray视图一共包括9种类型,每一种视图都是一种构造函数。

Int8Array:8位有符号整数,长度1个字节。

Uint8Array:8位无符号整数,长度1个字节。

Uint8ClampedArray:8位无符号整数,长度1个字节,溢出处理不同。

Int16Array:16位有符号整数,长度2个字节。

Uint16Array:16位无符号整数,长度2个字节。

Int32Array:32位有符号整数,长度4个字节。

Uint32Array:32位无符号整数,长度4个字节。

Float32Array:32位浮点数,长度4个字节。

Float64Array:64位浮点数,长度8个字节

这9个构造函数生成的数组,统称为TypedArray视图。它们很像普通数组,都有length属性,都能用方括号运算符([])获取单个元素,所有数组的方法,在它们上面都能使用。

普通数组与TypedArray数组的差异:

TypedArray数组的所有成员,都是同一种类型。

TypedArray数组的成员是连续的,不会有空位。

TypedArray数组成员的默认值为0。比如,new Array(10)返回一个普通数组,里面没有任何成员,只是10个空位;new Uint8Array(10)返回一个TypedArray数组,里面10个成员都是0。

TypedArray数组只是一层视图,本身不储存数据,它的数据都储存在底层的ArrayBuffer对象之中,要获取底层对象必须使用buffer属性。

构造函数

构造函数有多种用法。

TypedArray(buffer, byteOffset=0, length?):
第一个参数(必需):视图对应的底层ArrayBuffer对象。第二个参数(可选):视图开始的字节序号,默认从0开始。第三个参数(可选):视图包含的数据个数,默认直到本段内存区域结束。

同一个ArrayBuffer对象之上,可以根据不同的数据类型,建立多个视图。

// 创建一个8字节的ArrayBuffer
var b = new ArrayBuffer(8);

// 创建一个指向b的Int32视图,开始于字节0,直到缓冲区的末尾
var v1 = new Int32Array(b);

// 创建一个指向b的Uint8视图,开始于字节2,直到缓冲区的末尾
var v2 = new Uint8Array(b, 2);

// 创建一个指向b的Int16视图,开始于字节2,长度为2
var v3 = new Int16Array(b, 2, 2);

上面代码在一段长度为8个字节的内存(b)之上,生成了三个视图:v1、v2和v3。v1、v2和v3是重叠的:v1[0]是一个32位整数,指向字节0~字节3;v2[0]是一个8位无符号整数,指向字节2;v3[0]是一个16位整数,指向字节2~字节3。只要任何一个视图对内存有所修改,就会在另外两个视图上反应出来。

byteOffset必须与所要建立的数据类型一致,否则会报错。

var buffer = new ArrayBuffer(8);
var i16 = new Int16Array(buffer, 1);
// Uncaught RangeError: start offset of Int16Array should be a multiple of 2

上面代码中,新生成一个8个字节的ArrayBuffer对象,然后在这个对象的第一个字节,建立带符号的16位整数视图,结果报错。因为,带符号的16位整数需要两个字节,所以byteOffset参数必须能够被2整除。

如果想从任意字节开始解读ArrayBuffer对象,必须使用DataView视图,因为TypedArray视图只提供9种固定的解读格式。

TypedArray(length):
视图还可以不通过ArrayBuffer对象,直接分配内存而生成。

var f64a = new Float64Array(8);//生成一个8个成员的Float64Array数组(共64字节)
f64a[0] = 10;

上面代码生成一个8个成员的Float64Array数组(共64字节),然后对成员赋值。这时,视图构造函数的参数就是成员的个数。可以看到,视图数组的赋值操作与普通数组的操作毫无两样。

TypedArray(typedArray):
TypedArray数组的构造函数,可以接受另一个TypedArray实例作为参数。

var typedArray = new Int8Array(new Float64Array(5));
//Int8Array构造函数接受一个Uint8Array实例作为参数。
typedArray.byteLength //5

上面代码中生成的新数组,只是复制了参数数组的值,对应的底层内存是不一样的。新数组会开辟一段新的内存储存数据,不会在原数组的内存之上建立视图。

如果想基于同一段内存,构造不同的视图,可以采用下面的写法。

var x = new Int8Array([1, 1]);
var y = new Int8Array(x.buffer);
x[0] // 1
y[0] // 1

x[0] = 2;
y[0] // 2

TypedArray(arrayLikeObject):
构造函数的参数也可以是一个普通数组,然后直接生成TypedArray实例。

var typedArray = new Uint8Array([1, 2, 3, 4]);

这时TypedArray视图会重新开辟内存,不会在原数组的内存上建立视图。

TypedArray数组也可以转换回普通数组。

var normalArray = Array.prototype.slice.call(typedArray);

普通数组的操作方法和属性,对TypedArray数组完全适用(除了concat方法,因为TypedArray数组没有concat方法)。另外,TypedArray数组与普通数组一样,部署了Iterator接口,所以可以被遍历。

字节序

字节序指的是数值在内存中的表示方式。

var buffer = new ArrayBuffer(16);
var int32View = new Int32Array(buffer);
for (var i = 0; i < int32View.length; i++) {
  int32View[i] = i * 2;
}
//上面代码生成一个16字节的ArrayBuffer对象,然后在它的基础上,建立了一个32位整数的视图。由于每个32位整数占据4个字节,所以一共可以写入4个整数,依次为0,2,4,6。


//在这段数据上接着建立一个16位整数的视图,则可以读出完全不一样的结果。
var int16View = new Int16Array(buffer);
for (var i = 0; i < int16View.length; i++) {
  console.log("Entry " + i + ": " + int16View[i]);
}
// Entry 0: 0
// Entry 1: 0
// Entry 2: 2
// Entry 3: 0
// Entry 4: 4
// Entry 5: 0
// Entry 6: 6
// Entry 7: 0

由于每个16位整数占据2个字节,所以整个ArrayBuffer对象现在分成8段。然后,由于x86体系的计算机都采用小端字节序(little endian),相对重要的字节排在后面的内存地址,相对不重要字节排在前面的内存地址,所以就得到了上面的结果。

比如,一个占据四个字节的16进制数0x12345678,决定其大小的最重要的字节是“12”,最不重要的是“78”。小端字节序将最不重要的字节排在前面,储存顺序就是78563412;大端字节序则完全相反,将最重要的字节排在前面,储存顺序就是12345678。目前,所有个人电脑几乎都是小端字节序,所以TypedArray数组内部也采用小端字节序读写数据。

与普通数组相比,TypedArray数组的最大优点就是可以直接操作内存,不需要数据类型转换,所以速度快得多。

BYTES_PER_ELEMENT属性

每一种视图的构造函数,都有一个BYTES_PER_ELEMENT属性,表示这种数据类型占据的字节数。

Int8Array.BYTES_PER_ELEMENT // 1
Uint8Array.BYTES_PER_ELEMENT // 1
Int16Array.BYTES_PER_ELEMENT // 2
Uint16Array.BYTES_PER_ELEMENT // 2
Int32Array.BYTES_PER_ELEMENT // 4
Uint32Array.BYTES_PER_ELEMENT // 4
Float32Array.BYTES_PER_ELEMENT // 4
Float64Array.BYTES_PER_ELEMENT // 8

这个属性在TypedArray实例上也能获取,即有TypedArray.prototype.BYTES_PER_ELEMENT。

ArrayBuffer与字符串的互相转换

ArrayBuffer转为字符串,或者字符串转为ArrayBuffer,有一个前提,即字符串的编码方法是确定的。假定字符串采用UTF-16编码(JavaScript的内部编码方式),可以自己编写转换函数。

// ArrayBuffer转为字符串,参数为ArrayBuffer对象
function ab2str(buf) {
  return String.fromCharCode.apply(null, new Uint16Array(buf));
}

// 字符串转为ArrayBuffer对象,参数为字符串
function str2ab(str) {
  var buf = new ArrayBuffer(str.length * 2); // 每个字符占用2个字节
  var bufView = new Uint16Array(buf);
  for (var i = 0, strLen = str.length; i < strLen; i++) {
    bufView[i] = str.charCodeAt(i);
  }
  return buf;
}
溢出

不同的视图类型,所能容纳的数值范围是确定的。超出这个范围,就会出现溢出。比如,8位视图只能容纳一个8位的二进制值,如果放入一个9位的值,就会溢出。

TypedArray数组的溢出处理规则,简单来说,就是抛弃溢出的位,然后按照视图类型进行解释。

var uint8 = new Uint8Array(1);

uint8[0] = 256;
uint8[0] // 0

uint8[0] = -1;
uint8[0] // 255

上面代码中,uint8是一个8位视图,而256的二进制形式是一个9位的值100000000,这时就会发生溢出。根据规则,只会保留后8位,即00000000。uint8视图的解释规则是无符号的8位整数,所以00000000就是0。

负数在计算机内部采用“2的补码”表示,也就是说,将对应的正数值进行否运算,然后加1。比如,-1对应的正值是1,进行否运算以后,得到11111110,再加上1就是补码形式11111111。uint8按照无符号的8位整数解释11111111,返回结果就是255。

一个简单转换规则,可以这样表示。

正向溢出(overflow):当输入值大于当前数据类型的最大值,结果等于当前数据类型的最小值加上余值,再减去1。
负向溢出(underflow):当输入值小于当前数据类型的最小值,结果等于当前数据类型的最大值减去余值,再加上1。
上面的“余值”就是模运算的结果,即 JavaScript 里面的%运算符的结果。

var int8 = new Int8Array(1);

int8[0] = 128;
int8[0] // -128

int8[0] = -129;
int8[0] // 127

上面例子中,int8是一个带符号的8位整数视图,它的最大值是127,最小值是-128。输入值为128时,相当于正向溢出1,根据“最小值加上余值(128除以127的余值是1),再减去1”的规则,就会返回-128;输入值为-129时,相当于负向溢出1,根据“最大值减去余值(-129除以-128的余值是1),再加上1”的规则,就会返回127。

Uint8ClampedArray视图的溢出规则,与上面的规则不同。它规定,凡是发生正向溢出,该值一律等于当前数据类型的最大值,即255;如果发生负向溢出,该值一律等于当前数据类型的最小值,即0。

TypedArray.prototype.buffer

TypedArray.prototype.buffer返回整段内存区域对应的ArrayBuffer对象。该属性为只读属性。

var a = new Float32Array(64);
var b = new Uint8Array(a.buffer);

上面代码的a视图对象和b视图对象,对应同一个ArrayBuffer对象,即同一段内存。

TypedArray.prototype.byteLength,TypedArray.prototype.byteOffset

byteLength属性返回TypedArray数组占据的内存长度,单位为字节。byteOffset属性返回TypedArray数组从底层ArrayBuffer对象的哪个字节开始。这两个属性都是只读属性。

TypedArray.prototype.length

length属性表示TypedArray数组含有多少个成员。注意将byteLength属性和length属性区分,前者是字节总长度,后者是成员长度。

var a = new Int16Array(4);

a.length // 4
a.byteLength // 8
TypedArray.prototype.set()

TypedArray数组的set方法用于复制数组(普通数组或TypedArray数组),也就是将一段内容完全复制到另一段内存。set方法的第二个参数,表示从b对象的哪一个成员开始复制a对象。

var a = new Uint16Array(8);
var b = new Uint16Array(10);

b.set(a, 2)
//从b[2]开始,将复制a数组的内容到b数组,它是整段内存的复制,比一个个拷贝成员的那种复制快得多。
TypedArray.prototype.subarray()

subarray方法是对于TypedArray数组的一部分,再建立一个新的视图。方法的第一个参数是起始的成员序号,第二个参数是结束的成员序号(不含该成员),如果省略则包含剩余的全部成员。

TypedArray.prototype.slice()

TypeArray实例的slice方法,可以返回一个指定位置的新的TypedArray实例。slice方法的参数,表示原数组的具体位置,开始生成新数组。负值表示逆向的位置,即-1为倒数第一个位置,-2表示倒数第二个位置,以此类推。

TypedArray.of()

TypedArray数组的所有构造函数,都有一个静态方法of,用于将参数转为一个TypedArray实例。
下面三种方法都会生成同样一个TypedArray数组。

// 方法一
let tarr = new Uint8Array([1,2,3]);

// 方法二
let tarr = Uint8Array.of(1,2,3);

// 方法三
let tarr = new Uint8Array(3);
tarr[0] = 1;
tarr[1] = 2;
tarr[2] = 3;
TypedArray.from()

静态方法from接受一个可遍历的数据结构(比如数组)作为参数,返回一个基于这个结构的TypedArray实例。
from方法还可以接受一个函数,作为第二个参数,用来对每个元素进行遍历,功能类似map方法。

Int8Array.of(127, 126, 125).map(x => 2 * x)
// Int8Array [ -2, -4, -6 ]

Int16Array.from(Int8Array.of(127, 126, 125), x => 2 * x)
// Int16Array [ 254, 252, 250 ]

上面的例子中,from方法没有发生溢出,这说明遍历不是针对原来的8位整数数组。也就是说,from会将第一个参数指定的TypedArray数组,拷贝到另一段内存之中,处理之后再将结果转成指定的数组格式。

复合视图

由于视图的构造函数可以指定起始位置和长度,所以在同一段内存之中,可以依次存放不同类型的数据,这叫做“复合视图”。

var buffer = new ArrayBuffer(24);

var idView = new Uint32Array(buffer, 0, 1);
var usernameView = new Uint8Array(buffer, 4, 16);
var amountDueView = new Float32Array(buffer, 20, 1);

上面代码将一个24字节长度的ArrayBuffer对象,分成三个部分:

字节0到字节3:1个32位无符号整数

字节4到字节19:16个8位整数

字节20到字节23:1个32位浮点数

DataView视图

一段数据包括多种类型可通过建立ArrayBuffer对象的复合视图或DataView视图进行操作。

ArrayBuffer对象的各种TypedArray视图,是用来向网卡、声卡之类的本机设备传送数据,所以使用本机的字节序就可以了;而DataView视图的设计目的,是用来处理网络设备传来的数据,所以大端字节序或小端字节序是可以自行设定的。

DataView视图本身也是构造函数,接受一个ArrayBuffer对象作为参数,生成视图。

DataView(ArrayBuffer buffer [, 字节起始位置 [, 长度]]);

DataView实例有以下属性:

DataView.prototype.buffer:返回对应的ArrayBuffer对象。

DataView.prototype.byteLength:返回占据的内存字节长度。

DataView.prototype.byteOffset:返回当前视图从对应的ArrayBuffer对象的哪个字节开始。

DataView实例提供8个方法读取内存:

这一系列get方法的参数都是一个字节序号(不能是负数,否则会报错),表示从哪个字节开始读取

getInt8:读取1个字节,返回一个8位整数。

getUint8:读取1个字节,返回一个无符号的8位整数。

getInt16:读取2个字节,返回一个16位整数。

getUint16:读取2个字节,返回一个无符号的16位整数。

getInt32:读取4个字节,返回一个32位整数。

getUint32:读取4个字节,返回一个无符号的32位整数。

getFloat32:读取4个字节,返回一个32位浮点数。

getFloat64:读取8个字节,返回一个64位浮点数

var buffer = new ArrayBuffer(24);
var dv = new DataView(buffer);

// 从第1个字节读取一个8位无符号整数
var v1 = dv.getUint8(0);

// 从第2个字节读取一个16位无符号整数
var v2 = dv.getUint16(1);

// 从第4个字节读取一个16位无符号整数
var v3 = dv.getUint16(3);

如果一次读取两个或两个以上字节,就必须明确数据的存储方式,到底是小端字节序还是大端字节序。默认情况下,DataView的get方法使用大端字节序解读数据,如果需要使用小端字节序解读,必须在get方法的第二个参数指定true。

DataView视图提供8个方法写入内存:

这一系列set方法,接受两个参数,第一个参数是字节序号,表示从哪个字节开始写入,第二个参数为写入的数据。对于那些写入两个或两个以上字节的方法,需要指定第三个参数,false或者undefined表示使用大端字节序写入,true表示使用小端字节序写入。

setInt8:写入1个字节的8位整数。

setUint8:写入1个字节的8位无符号整数。

setInt16:写入2个字节的16位整数。

setUint16:写入2个字节的16位无符号整数。

setInt32:写入4个字节的32位整数。

setUint32:写入4个字节的32位无符号整数。

setFloat32:写入4个字节的32位浮点数。

setFloat64:写入8个字节的64位浮点数。

二进制数组的应用 AJAX

传统上,服务器通过AJAX操作只能返回文本数据,即responseType属性默认为text。XMLHttpRequest第二版XHR2允许服务器返回二进制数据,这时分成两种情况。如果明确知道返回的二进制数据类型,可以把返回类型(responseType)设为arraybuffer;如果不知道,就设为blob。

Canvas

网页Canvas元素输出的二进制像素数据,就是TypedArray数组。

var canvas = document.getElementById("myCanvas");
var ctx = canvas.getContext("2d");

var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
var uint8ClampedArray = imageData.data;

需要注意的是,上面代码的uint8ClampedArray虽然是一个TypedArray数组,但是它的视图类型是一种针对Canvas元素的专有类型Uint8ClampedArray。这个视图类型的特点,就是专门针对颜色,把每个字节解读为无符号的8位整数,即只能取值0~255,而且发生运算的时候自动过滤高位溢出。这为图像处理带来了巨大的方便。

WebSocket

WebSocket可以通过ArrayBuffer,发送或接收二进制数据。

var socket = new WebSocket("ws://127.0.0.1:8081");
socket.binaryType = "arraybuffer";

// Wait until socket is open
socket.addEventListener("open", function (event) {
  // Send binary data
  var typedArray = new Uint8Array(4);
  socket.send(typedArray.buffer);
});

// Receive binary data
socket.addEventListener("message", function (event) {
  var arrayBuffer = event.data;
  // ···
});
Fetch API

Fetch API取回的数据,就是ArrayBuffer对象。

fetch(url)
.then(function(request){
  return request.arrayBuffer()
})
.then(function(arrayBuffer){
  // ...
});
File API

如果知道一个文件的二进制数据类型,也可以将这个文件读取为ArrayBuffer对象。

var fileInput = document.getElementById("fileInput");
var file = fileInput.files[0];
var reader = new FileReader();
reader.readAsArrayBuffer(file);
reader.onload = function () {
  var arrayBuffer = reader.result;
  // ···
};
SharedArrayBuffer

JavaScript 是单线程的,web worker 引入了多进程,每个进程的数据都是隔离的,通过postMessage()通信,即通信的数据是复制的。如果数据量比较大,这种通信的效率显然比较低。

//主进程新建了一个 Worker 进程
var w = new Worker("myworker.js");
//主进程通过w.postMessage向 Worker 进程发消息,同时通过message事件监听 Worker 进程的回应。
w.postMessage("hi");
w.onmessage = function (ev) {
  console.log(ev.data);
}


//Worker 进程也是通过监听message事件,来获取主进程发来的消息,并作出反应。
onmessage = function (ev) {
  console.log(ev.data);
  postMessage("ho");
}

主进程与 Worker 进程之间,可以传送各种数据,不仅仅是字符串,还可以传送二进制数据。若有大量数据要传送,留出一块内存区域,主进程与 Worker 进程共享,两方都可以读写,那么就会大大提高效率。

ES2017 引入SharedArrayBuffer,允许多个 Worker 进程与主进程共享内存数据。SharedArrayBuffer的 API 与ArrayBuffer一模一样,唯一的区别是后者无法共享。

// 新建 1KB 共享内存
var sharedBuffer = new SharedArrayBuffer(1024);
// 主窗口发送数据
w.postMessage(sharedBuffer);
// 本地写入数据
const sharedArray = new Int32Array(sharedBuffer);

共享内存也可以在 Worker 进程创建,发给主进程。SharedArrayBuffer本身是无法读写,必须在上面建立视图,然后通过视图读写。

Worker 进程直接改写共享内存是不正确的。有两个原因,一是可能发生两个进程同时改写该地址,二是改写以后无法同步到其他 Worker 进程。所以,必须使用Atomics.add()方法进行改写。SharedArrayBuffer API 提供了Atomics对象,保证所有共享内存的操作都是“原子性”的,并且可以在所有进程内同步。

Atomics对象有以下方法:

Atomics.load(array, index):返回array[index]的值。

Atomics.store(array, index, value):设置array[index]的值,返回这个值。

Atomics.compareExchange(array, index, oldval, newval):如果array[index]等于oldval,就写入newval,返回oldval。

Atomics.exchange(array, index, value):设置array[index]的值,返回旧的值。
Atomics.add(array, index, value):将value加到array[index],返回array[index]旧的值。

Atomics.sub(array, index, value):将value从array[index]减去,返回array[index]旧的值。

Atomics.and(array, index, value):将value与array[index]进行位运算and,放入array[index],并返回旧的值。

Atomics.or(array, index, value):将value与array[index]进行位运算or,放入array[index],并返回旧的值。

Atomics.xor(array, index, value):将vaule与array[index]进行位运算xor,放入array[index],并返回旧的值。

Atomics.wait(array, index, value, timeout):如果array[index]等于value,进程就进入休眠状态,必须通过Atomics.wake()唤醒。timeout指定多少毫秒之后,进入休眠。返回值是三个字符串(ok、not-equal、timed-out)中的一个。

Atomics.wake(array, index, count):唤醒指定数目在某个位置休眠的进程。

Atomics.isLockFree(size):返回一个布尔值,表示Atomics对象是否可以处理某个size的内存锁定。如果返回false,应用程序就需要自己来实现锁定。

SIMD

SIMD(发音/sim-dee/)是“Single Instruction/Multiple Data”的缩写,意为“单指令,多数据”。它是 JavaScript 操作 CPU 对应指令的接口。与它相对的是 SISD(“Single Instruction/Single Data”),即“单指令,单数据”。

SIMD 的含义是使用一个指令,完成多个数据的运算;SISD 的含义是使用一个指令,完成单个数据的运算,这是 JavaScript 的默认运算模式。显而易见,SIMD 的执行效率要高于 SISD,所以被广泛用于3D图形运算、物理模拟等运算量超大的项目之中。

var a = SIMD.Float32x4(1, 2, 3, 4);
var b = SIMD.Float32x4(5, 6, 7, 8);
var c = SIMD.Float32x4.add(a, b); // Float32x4[6, 8, 10, 12]

上面代码之中,数组a和b的四个成员的各自相加,只用一条指令就完成了。

一次 SIMD 运算,可以处理多个数据,这些数据被称为“通道”(lane)。上面代码中,一次运算了四个数据,因此就是四个通道。

SIMD 通常用于矢量运算。

数据类型

SIMD 提供12种数据类型,总长度都是128个二进制位。

Float32x4:四个32位浮点数

Float64x2:两个64位浮点数

Int32x4:四个32位整数

Int16x8:八个16位整数

Int8x16:十六个8位整数

Uint32x4:四个无符号的32位整数

Uint16x8:八个无符号的16位整数

Uint8x16:十六个无符号的8位整数

Bool32x4:四个32位布尔值

Bool16x8:八个16位布尔值

Bool8x16:十六个8位布尔值

Bool64x2:两个64位布尔值

每种数据类型被x符号分隔成两部分,后面的部分表示通道数,前面的部分表示每个通道的宽度和类型。比如,Float32x4就表示这个值有4个通道,每个通道是一个32位浮点数。

每个通道之中,可以放置四种数据:

浮点数(float,比如1.0)

带符号的整数(Int,比如-1)

无符号的整数(Uint,比如1)

布尔值(Bool,包含true和false两种值)

每种 SIMD 的数据类型都是一个函数方法,可以传入参数,生成对应的值。注意,这些数据类型方法都不是构造函数,前面不能加new,否则会报错。

var a = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
//变量a就是一个128位、包含四个32位浮点数(即四个通道)的值。
静态方法:数学运算

每种数据类型都有一系列运算符,支持基本的数学运算。

SIMD.%type%.abs(),SIMD.%type%.neg()

abs方法接受一个SIMD值作为参数,将它的每个通道都转成绝对值,作为一个新的SIMD值返回。

var a = SIMD.Float32x4(-1, -2, 0, NaN);
SIMD.Float32x4.abs(a)
// Float32x4[1, 2, 0, NaN]

neg方法接受一个SIMD值作为参数,将它的每个通道都转成负值,作为一个新的SIMD值返回。

var a = SIMD.Float32x4(-1, -2, 3, 0);
SIMD.Float32x4.neg(a)
// Float32x4[1, 2, -3, -0]
SIMD.%type%.add(),SIMD.%type%.addSaturate()

add方法接受两个SIMD值作为参数,将它们的每个通道相加,作为一个新的SIMD值返回。

addSaturate方法跟add方法的作用相同,都是两个通道相加,但是溢出的处理不一致。对于add方法,如果两个值相加发生溢出,溢出的二进制位会被丢弃; addSaturate方法则是返回该数据类型的最大值。

注意,Uint32x4和Int32x4这两种数据类型没有addSaturate方法。

SIMD.%type%.sub(),SIMD.%type%.subSaturate()

sub方法接受两个SIMD值作为参数,将它们的每个通道相减,作为一个新的SIMD值返回。

var a = SIMD.Float32x4(-1, -2, 3, 4);
var b = SIMD.Float32x4(3, 3, 3, 3);
SIMD.Float32x4.sub(a, b)
// Float32x4[-4, -5, 0, 1]

subSaturate方法跟sub方法的作用相同,都是两个通道相减,但是溢出的处理不一致。对于sub方法,如果两个值相减发生溢出,溢出的二进制位会被丢弃; subSaturate方法则是返回该数据类型的最小值。

SIMD.%type%.mul(),SIMD.%type%.div(),SIMD.%type%.sqrt()

mul方法接受两个SIMD值作为参数,将它们的每个通道相乘,作为一个新的SIMD值返回。
div方法接受两个SIMD值作为参数,将它们的每个通道相除,作为一个新的SIMD值返回。
sqrt方法接受一个SIMD值作为参数,求出每个通道的平方根,作为一个新的SIMD值返回。

SIMD.%FloatType%.reciprocalApproximation(),SIMD.%type%.reciprocalSqrtApproximation()

reciprocalApproximation方法接受一个SIMD值作为参数,求出每个通道的倒数(1 / x),作为一个新的SIMD值返回。
reciprocalSqrtApproximation方法接受一个SIMD值作为参数,求出每个通道的平方根的倒数(1 / (x^0.5)),作为一个新的SIMD值返回。

注意,只有浮点数的数据类型才有这两个方法。

SIMD.%IntegerType%.shiftLeftByScalar()

shiftLeftByScalar方法接受一个SIMD值作为参数,然后将每个通道的值左移指定的位数,作为一个新的SIMD值返回。如果左移后,新的值超出了当前数据类型的位数,溢出的部分会被丢弃。

注意,只有整数的数据类型才有这个方法。

SIMD.%IntegerType%.shiftRightByScalar()

shiftRightByScalar方法接受一个SIMD值作为参数,然后将每个通道的值右移指定的位数,返回一个新的SIMD值。
如果原来通道的值是带符号的值,则符号位保持不变,不受右移影响。如果是不带符号位的值,则右移后头部会补0。

静态方法:通道处理 SIMD.%type%.check()

check方法用于检查一个值是否为当前类型的SIMD值。如果是的,就返回这个值,否则就报错。

SIMD.%type%.extractLane(),SIMD.%type%.replaceLane()

extractLane方法用于返回给定通道的值。它接受两个参数,分别是SIMD值和通道编号。

var t = SIMD.Float32x4(1, 2, 3, 4);
SIMD.Float32x4.extractLane(t, 2) // 3

replaceLane方法用于替换指定通道的值,并返回一个新的SIMD值。它接受三个参数,分别是原来的SIMD值、通道编号和新的通道值。

SIMD.%type%.load()

load方法用于从二进制数组读入数据,生成一个新的SIMD值。load方法接受两个参数:一个二进制数组和开始读取的位置(从0开始)。如果位置不合法(比如-1或者超出二进制数组的大小),就会抛出一个错误。

var b = new Int32Array([1,2,3,4,5,6,7,8]);
SIMD.Int32x4.load(a, 2);
// Int32x4[3, 4, 5, 6]

这个方法还有三个变种load1()、load2()、load3(),表示从指定位置开始,只加载一个通道、二个通道、三个通道的值。

SIMD.%type%.store()

store方法用于将一个SIMD值,写入一个二进制数组。它接受三个参数,分别是二进制数组、开始写入的数组位置、SIMD值。它返回写入值以后的二进制数组。

var t2 = new Int32Array(8);
var v2 = SIMD.Int32x4(1, 2, 3, 4);
SIMD.Int32x4.store(t2, 2, v2)
// Int32Array[0, 0, 1, 2, 3, 4, 0, 0]

这个方法还有三个变种store1()、store2()和store3(),表示只写入一个通道、二个通道和三个通道的值。

SIMD.%type%.splat()

splat方法返回一个新的SIMD值,该值的所有通道都会设成同一个预先给定的值。如果省略参数,所有整数型的SIMD值都会设定0,浮点型的SIMD值都会设成NaN。

SIMD.%type%.swizzle()

swizzle方法返回一个新的SIMD值,重新排列原有的SIMD值的通道顺序。swizzle方法的第一个参数是原有的SIMD值,后面的参数对应将要返回的SIMD值的四个通道。

var t = SIMD.Float32x4(1, 2, 3, 4);
SIMD.Float32x4.swizzle(t, 1, 2, 0, 3);
// Float32x4[2,3,1,4]

上面代码中,后面的参数的意思是新的SIMD的四个通道,依次是原来SIMD值的1号通道、2号通道、0号通道、3号通道。由于SIMD值最多可以有16个通道,所以swizzle方法除了第一个参数以外,最多还可以接受16个参数。

SIMD.%type%.shuffle()

shuffle方法从两个SIMD值之中取出指定通道,返回一个新的SIMD值。

var a = SIMD.Float32x4(1, 2, 3, 4);
var b = SIMD.Float32x4(5, 6, 7, 8);

SIMD.Float32x4.shuffle(a, b, 1, 5, 7, 2);
// Float32x4[2, 6, 8, 3]

上面代码中,a和b一共有8个通道,依次编号为0到7。shuffle根据编号,取出相应的通道,返回一个新的SIMD值。

静态方法:比较运算 SIMD.%type%.equal(),SIMD.%type%.notEqual()

equal方法用来比较两个SIMD值a和b的每一个通道,根据两者是否精确相等(a === b),得到一个布尔值。最后,所有通道的比较结果,组成一个新的SIMD值,作为掩码返回。notEqual方法则是比较两个通道是否不相等(a !== b)。

var a = SIMD.Float32x4(1, 2, 3, 9);
var b = SIMD.Float32x4(1, 4, 7, 9);

SIMD.Float32x4.equal(a,b)
// Bool32x4[true, false, false, true]

SIMD.Float32x4.notEqual(a,b);
// Bool32x4[false, true, true, false]
SIMD.%type%.greaterThan(),SIMD.%type%.greaterThanOrEqual()

greatThan方法用来比较两个SIMD值a和b的每一个通道,如果在该通道中,a较大就得到true,否则得到false。最后,所有通道的比较结果,组成一个新的SIMD值,作为掩码返回。greaterThanOrEqual则是比较a是否大于等于b。

SIMD.%type%.lessThan(),SIMD.%type%.lessThanOrEqual()

lessThan方法用来比较两个SIMD值a和b的每一个通道,如果在该通道中,a较小就得到true,否则得到false。最后,所有通道的比较结果,会组成一个新的SIMD值,作为掩码返回。lessThanOrEqual方法则是比较a是否小于等于b。

SIMD.%type%.select()

select方法接受掩码和两个SIMD值作为参数,返回一个新生成的SIMD值。当某个通道对应的掩码为true时,会选择第一个SIMD值的对应通道,否则选择第二个SIMD值的对应通道。这个方法通常与比较运算符结合使用。

var a = SIMD.Float32x4(0, 12, 3, 4);
var b = SIMD.Float32x4(0, 6, 7, 50);

var mask = SIMD.Float32x4.lessThan(a,b);
// Bool32x4[false, false, true, true]

var result = SIMD.Float32x4.select(mask, a, b);
// Float32x4[0, 6, 3, 4]

上面代码中,先通过lessThan方法生成一个掩码,然后通过select方法生成一个由每个通道的较小值组成的新的SIMD值。

SIMD.%BooleanType%.allTrue(),SIMD.%BooleanType%.anyTrue()

allTrue方法接受一个SIMD值作为参数,然后返回一个布尔值,表示该SIMD值的所有通道是否都为true。anyTrue方法则是只要有一个通道为true,就返回true,否则返回false。

注意,只有四种布尔值数据类型(Bool32x4、Bool16x8、Bool8x16、Bool64x2)才有这两个方法。

SIMD.%type%.min(),SIMD.%type%.minNum()

min方法接受两个SIMD值作为参数,将两者的对应通道的较小值,组成一个新的SIMD值返回。如果有一个通道的值是NaN,则会优先返回NaN。minNum方法与min的作用一模一样,唯一的区别是如果有一个通道的值是NaN,则会优先返回另一个通道的值。

SIMD.%type%.max(),SIMD.%type%.maxNum()

max方法接受两个SIMD值作为参数,将两者的对应通道的较大值,组成一个新的SIMD值返回。如果有一个通道的值是NaN,则会优先返回NaN。maxNum方法与max的作用一模一样,唯一的区别是如果有一个通道的值是NaN,则会优先返回另一个通道的值。

静态方法:位运算 SIMD.%type%.and(),SIMD.%type%.or(),SIMD.%type%.xor(),SIMD.%type%.not()

and方法接受两个SIMD值作为参数,返回两者对应的通道进行二进制AND运算(&)后得到的新的SIMD值。
or方法接受两个SIMD值作为参数,返回两者对应的通道进行二进制OR运算(|)后得到的新的SIMD值。
xor方法接受两个SIMD值作为参数,返回两者对应的通道进行二进制”异或“运算(^)后得到的新的SIMD值。
not方法接受一个SIMD值作为参数,返回每个通道进行二进制”否“运算(~)后得到的新的SIMD值。

静态方法:数据类型转换

SIMD提供以下方法,用来将一种数据类型转为另一种数据类型:

SIMD.%type%.fromFloat32x4()

SIMD.%type%.fromFloat32x4Bits()

SIMD.%type%.fromFloat64x2Bits()

SIMD.%type%.fromInt32x4()

SIMD.%type%.fromInt32x4Bits()

SIMD.%type%.fromInt16x8Bits()

SIMD.%type%.fromInt8x16Bits()

SIMD.%type%.fromUint32x4()

SIMD.%type%.fromUint32x4Bits()

SIMD.%type%.fromUint16x8Bits()

SIMD.%type%.fromUint8x16Bits()

带有Bits后缀的方法,会原封不动地将二进制位拷贝到新的数据类型;不带后缀的方法,则会进行数据类型转换。

var t = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
SIMD.Int32x4.fromFloat32x4(t);
// Int32x4[1, 2, 3, 4]

SIMD.Int32x4.fromFloat32x4Bits(t);
// Int32x4[1065353216, 1073741824, 1077936128, 1082130432]

上面代码中,fromFloat32x4是将浮点数转为整数,然后存入新的数据类型;fromFloat32x4Bits则是将二进制位原封不动地拷贝进入新的数据类型,然后进行解读。

Bits后缀的方法,还可以用于通道数目不对等的拷贝(原通道的数据大小可小于目标通道的最大宽度)。如果数据转换时,原通道的数据大小,超过了目标通道的最大宽度,就会报错。

实例方法

SIMD.%type%.prototype.toString()返回一个SIMD值的字符串形式。

var a = SIMD.Float32x4(11, 22, 33, 44);
a.toString() // "SIMD.Float32x4(11, 22, 33, 44)"

参考自:ECMAScript 6 入门

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/83411.html

相关文章

  • 让代码飞起来——高性能Julia学习笔记(二)

    摘要:首发于接上一篇让代码飞起来高性能学习笔记一,继续整理高性能学习笔记。和都只能表示特定的整数范围,超过范围会。通用代码一般会用,这就有可能导致性能问题。 首发于 https://magicly.me/hpc-julia-2/ 接上一篇:让代码飞起来——高性能 Julia 学习笔记(一), 继续整理高性能 Julia 学习笔记。 数字 Julia 中 Number 的 size 就跟 C ...

    noONE 评论0 收藏0
  • 《JavaScript语言精粹 修订版》 读书笔记

    摘要:于是我就先把这本薄的经典书语言精粹修订版豆瓣读书本书简介总共章,除去附录,才页,读完并记录了一些笔记。读书笔记还可以分享给别人看。编程语言第版定义了的标准。程序检查时丢弃值为函数的属性。 之前看到这篇文章,前端网老姚浅谈:怎么学JavaScript?,说到怎么学习JavaScript,那就是看书、分析源码。10本书读2遍的好处,应该大于一本书读20遍。看书主动学习,看视频是被动学习。看...

    EscapedDog 评论0 收藏0
  • JavaScript异步编程解决方案笔记

    摘要:异步编程解决方案笔记最近读了朴灵老师的深入浅出中异步编程一章,并参考了一些有趣的文章。另外回调函数中的也失去了意义,这会使我们的程序必须依赖于副作用。 JavaScript 异步编程解决方案笔记 最近读了朴灵老师的《深入浅出NodeJS》中《异步编程》一章,并参考了一些有趣的文章。在此做个笔记,记录并巩固学到的知识。 JavaScript异步编程的两个核心难点 异步I/O、事件驱动使得...

    dmlllll 评论0 收藏0
  • AI开发书籍分享

    摘要:编程书籍的整理和收集最近一直在学习深度学习和机器学习的东西,发现深入地去学习就需要不断的去提高自己算法和高数的能力然后也找了很多的书和文章,随着不断的学习,也整理了下自己的学习笔记准备分享出来给大家后续的文章和总结会继续分享,先分享一部分的 编程书籍的整理和收集 最近一直在学习deep learning深度学习和机器学习的东西,发现深入地去学习就需要不断的去提高自己算法和高数的能力然后...

    huayeluoliuhen 评论0 收藏0

发表评论

0条评论

kumfo

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<