重学js —— 索引集合之TypedArray 对象（类型化数组）

[lizhongzhen11]

TypedArray 对象（类型化数组）

• MDN
• 现代JavaScript教程——ArrayBuffer，二进制数组 讲的更易懂
• 对类型化数组使用 Array.isArray() 返回 false
• 类型化数组不完全支持所有可用于正常数组的方法（如 push 和 pop）
• 曾经见过这个名词，但是完全不了解。。。看了MDN，不懂
• 看MDN发现 TypedArray 和 ArrayBuffer 等对象联合使用，但是规范把它们分成两大章节来讲，关键还在中间夹着另一个不相关的 键控集合 章节。

TypedArray 对象提供基础二进制数据 缓冲区 的类似数组的视图。TypedArray 实例的每个元素都具有相同的基础二进制标量数据类型。下表列出了每种支持的元素类型的不同 TypedArray 构造函数。表中的每个构造函数都有一个对应的不同原型对象。

构造函数名称和固有对象	元素类型	元素大小	转换操作	描述
Int8Array %Int8Array%	Int8	1	ToInt8	8位二进制补码有符号整数
Uint8Array %Uint8Array%	Uint8	1	ToUint8	8位无符号整数
Uint8ClampedArray %Uint8ClampedArray%	Uint8C	1	ToUint8Clamp	8位无符号整数（固定转换）
Int16Array %Int16Array%	Int16	2	ToInt16	16位二进制补码有符号整数
Uint16Array %Uint16Array%	Uint16	2	ToUint16	16位无符号整数
Int32Array %Int32Array%	Int32	4	ToInt32	32位二进制补码有符号整数
Uint32Array %Uint32Array%	Uint32	4	ToUint32	32位无符号整数
BigInt64Array %BigInt64Array%	BigInt64	8	ToBigInt64	64位二进制补码有符号整数
BigUint64Array %BigUint64Array%	BigUint64	8	ToBigUint64	64位无符号整数
Float32Array %Float32Array%	Float32	4		32位 IEEE 浮点
Float64Array %Float64Array%	Float64	8		64位 IEEE 浮点

%TypedArray% 固有对象

• 是构造器函数对象，所有的 TypedArray 构造器对象都继承自它
• 连同其相应的原型对象一起，提供了所有 TypedArray 构造函数及其实例继承的公共属性。
• 全局对象 上没有对应的属性名
• 充当各种 TypedArray 构造函数的抽象超类。
• 调用时会引发错误，因为它是抽象类的构造函数。TypedArray 构造函数不对其执行 super 调用。

%TypedArray% ( )

1. 抛 TypeError 异常

%TypedArray% 固有对象属性

• 有 [[Prototype]] 内置插槽，其值为 %Function.prototype%
• 有个 "name" 属性其值为 "TypedArray"
• 还具有以下属性：

%TypedArray%.from ( source [ , mapfn [ , thisArg ] ] )

1. 定义 C 为 this 值
2. 如果 C 不是构造器，抛 TypeError 异常
3. 如果 mapfn 为 undefined，定义 mapping 为 false
4. 否则，
   1. 如果 mapfn 不可调用，抛 TypeError 异常
   2. 定义 mapping 为 true
5. 定义 usingIterator 为 ? GetMethod(source, @@iterator)
6. 如果 usingIterator 不是 undefined，
   1. 定义 values 为 ? IterableToList(source, usingIterator)
   2. 定义 len 为 values 中元素的数量
   3. 定义 targetObj 为 ? TypedArrayCreate(C, « len »)
   4. 定义 k 为 0
   5. 当 k < len 时，重复以下步骤，
      1. 定义 Pk 为 ! ToString(k)
      2. 定义 kValue 为 values 中的第一个元素且从 values 中移除该元素
      3. 如果 mapping 为 true
         1. 定义 mappedValue 为 ? Call(mapfn, thisArg, « kValue, k »)
      4. 否则，定义 mappedValue 为 kValue
      5. 执行 ? Set(targetObj, Pk, mappedValue, true)
      6. 将 k 设置为 k + 1
   6. 断言：values 现在是空 List
   7. 返回 targetObj
7. 注意：source 不是可迭代对象，因此推断它是 类数组对象
8. 定义 arrayLike 为 ! ToString(source)
9. 定义 len 为 ? LengthOfArrayLike(arrayLike)
10. 定义 targetObj 为 ? TypedArrayCreate(C, « len »)
11. 定义 k 为 0
12. 当 k < len 时，重复以下步骤，
    1. 定义 Pk 为 ! ToString(k)
    2. 定义 kValue 为 ? Get(arrayLike, Pk)
    3. 如果 mapping 为 true，
       1. 定义 mappedValue 为 ? Call(mapfn, thisArg, « kValue, k »)
    4. 否则，定义 mappedValue 为 kValue
    5. 执行 ? Set(targetObj, Pk, mappedValue, true)
    6. 将 k 设置为 k + 1
13. 返回 targetObj

%TypedArray%.of ( ...items )

1. 定义 len 为传给该函数的参数的实际数量
2. 定义 items 为传给该函数的参数 List
3. 定义 C 为 this 值
4. 如果 C 不是构造器，抛 TypeError 异常
5. 定义 newObj 为 ? TypedArrayCreate(C, « len »)
6. 定义 k 为 0
7. 当 k < len 时，重复以下步骤，
   1. 定义 kValue 为 items[k]
   2. 定义 Pk 为 ! ToString(k)
   3. 执行 ? Set(newObj, Pk, kValue, true)
   4. 将 k 设置为 k + 1
8. 返回 newObj

get %TypedArray% [ @@species ]

访问器属性，其 set 访问器为 undefined。

1. 返回 this 值

该函数的 "name" 属性值为 "get [Symbol.species]"

%TypedArray.prototype% 对象上的属性（附上不支持的数组方法）

• %TypedArray%.prototype.copyWithin ( target, start [ , end ] )
• %TypedArray%.prototype.entries ( )
• %TypedArray%.prototype.every ( callbackfn [ , thisArg ] )
• %TypedArray%.prototype.fill ( value [ , start [ , end ] ] )
• %TypedArray%.prototype.filter ( callbackfn [ , thisArg ] )
• %TypedArray%.prototype.find ( predicate [ , thisArg ] )
• %TypedArray%.prototype.findIndex ( predicate [ , thisArg ] )
• %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
• %TypedArray%.prototype.includes ( searchElement [ , fromIndex ] )
• %TypedArray%.prototype.indexOf ( searchElement [ , fromIndex ] )
• %TypedArray%.prototype.join ( separator )
• %TypedArray%.prototype.keys ( )
• %TypedArray%.prototype.lastIndexOf ( searchElement [ , fromIndex ] )
• %TypedArray%.prototype.map ( callbackfn [ , thisArg ] )
• %TypedArray%.prototype.reduce ( callbackfn [ , initialValue ] )
• %TypedArray%.prototype.reduceRight ( callbackfn [ , initialValue ] )
• %TypedArray%.prototype.reverse ( )
• %TypedArray%.prototype.slice ( start, end )
• %TypedArray%.prototype.some ( callbackfn [ , thisArg ] )
• %TypedArray%.prototype.sort ( comparefn )
• %TypedArray%.prototype.values ( )
• ...

和 重学js —— 索引集合之Array原型对象属性 对比，可以看出不支持以下数组方法：

• concat
• flat
• flatMap
• push
• pop
• shift
• splice
• unshift

特有的属性

get %TypedArray%.prototype.buffer

1. 定义 O 为 this 值
2. 执行 ? RequireInternalSlot(O, [[TypedArrayName]])
3. 断言：O 有个 [[ViewedArrayBuffer]] 内置插槽
4. 定义 buffer 为 O.[[ViewedArrayBuffer]]
5. 返回 buffer

get %TypedArray%.prototype.byteLength

1. 定义 O 为 this 值
2. 执行 ? RequireInternalSlot(O, [[TypedArrayName]])
3. 断言：O 有个 [[ViewedArrayBuffer]] 内置插槽
4. 定义 buffer 为 O.[[ViewedArrayBuffer]]
5. 如果 IsDetachedBuffer(buffer) 为 true，返回 0
6. 定义 size 为 O.[[ByteLength]]
7. 返回 size

还有其他特有的属性，不具体列出来

示例，来自MDN

需要结合 ArrayBuffer 来看，下面打印的对象属性值，以 [[Int8Array]] 为例，可能表示 每个数组元素代表 8 位即 1 字节，所以 16字节需要16个数组元素空间；而 [[Int32Array]] 可能表示 每个数组元素代表 32位即 4 字节，所以只需要 4 个数组元素空间。

const buffer = new ArrayBuffer(16);
// ArrayBuffer(16) {}
{
  [[Int8Array]]: Int8Array(16) [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [[Int16Array]]: Int16Array(8) [0, 0, 0, 0, 0, 0, 0, 0],
  [[Int32Array]]: Int32Array(4) [0, 0, 0, 0],
  [[Uint8Array]]: Uint8Array(16) [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  byteLength: 16
}