数据结构和算法(一)：数组

数组的迭代器函数

every —— 如果每一次迭代都返回true，则该迭代器最终返回true，否则返回false。

const arr = [12, 22, 35, 1, 99, 129, 3, 11]
const ret = arr.every((val, index, arr) => {
  return val % 2 === 0 // 第三次迭代的时候返回了false，所有最终结果为false
})

console.log(ret) // => false

some —— 如果有任何一次迭代返回了true，则该迭代器最终会返回true

const arr = [11, 22, 35, 1, 99, 129, 3, 11]
const ret = arr.some((val, index, arr) => {
  return val % 2 === 0 // 第二次迭代返回了true，即便第一次迭代返回的false，其最终结果也会返回true
})

console.log(ret) // true

forEach —— 执行回调函数中的程序（和for循环类似，非常常用的方法），返回undefined

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const ret = arr.forEach((val, index, arr) => {
  console(val) // 将会依次打印arr数组的各个元素
})

map —— 该方法用于对数组的元素进行处理，最终返回一个新数组，新数组的元素就是回调函数中的返回值

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const ret = arr.map((val, index, arr) => {
  return val * 2 // 该值就是该迭代器返回的数组的元素值
})

console.log(ret) // [22, 44, 70, 2, 104, 258, 8, 22]

filter —— 返回一个满足条件值的数组

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const ret = arr.filter((val, index, arr) => {
  return val % 2 === 0 // 当该等式返回true时，此次迭代的val将会被放入ret数组中
})

console.log(ret) // [22, 52, 4]

reduce —— 当我们需要类似累加之类的操作时，使用这个函数将会非常方便

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const ret = arr.reduce((previousVal, currentVal) => {
  return previousVal + currentVal // previousVal 是上一个元素，currentVal是当前元素
  // 当然我们也可以累乘
  // return previousVal * currentVal
})

console.log(ret); // 265 （这是arr所有元素累加的结果）

for…of —— 当我们不需要关心数组索引的时候，可以使用 for…of 循环

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
for (let val of arr) {
  console.log(val); // 将会依次打印arr数组的各个元素
}

@@iterator对象 —— 需要通过 next 方法不断的触发迭代

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
let iterator = arr[Symbol.iterator]()
console.log(iterator.next().value); // 11
console.log(iterator.next().value); // 22
console.log(iterator.next().value); // 35
// ... 每一次iterator.next().value都会返回对应的元素，直到最后（第arr.length + 1次时）会返回undefined

entries —— 与@@iterator对象相似，需要通过 next 方法不断的触发迭代

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
let entries = arr.entries()
console.log(entries.next().value); // [0, 11]
console.log(entries.next().value); // [1, 22]
console.log(entries.next().value); // [2, 35]
// ... 每一次iterator.next().value都会返回对应的索引/元素数组，直到最后（第arr.length + 1次调用时）会返回undefined

Array.from —— 传入一个数组，创建新数组

我们可以通过它来对数组进行深拷贝

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const arr2 = Array.from(arr)
console.log(arr) // [11, 22, 35, 1, 52, 129, 4, 11]
console.log(arr === arr2) // false

还可以传入一个回调函数用于设置新数组的元素，这与map方法是不是很相似呢

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const arr2 = Array.from(arr, x => x * 2)
console.log(arr2) // [22, 44, 70, 2, 104, 258, 8, 22]

Array.of —— 根据传入的参数创建新数组

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const arr2 = Array.of(...arr) // [11, 22, 35, 1, 52, 129, 4, 11]

fill —— 传入的参数用于填充数组

如果只传一个参数，则填充该数组的所有索引的值

const arr = new Array(5).fill(1)
console.log(arr) // [1, 1, 1, 1, 1]

第一个参数为填充的值，第二个参数为填充的起始索引，第三个参数为填充的结尾索引
如以下例子，传入的参数分别为1、2、5，意味着将会在数组2 ~ 5（不包括5）之间填充数字1

const arr = [11, 22, 35, 1, 52, 129, 4, 11]
const arr2 = arr.fill(1, 2, 5)
console.log(arr2); // [11, 22, 1, 1, 1, 129, 4, 11]