Array

array.at() 根据索引找值

数组的取值方法。接收一个整数值返回该索引的值，可以输入正负值，负值从后向前倒数。

array.concat() 数组拼接

数组拼接方法。用于拼接两个或多个数组。返回一个新数组、传入多维数组只展开一层、不过滤相同元素。 a.concat(b,c)

Array.from() 大A，

是数组对像的方法，将一个类数组或可遍历的对象 转换成一个真数组。

• 将类数组（有length属性、属性名(key)必须是数字或字符串数字）转为真数组
• 将Set的数据结构转换成真数组
• 传入字符串，会转换成字符传分割的数组
• 传入真数组，返回一模一样的新数组
• 可以接收第二个参数Fn，类似于数组map的方法，处理返回每一项的值（Array.from(set, item => item + 1)）

注： 类数组的属性名(key)必须是数字或字符串数字，不然转成后会成为有length的undefined

Array.isArray()

检测一个对象是否为数组。

if(!Array.isArray){
    Array.isArray = function(value) {
      return Object.prototype.toString.call(value) === '[object Array]';
    }
}

typeof、Array.isArray()、Object.prototype.toString.call(val)、instanceof

Array.of() 大A,值转为数组

用于将一组值转换为数组

Array.of(3,5,8)   //[3, 5, 8]
Array.of()        // []

// 为了弥补 array()方法的缺陷
Array(3)     //[ , , ]
Array.of(3)  // [3]

//模拟
function ArrayOf{
    return [].slice.call(arguments)
}

array.copyWithin(target, start, end)

用于从数组的指定位置拷贝元素到数组的另一个指定位置中。返回修改后的数组（即直接修改原数组），不会改变数组的长度。

• target：目的起始位置。
• start：复制源的起始位置，可以省略，可以是负数。
• end：复制源的结束位置，可以省略，可以是负数，实际结束位置是的索引（省略是数组length）。

var array = ['1', 'a', '2', 'b', 3, 'c']
array.copyWithin(3, 1, 5)  //['1', 'a', '2', 'a', '2', 'b']

array.every() 一个不通过返回false

方法使用指定函数检测数组中的所有元素：

• 如果数组中检测到有一个元素不满足，则返回 false ，且剩余的元素不会再进行检测。
• 如果所有元素都满足条件，则返回 true。
• every() 不会对空数组进行检测。
• every() 不会改变原始数组。

let ages = [32, 33, 16, 40];
ages.every(item => item > 18)

array.some() 一个通过就是true

方法使用指定函数检测数组中的所有元素：

• 如果数组中检测到有一个元素满足，返回 true ，且剩余的元素不会再进行检测。
• 如果所有元素都没有满足条件，则返回 false。
• every() 不会对空数组进行检测。
• every() 不会改变原始数组。

let ages = [32, 33, 16, 40];
ages.some(item => item > 18)

array.fill(value, start, end)

value	必需。填充的值。
start	可选。开始填充位置。
end	可选。停止填充位置 (默认为 array.length)

const arr = new Array(3).fill('ha'); // ['ha', 'ha', 'ha']
对像数组要注意，指定下标也是全改变

array.filter(fn)

常用操作，用于过滤元素，然后返回剩下的元素。传入的函数依次作用于每个元素，true 还是false

const arr = [1, 6, 9, 10, 100, 500,8]
const result = arr.filter(item => item % 2 === 0)
result // [6, 10, 100, 500, 8]

array.find(fn(currentValue, index, arr))

find()函数返回true，则停止迭代，并返回currentValue；如果没有搜索到，则返回undefined

• 注意：在函数执行中添加数组不会被执行，但执行后的结果里是有的

let a = [1,2,3,4,5,6]
a.find((item, index) => {
    if(index == 0){
        a.push(10)
    }
    console.log(item) // 1、2、3、4、5、6
})
console.log(a) // [1, 2, 3, 4, 5, 6, 10]

let a = [1,2,3,4,5,6]
a.find((item, index) => {
    if(index == 0){
        a.pop()
    }
    console.log(item)  // 1、2、3、4、5、undefined
})
console.log(a) // [1, 2, 3, 4, 5]

array.findIndex(fn(currentValue, index, arr))

findIndex()函数是查找目标元素，找到就返回元素的位置，找不到就返回-1 同上

array.findLast(fn(currentValue, index, arr))

findLast()函数从后向前查找目标元素，找到就返回元素，找不到就返回undefined 同上

array.findLastIndex(fn(currentValue, index, arr))

findLastIndex()函数从后向前查找目标元素，找到就返回元素的位置，找不到就返回-1 同上

array.flat() - 拉平多维数组

flat() 方法会按照一个可指定的深度拉平数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

arr2.flat()  // 默认1层 //过滤空数组
arr3.flat(2);   //指定层级2
arr4.flat(Infinity);  //无限层级 reduce 和 concat的结合版

array.flatMap(fn)

flatMap()可以理解为flat和map的结合体; flat对应的是扁平化功能; map对应的是对数组每个元素的操作功能;

array.forEach(fn(currentValue, index, arr), thisValue)

forEach适用于只是遍历，for则在较复杂的循环中效率更高,forEach无法中断循环,除非程序报错。

• 基本类型的数据，无法更改
• 引用数据类型的是可以更改的

array.includes(searchEl, fromIndex[省略为0])

includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

• searchEl:可以传入一个数组 ['aa', 'bb', 'cc],是否包含 aa || bb || cc
• fromIndex:大于等于数组长度,则返回 false;该数组不会被搜索。
• 解决 indexOf的语义化和NaN的匹配

array.indexOf(searchEl, fromIndex[省略为0])

一维数组元素中搜索指定对象，然后返回其首个匹配项的索引。 范围从指定索引到该数组结尾。

array.indexLashOf(searchEl, fromIndex[省略为0])

一维数组元素中从后向前搜索指定对象，然后返回其首个匹配项的索引。 范围从指定索引到该数组结尾从后向前数。

array.join() 数组转成字符串

将数组的元素连接转成字符串。字符串的元素将由指定的分隔符分隔，其默认值为(，)。

array.toLocaleString() - toString加强,本地符号分隔

[12345].toLocaleString()    // '12,345'

array.toString() - 返回给定数组的字符串形式

[1,2,3].toString()    // '1,2,3'

array.map(fn(currentValue,index,arr), thisValue)

• map方法会返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
• forEach方法返回值则永远是undefined。

[1,  2, 3].map(parseInt); // 1, NaN, NaN

array.reduce(callback, [initialValue]) - 迭加器 - 号称万能数组操作

callback （执行数组中每个值的函数，包含四个参数）

    1、previousValue （上一次调用回调返回的值，或者是提供的初始值（initialValue））
    2、currentValue （数组中当前被处理的元素）
    3、index （当前元素在数组中的索引）
    4、array （调用 reduce 的数组）

initialValue： `省略时为1，应该是0；空数组不加默认值会报错`。

// 简单方法 数组求合，求乘积
const arr = [1, 2, 3, 4];
const sum = arr.reduce((x,y) => x+y)
const mul = arr.reduce((x,y) => x*y)
console.log( sum ); //10
console.log( mul ); //24

// 计算数组中每个元素出现的次数
const names = ['A', 'D', 'T', 'B', 'A'];
const nameNum = names.reduce((pre,cur) => {
  if(cur in pre) {
    pre[cur]++
  } else {
    pre[cur] = 1 
  }
  return pre
},{})
console.log(nameNum); //{A: 2, B: 1, T: 1, D: 1}

//数组去重
const arr = [1,2,2,4,4,1]
const newArr = arr.reduce((pre,cur) => {
    if(!pre.includes(cur)) {
      return pre.concat(cur)
    } else {
      return pre
    }
},[])
console.log(newArr);// [1, 2, 4]

// 将二维数组转化为一维
const arr = [[0, 1], [2, 3], [4, 5]]
const newArr = arr.reduce((pre,cur) => {
    return pre.concat(cur)
},[])
console.log(newArr); // [0, 1, 2, 3, 4, 5]

// 多维数组转化为一维
function Flat(arr = []) {
   return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
}

//获取数组中最大值和最小值
let arr = [3.24, 2.78, 999];
arr.reduce((x, y) => Math.max(x, y));
arr.reduce((x, y) => Math.min(x, y));

array.reduceRight(callback, [initialValue]) - 从后向前

同上 reduce()

array.pop() 删除最后一个元素

pop() 方法移除数组的最后一个元素，并返回该元素

array.shift() 删除第一个元素

shift() 方法移除数组的第一个元素，并返回该元素

array.push() 最后面添加

push() 方法向数组最后面添加元素

array.unshift() 最前面添加

unshift() 方法向数组最前面添加元素

array.slice(num1,num2) - 数组截取

可以截取数组的任意一端，并将截取到的数组返回，但需注意的是它并不改变原数组。

• num1:开始截取数组的位置（包含该位置的元素）,如果内有传，则默认为0
• num2:停止截取数组的位置（不包含该位置的元素），如果没有传，则默认值是数组的长度length。

array.splice(start, num, value...) - 插入、删除或替换元素

• start——必须，整数，规定添加或者删除的位置，使用负数，从数组尾部规定位置。
• num ——必须，要删除的数量，如果为0，则不删除项目。
• value ——可选，向数组添加的新项目，删除0个就是插入。

array.reverse() - 数组反转

reverse() 方法反转数组中元素的顺序

array.sort() - 排序

arr.sort(function(a,b){
  return a-b; //从小到大
});

arr.sort(function(a,b){
  return b-a; //从大到小
});

array.entries() - 索引和键值 对比keys、values

用于获取一个新的Array，其中包含数组每个索引的键和值对。

let arr = ['a', 'b', 'c', 'd'];
var arr2 = arr.entries()
for (let e of arr2) {
     console.log(e)
   }
[0, 'a']
[1, 'b']
[2, 'c']
[3, 'd']

arr2.next().value 每一项都是数组

array.keys()

keys()方法创建并返回新的迭代器对象，它保存数组中每个索引的键。此方法不会影响原始数组。

array.values()

values()方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值。

它们都返回一个遍历器对象，可以用for…of循环进行遍历，唯一的区别是 keys()是对键名的遍历、 values()是对键值的遍历， entries()是对键值对的遍历.

let arr = ['a', 'b', 'c']
for (let index of arr.keys()) {
console.log(index);
}
// 0
// 1
// 2
for (let item of arr.values()) {
console.log(item);
}
// 'a'
// 'b'
// 'c'
for (let [index, item] of arr.entries()) {
console.log(index, item);
}
// 0 'a'
// 1 'b'
// 2 'c'