Array理解

1.Array的属性

1.1 prototype

Array.prototype // 数组原型对象，上面挂载了很多数组的方法
!数组的原型对象也是一个数组

1.2 length

let arr = [1, 2, 3]
arr.length // 3
// lengt可以用来截断数组
arr.length = 1 // [1]
// 也可以使数组变长
arr.length = 5 // [1, empty × 4]
arr[4] = undefined

2.Array本身的方法

2.1 Array.from()

// Array.from(arrayLike, mapFn , thisArg) 返回值：一个新数组
// 对一个类数组或可迭代对象创建一个新的，浅拷贝的数组实例。
Array.from('zhm') // ['z', 'h', 'm']
Array.from([1,2,3], x => x * 2, this) // [2,4,6]
function fn () {
	Array.from(arguments) // [1,2,3]
}
fn(1,2,3)
Array.from({ length: 5 }, (item, index) => index) // [0,1,2,3,4,5]

2.2 Array.isArray()

// Array.isArray(arr) 返回值 Boolean
Array.isArray([1,2,3]) // true
Array.isArray('zhm') // false

2.3 Array.of()

//创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型
Array.of(7) // [7]
Array.of(1,2,3) // [1,2,3]

3.Array.prototype上的方法

callback都含有三个形参 item,index,arr, 分别是数组每一项，数组每一项的索引值，数组本身（除了reduce）

3.1 concat

// concat(arr)  返回值：新数组 
// 作用：合并两个或多个数组，不改变原有数组
let arr = [1,2,3]
let newArr = arr.concat(['zhm']) // [1,2,3,'zhm']

3.2 copyWithin

// copyWithin(target, start, end) 返回值：修改原本数组
// 作用：复制start-end索引的值，从target索引开始替换
let arr = [1,2,3,4,5,6]
arr.copyWithin(0, 1, 3) // [2,3,3,4,5,6]

3.3 every()

// every(callback) 返回值 Boolean
// 作用：测试一个数组内的所有元素是否都能通过某个指定函数的测试
arr = [1,2,3,4,5]
arr.every(item => item > 2) // false
arr.every(item => item < 6) // true

3.4 fill()

// fill(value, start, end) 返回值：修改原数组
// 作用：修改start-end索引的值为value
let arr = [1,2,3,4,5,6]
arr.fill('z', 0, 2) // ['z', 'z', 3, 4, 5, 6]

3.5 filter()

// filter(callback) 返回值：新数组
// 作用：创建一个数组，包含所提供函数实现的所有元素
arr = [1,2,3,4,5]
let newArr = arr.filter(item => item > 3) // [4,5]

3.6 find()

// find(callback) 返回值：满足函数的第一个元素
// 作用：满足函数方法的第一个元素的值，没有就返回undefined
let arr = [1,2,3,4,5]
let num = arr.find(item => item > 3) // 4

3.7 findIndex()

// findIndex(callback) 返回值：满足函数的第一个元素的索引值
// 作用：满足函数方法的第一个元素的索引值，没有就返回-1
let arr = ['z', 'h', 'm']
let index = arr.findIndex(item => item === 'h') // 1

3.8 flat()

// flat(depth) depth：结构深度，默认为1 返回值：新数组
// 作用： 扁平化处理数组
let arr = [1,2,3,[4,5]]
let newArr = arr.flat() // [1,2,3,4,5]

3.9 forEach()

// forEach(callback) 无返回值
// 遍历数组
arr = ['z', 'h', 'm']
arr.forEach((item, index, arr) => {
	// item 数组每一项
	// index 数组每一项的索引
	// arr 数组本身
})

3.10 includes()

// includes(valueToFind fromIndex) fromIndex可选：从fromIndex索引开始寻找，如果fromIndex大于数组的长度，直接返回false 
// 返回值：Boolean
// 作用：判断一个数组是否包含一个指定的值
let arr = [1,2,3]
arr.includes(2) // true
arr.includes(4) // false
arr.includes(1, 4) // false

3.11 indexOf()

// indexOf(searchElement, fromIndex) fromIndex可选：从fromIndex索引开始寻找，如果fromIndex大于数组的长度，直接返回-1
// 返回值：查找要查询元素的第一个索引值，如果没有就返回-1
// 作用： 在数组中找到一个给定元素的第一个索引
let arr = [1,2,3]
arr.indexOf(1) // 0
arr.indexOf(4) // -1
arr.indexOf(1, 4) // -1

3.12 lastIndexOf()

和 indexOf 相反， 返回给定元素的最后一个索引值

3.13 join()

// join(separator) separator可选：指定一个字符串来分隔数组的每个元素，默认为(,)
// 返回值: 返回一个分割后的字符串
// 作用：将一个数组或类数组的所有元素根据分隔符连接成一个字符串，并返回这个字符串
let arr = [1,2,3]
arr.join() // '1,2,3'
arr.join('-') // '1-2-3'

3.14 map()

// map(callback) 返回值：新数组
// 作用：创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。
let arr = [1,2,3]
let newArr = arr.map(item => {
	item = item * 2
	return item
}) // [2,4,6]

3.15 pop()

// pop() 返回值：从数组中删除的最后一个元素，并返回该元素的值，修改原数组
// 作用：删除数组的最后一个元素
let arr = [1,2,3]
let item = arr.pop() // 3
arr // [1,2]

3.16 push()

// push() 返回值：数组的新长度，修改原数组
// 作用：将一个或多个元素添加到数组的末尾
let arr = [1,2,3,4]
let length = arr.push(5) // 5
arr // [1,2,3,4,5]

3.17 reduce()

// reduce(callback, value) 返回值：处理之后的结果
// 作用：对数组中的每个元素执行一个由您提供的**reducer**函数(升序执行)，将其结果汇总为单个返回值。
let arr = [1,2,3,4]
// pre 如果没有value参数，默认值就是数组的第一项，如果有value参数，默认值就是value的值，每次函数return的值 就会覆盖pre的值
// cur 数组每一项
let sum = arr.reduce((pre, cur, index, arr) => {
	return pre+cur
}) // 1+2+3+4

// 数组去重
let arr1 = [1,1,2,3,3]
arr1.reduce((pre, cur) => {
	!pre.includes(cur) && pre.push(cur)
	return pre
}, []) // [1,2,3]

3.18 reverse()

// reverse() 返回值: 改变后的数组
// 作用：对数组进行位置的颠倒
let arr = [1,2,3]
arr.reverse()

3.19 shift()

// shift() 返回值: 从数组删除的第一个元素值
// 作用：从数组中删除第一个元素
let arr = [1,2,3]
arr.shift() // 1
arr // [2,3]

3.20 slice()

// slice(start, end) 返回值: 新数组
// 作用：截取数组start-end的值为一个新数组，可以填写负数，就是倒着来。
let arr = [1,2,3,4]
arr.slice(1,3) // [2,3]

3.21 some()

// some(callback) 返回值：Boolean
// 作用：测试数组中是不是至少有1个元素通过了被提供的函数测试
let arr = [1,2,3]
arr.some(item => item === 2) // true
arr.some(item => item === 0) // false

3.21 sort()

// sort(compareFunction) 返回值：排序后的新数组
// 作用：对数组的元素进行排序，并返回数组
let arr = [2,1,4,3]
arr.sort() // [1,2,3,4]
arr.sort((a, b) => {
	return b-a
}) // [4,3,2,1]

3.22 splice()

// splice(start, count, item1, item2...) start 索引值 count 要删除的个数 item1, item2 替换的元素
// 返回值：由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组 改变原数组
// 作用：通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
let arr = [1,2,3,4,5]
arr.splice(1, 1) // [2] 从index为1的位置删除一个元素
arr // [1,3,4,5]

let arr1 = [1,2,3,4,5]
arr1.splice(0, 2, 'z', 'h') // [1,2]
arr1 // ['z', 'h', 3, 4, 5]

3.23 unshift()

// unshift() 返回值：数组的新长度 修改原本数组
// 作用：将一个元素或多个元素添加的数组的开头
let arr = [1,2,3]
arr.unshift(4) // [4]
arr [4,1,2,3]

3.24 toString()

// toString() 返回值：数组元素组成的字符串
// 作用：返回一个字符串，表示指定的数组及其元素
let arr = [1,2,3]
arr.toString() // '1,2,3'