Array构造函数
- 创建Array对象
- 调用Array()时可以使用或者不适用new，都会创建一个新的Array实例
- 参数
- elementN:根据给地的元素创建一个js数组，但是当仅有一个参数为数字时除外
- arrayLength：如果传递给Array构造函数的唯一参数是介于0到2^32-1(含)之间的整数，这将返回一个新的js数组，其length属性设置为该数字(稀疏数组)
- 异常
- RangeError:如果只有一个参数且其值不在0到2^32-1之间，则会触发异常
静态方法
- Array.from()
- 从可迭代或类数组对象创建一个新的浅拷贝的数组实例
- 语法：
- Array.from(arrayLike)
- Array.from(arrayLike, mapFn)
- Array.from(arrayLike, mapFn, thisArg)
- 参数
- arrayLike:想要转换成数组的类数组或可迭代对象
- mapFn:调用数组每个元素的函数。如果提供，每个将要添加到数组中的值首先会传递给该函数，然后将 mapFn 的返回值增加到数组中。使用以下参数调用该函数：
- element：数组当前正在处理的元素
- index：数组当前正在处理的元素的索引
- thisArg:执行 mapFn 时用作 this 的值
- Array.myfrom(arrayLike, mapFn=undefined, thisArg)
Array.myFrom = function (arrayLike, mapFn = undefined, thisArg) {
// 定义报错需要类型和值一块返回的几种基本类型
const typeList = ['number', 'string', 'boolean']
let arrLike = arrayLike
// 如果mapFn存在但是不为函数类型或者mapFn为null，报错
if (mapFn !== undefined && typeof mapFn !== 'function') {
const mapFnType = typeof mapFn
throw new Error(
`${
typeList.includes(mapFnType) || mapFn === null
? `${mapFnType} ${mapFn}`
: mapFnType
} is not a function`
)
}
// 如果参数是可迭代数组，直接使用扩展运算符转为数组
if (arrayLike[Symbol.iterator]) {
arrLike = [...arrayLike]
}
// 获取数组或者可迭代对象的length，并进行循环赋值
const len = arrLike.length
if (len >= 0 && len <= 2 ** 32 - 1) {
// 构建一个长度为length的空数组
let arr = new Array(len)
for (let i = 0; i < len; i++) {
// 循环赋值，如果存在mapFn函数，则使用mapFn函数处理每一项的值，如果值是undefined或者empty，则均转为undefined
// 如果存在thisArg参数，则将mapFn的this指向mapFn
arr[i] = mapFn
? mapFn.call(thisArg, arrLike[i], i)
: arrLike[i] || undefined
}
return arr
} else {
// 超过数组长度范围报错
throw new RangeError('Invalid array length')
}
}
- Array.fromAsync()
- 可以由一个异步可迭代对象、可迭代对象或类数组对象创建一个新的、浅拷贝的 Array 实例
- 语法
- Array.fromAsync(arrayLike)
- Array.fromAsync(arrayLike, mapFn)
- Array.fromAsync(arrayLike, mapFn, thisArg)
- 参数
- arrayLike
- mapFn
- 为数组中的每个元素执行的函数。如果提供了该函数，则每个要添加到数组中的值都会先通过该函数处理，mapFn 的返回值将代替该值被添加到数组中（在等待兑现后）。该函数被调用时将传入以下参数：
- element：数组中当前正在处理的元素。由于所有元素都会先等待其兑现，因此该值永远不会是 thenable
- index：正在处理的元素在数组中的索引
- thisArg
- 返回值
- 一个新的 Promise，其兑现值是一个新的 Array 实例
- Array,myFromAsync(arrayLike,mapFn,thisArg)
Array.myFromAsync = async function (arrayLike, mapFn = undefined, thisArg) {
// 当mapFn存在但是不为function类型的时候，报错，返回值为Promise类型
if (mapFn !== undefined && typeof mapFn !== 'function') {
throw new TypeError(`${mapFn} is not function`)
}
// 长度超出数组范围报错
const len = arrayLike.size || arrayLike.length
if (len < 0 || len >= 2 ** 32) {
throw new RangeError('Invalid array length')
}
let arr = []
// 迭代对象分为同步迭代对象和异步迭代对象和具有length属性的object类型不可直接迭代对象
// 将同步可迭代对象转为异步可迭代对象, 同时使用for await of进行处理
// 具有length属性的对象特殊处理
// 如果有mapFn函数，mapFn返回的值也需要使用await获取到具体值
if (arrayLike[Symbol.asyncIterator] || arrayLike[Symbol.iterator]) {
for await (const item of arrayLike) {
arr.push(mapFn ? await mapFn.call(thisArg, item) : item)
}
} else {
for (let i = 0; i < arrayLike.length; i++) {
arr[i] = mapFn
? await mapFn.call(thisArg, arrayLike[i])
: await arrayLike[i]
}
}
// 将处理好的数组返回
return arr
}
- Array.isArray(value)
- Array.isArray() 静态方法用于确定传递的值是否是一个数组
- 语法
- 参数
- 返回值
- 如果 value 是 Array，则为 true；否则为 false。如果 value 是 TypedArray 实例，则总是返回 false
- Array.myIsArray(value)
Array.myIsArray = (value) => {
return Object.prototype.toString.call(value) === '[object Array]'
}
- Array.of()
- Array.of() 静态方法通过可变数量的参数创建一个新的 Array 实例，而不考虑参数的数量或类型
- 语法
- Array.of()
- Array.of(element0)
- Array.of(element0, element1)
- Array.of(element0, element1, /* … ,*/ elementN)
- 参数
- 返回值
- 新的Array实例，如果是Array的子类继承了of()方法，将返回子类的新实例，而不是Array的实例；this指向普通构造函数，会创建普通构造函数实例的可迭代对象（能被Array.from()转为数组的对象）
- Array.myOf(elementN)
Array.myOf = function (...rest) {
// 判断this是否指向构造函数，如果是，返回值应该为一个带有length属性的对象，length值为参数的个数
if (typeof this === 'function') {
const len = rest.length
// 执行构造函数，参数为myOf函数接受到的参数长度，生成实例
const result = new this(len)
// 以rest的index为key，值为value，添加到实例result上
for (let i = 0; i < len; i++) {
result[i] = rest[i]
}
// 为result设置length属性，值为myOf函数参数长度
result.length = len
return result
}
// 其他类型直接返回rest数组
return rest
}
