重学js —— 索引集合之数组对象

[lizhongzhen11]

数组对象

• Array

数组构造器

• 即固有对象 %Array%
• 全局对象 "Array" 属性的初始值
• 当作为构造器调用时，创建并初始化 数组怪异对象
• ...

Array ( )

1. 定义 numberOfArgs 为函数调用时传递过来的参数数量
2. 断言：numberOfArgs = 0
3. 如果 NewTarget 为 undefined，定义 newTarget 为 活跃的函数对象；否则，定义 newTarget 为 NewTarget
4. 定义 proto 为 ? GetPrototypeFromConstructor(newTarget, "%Array.prototype%")
5. 返回 ! ArrayCreate(0, proto)

Array ( len )

Array(1) // [empty]
new Array(1) // [empty]

1. 定义 numberOfArgs 为函数调用时传递过来的参数数量
2. 断言：numberOfArgs = 1
3. 如果 NewTarget 为 undefined，定义 newTarget 为 活跃的函数对象；否则，定义 newTarget 为 NewTarget
4. 定义 proto 为 ? GetPrototypeFromConstructor(newTarget, "%Array.prototype%")
5. 定义 array 为 ! ArrayCreate(0, proto)
6. 如果 len 不是 Number 类型，
   1. 执行 ! CreateDataPropertyOrThrow(array, "0", len)
   2. 定义 intLen 为 1
7. 否则，
   1. 定义 intLen 为 ToUint32(len)
   2. 如果 intLen ≠ len，抛 RangeError 异常
8. 执行 ! Set(array, "length", intLen, true)
9. 返回 array

Array ( ...items )

Array(1, 2, 3) // [1, 2, 3]
new Array(1, 2, 3) // [1, 2, 3]

1. 定义 numberOfArgs 为函数调用时传递过来的参数数量
2. 断言：numberOfArgs ≥ 2
3. 如果 NewTarget 为 undefined，定义 newTarget 为 活跃的函数对象；否则，定义 newTarget 为 NewTarget
4. 定义 proto 为 ? GetPrototypeFromConstructor(newTarget, "%Array.prototype%")
5. 定义 array 为 ? ArrayCreate(numberOfArgs, proto)
6. 定义 k 为 0
7. 定义 items 为零序列表，按顺序包含参数项目
8. 当 k < numberOfArgs，重复以下操作，
   1. 定义 Pk 为 ! ToString(k)
   2. 定义 itemK 为 items[k]
   3. 执行 ! CreateDataPropertyOrThrow(array, Pk, itemK)
   4. 将 k 设置为 k + 1
9. 断言：array 的 "length" 属性值为 numberOfArgs
10. 返回 array

Array 构造器上的属性

• 有 [[Prototype]] 内置插槽，其值为 %Function.prototype%

Array.from ( items [ , mapfn [ , thisArg ] ] )

• MDN

1. 定义 C 为 this 值
2. 如果 mapfn 为 undefined，定义 mapping 为 false
3. 否则，
   1. 如果 mapfn 不可调用，抛 TypeError 异常
   2. 定义 mapping 为 true
4. 定义 usingIterator 为 ? GetMethod(items, @@iterator)
5. 如果 usingIterator 为 undefined，
   1. 如果 C 是构造器，
      1. 定义 A 为 ? Construct(C)
   2. 否则，
      1. 定义 A 为 ! ArrayCreate(0)
   3. 定义 iteratorRecord 为 ? GetIterator(items, sync, usingIterator)
   4. 定义 k 为 0
   5. 重复，
      1. 如果 k ≥ 2⁵³ - 1，
         1. 定义 error 为 ThrowCompletion(新创建的TypeError对象)
         2. 返回 ? IteratorClose(iteratorRecord, error)
      2. 定义 Pk 为 ! ToString(k)
      3. 定义 next 为 ? IteratorStep(iteratorRecord)
      4. 如果 next 为 false，
         1. 执行 ? Set(A, "length", k, true)
         2. 返回 A
      5. 定义 nextValue 为 ? IteratorValue(next)
      6. 如果 mapping 为 true，
         1. 定义 mappedValue 为 Call(mapfn, thisArg, « nextValue, k »)
         2. 如果 mappedValue 是 abrupt completion，返回 ? IteratorClose(iteratorRecord, mappedValue)
         3. 将 mappedValue 设置为 mappedValue.[[Value]]
      7. 否则，定义 mappedValue 为 nextValue
      8. 定义 defineStatus 为 CreateDataPropertyOrThrow(A, Pk, mappedValue)
      9. 如果 defineStatus 是 abrupt completion，返回 ? IteratorClose(iteratorRecord, defineStatus)
      10. 将 k 设置为 k + 1
6. 注意：items 不是迭代对象，推断它是 类数组对象
7. 定义 arrayLike 为 ! ToObject(items)
8. 定义 len 为 ? LengthOfArrayLike(arrayLike)
9. 如果 C 是构造器，
   1. 定义 A 为 ? Construct(C, « len »)
10. 否则，
    1. 定义 A 为 ? ArrayCreate(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. 执行 ? CreateDataPropertyOrThrow(A, Pk, mappedValue)
    6. 将 k 设置为 k + 1
13. 执行 ? Set(A, "length", len, true)
14. 返回 A

Array.isArray ( arg )

• MDN
• 重学js —— Array.isArray——严格判定JavaScript对象是否为数组

1. 返回 ? IsArray(arg)

Array.of ( ...items )

• MDN
• 感觉这个方法主要就是为了弥补 Array() 生成数组的不足

Array(1) // [empty]
Array.of(1) // [1]

1. 定义 len 为传递给函数的参数数量
2. 定义 items 为 传递过来的参数 列
3. 定义 C 为 this 值
4. 如果 C 是构造器，
   1. 定义 A 为 ? Construct(C, « len »)
5. 否则，
   1. 定义 A 为 ? ArrayCreate(len)
6. 定义 k 为 0
7. 当 k < len，重复以下步骤
   1. 定义 kValue 为 items[k]
   2. 定义 Pk 为 ! ToString(k)
   3. 执行 ? CreateDataPropertyOrThrow(A, Pk, kValue)
   4. 将 k 设置为 k + 1
8. 执行 ? Set(A, "length", len, true)
9. 返回 A

Array 迭代对象（自己看看就好）

2020-07-29 补充

来自高级前端面试第18题

数组里面有10万个数据，取第一个元素和第10万个元素的时间相差多少？

这个其实涉及到数据结构知识了。数组是索引集合，取第一个和第10万个所用时间应该是一样的，不管取哪个索引的元素时间复杂度都是O(1)，时间差应该是0.