javascript内置对象Array(一)

ldy 8月前 ⋅ 261 阅读

javascript内置对象Array(一)

浏览器创建(new)一个Array对象或者利用“[ ]”声明一个匿名的数组对象

new Array
	[] 
	length: 0
	__proto__: Array(0)
[]
	[]
	length: 0
	__proto__: Array(0)

两者的结果一致,我们可以发现数组对象的属性只有两个length、proto 。length表示数组元素的数量。当然____proto____(对象的私有属性)上的东西是我们真正关注的

length: 0
__proto__: Array(0)
concat: ƒ concat()
constructor: ƒ Array()
copyWithin: ƒ copyWithin()
entries: ƒ entries()
every: ƒ every()
fill: ƒ fill()
filter: ƒ filter()
find: ƒ find()
findIndex: ƒ findIndex()
flat: ƒ flat()
flatMap: ƒ flatMap()
forEach: ƒ forEach()
includes: ƒ includes()
indexOf: ƒ indexOf()
join: ƒ join()
keys: ƒ keys()
lastIndexOf: ƒ lastIndexOf()
length: 0
map: ƒ map()
pop: ƒ pop()
push: ƒ push()
reduce: ƒ reduce()
reduceRight: ƒ reduceRight()
reverse: ƒ reverse()
shift: ƒ shift()
slice: ƒ slice()
some: ƒ some()
sort: ƒ sort()
splice: ƒ splice()
toLocaleString: ƒ toLocaleString()
toString: ƒ toString()
unshift: ƒ unshift()
values: ƒ values()
Symbol(Symbol.iterator): ƒ values()
Symbol(Symbol.unscopables): {copyWithin: true, entries: true, fill: true, find: true, findIndex: true, …}
__proto__: Object

Array.from()

Array.from(arrayLike[, mapFn[, thisArg]])

arrayLike:必填的参数,是__类数组对象和和可迭代对象__。可以显示地理解成为对象中有一个length属性的对象。

mapFn:迭代对象的__每个元素__将要执行的回调函数。

thisArg:mapFn函数中的this对象。

Array.from([1, 2, 3], x => x+1)
    (3) [2, 3, 4]
    0: 2
    1: 3
    2: 4

给新的数组每个元素数值加1

Array.isArray()

判断对象是否是数组

Array.of()

“方法创建一个具有可变数量参数的新数组实例,而不考虑参数的数量或类型。”它和from方法一样是生成新的数组实例的方法,他的重点在于__不考虑参数的数量或类型__,可以将所有的数据放进数组中。就如同下面这个例子:

Array.of(
    "dabc",
    111,
    {a:"234"},
    undefined,
    null,
    Math.PI,
    function(){console.info("test")}
)

(7) 
["dabc", 111, {…}, undefined, null, 3.141592653589793, ƒ]
0: "dabc"
1: 111
2: {a: "234"}
3: undefined
4: null
5: 3.141592653589793
6: ƒ ()

Array.concat()

方法用于合并两个或多个数组。此方法不会更改现有数组,而是返回一个新数组。

Array.copyWithin()

数组元素内部之间的复制

arr.copyWithin(target[, start[, end]])

target:索引的起始点

start:元素开始复制的位置

end:元素结束复制的位置

Array.entries()

获取该数组元素的迭代对象,每个元素的键(元素的索引)值(元素本身的值)对。其中键值对的形式也是一个数组

[1,2,3].entries()
	Array Iterator {}
	
[1,2,3].entries().next().value
	(2) [0, 1]

Array.fill()

快速填充一个数组。经常用来快速创建可迭代的数组,比如:

new Array(10).forEach(e=>console.info(e))

new Array(10).fill(null).forEach(e=>console.info(e))

这两个例子,第一个语句什么都不会输出,但是第二个会遍历输出null。我们用new 直接实例化一个有长度的数组对象它的每个元素都是empty,是不可迭代的,用fill填充每个元素,这样的数组对象就是可以迭代。

Array.find()

返回数组中满足提供的测试函数的第一个元素的值,否则返回undefined。它的参数是一个测试函数,这个函数是一个回调函数,回调函数的所有参数和every()、some()、forEach()回调的参数是一致的。

Array.findIndex()

和find()一样,只是返回结果是元素的索引

Array.flat()

按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。若参数是Infinity,那就按照最大深度进行展开。可以简单理解多维数组按照指定的层级要求将其“拉平”展开成为n维数组(n取决于原数组是几维数组以及参数的层级是多少)

var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
    (10) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    0: 1
    1: 2
    2: 3
    3: 4
    4: 5
    5: 6
    6: 7
    7: 8
    8: 9
    9: 10

Array.flatMap()

flatMap相当于flat()和map()的结合,但是flatMap只能“拉平”一层,和flat()不同的是,flatMap()的参数是一个回调函数,就像map()的回调函数一样。

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

arr.flatMap(x => [x, x * 2]);
    (8) [1, 2, 2, 4, 3, 6, 4, 8]
    0: 1
    1: 2
    2: 2
    3: 4
    4: 3
    5: 6
    6: 4
    7: 8

全部评论: 0

    我有话说: