携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第1天

浏览器支持没有特殊说明则支持，主要考虑浏览器为谷歌和IE

遍历（执行次数等于数组长度的方法）

map

可修改数组中的每个值，然后返回为新数组，如果没有return则新数组全部为undefined
不改变原数组（如果原数组的内容是引用类型是可以改变的）
函数执行次数等于数组长度
map函数在遍历的时候是将这个过程抽离出来的，这时我们可以更大程度的去操作这个过程（即对遍历的内容做处理）
不对未初始化的值进行任何操作（for循环中有介绍）
如果数组中是引用类型，map返回的新数组和原数组依然存在引用关系
项目中常用于：返回某一个属性值作为新数组或者修改数组里的元素存入新的数组
支持浏览器：IE9+

//  数组的每一个元素 * 0.8 
 let arr = [ 10,100,1000]
 let res =  arr.map( (item,index) => {
     return item*0.8
 })
 console.log(res);  //  [8，80，800]

let arr1 = [{
  name:'yfeng',
  age:18
}]
let res1 =  arr1.map( (item,index) => {
      item.age = item.age*0.8;
     return item
})
console.log(arr1);// [{0: age: 14.4,name: "yfeng"}]
console.log(res1)// [{0: age: 14.4,name: "yfeng"}]

// 项目中常用：返回选中项的code值
const selectArr = [{
  name:'yangf',
  code:'1'
},{
  name:'yangf1',
  code:'2'
}];
const selectArrCode = selectArr.map(item => item.code);
// ['1','2']

// 新数组和原数组存在引用关系
const arr2 = [{
    name:'yangf',
    num:1
},{
    name:'yangf1',
    num:2
},{
    name:'yangf2',
    num:3
}]
const arr3=arr2.map((item)=>{
    item.num++
    return item;
})
arr1[1].num = 5
console.log(arr3[1].num) // 5
console.log(arr2[1].num) // 5

filter

筛选符合return条件的项组成新数组，如果没有符合条件的，则新数组为[]
不改变原数组（如果原数组的内容是引用类型是可以改变的）
函数执行次数等于数组长度
不对未初始化的值进行任何操作（for循环中有介绍）
项目中常用于：排除某些不想要的元素
支持浏览器：IE9+

// 筛选大于10的数据
let arr = [ 10,100,1000]
let res =  arr.filter( (item,index) => {
	return item>10
})
console.log(arr);//[100,1000]

forEach

没有返回值，循环不能被任何方式终止，除了使用try-catch
不能修改原数组，（MDN上说的是forEach不会直接改变调用它的对象，但是那个对象可能会被callback函数改变）

- 我的理解是：遍历本身的栈内存数据是不能修改的，操作对象本身是可以修改的；还有就是数组中如果是引用数据类型也是可以修改的

函数执行次数等于数组长度
不对未初始化的值进行任何操作
项目中常用：类似于for循环，循环访问数组中所有元素，一般循环次数未知的时候用forEach，修改值一般使用map
支持浏览器：IE9+

const arr = [1,2,3];
arr.forEach((item)=>{
    item+=2;
});
console.log(arr); // [1,2,3]

// 不推荐这样做
arr.forEach((item,index)=>{
    arr[index] += 2;
});
console.log(arr); // [3,4,5]

// 数组中的引用类型可以修改
const arr1 = [{
    name:'yangf',
    num:5
},{
    name:'yangf1',
    num:6
},{
    name:'yangf2',
    num:7
}];
arr1.forEach((item)=>{
    item.num+=1;
})
console.log(arr1)
// [{
//    name:'yangf',
//    num:6
// },{
//    name:'yangf1',
//    num:7
// },{
//    name:'yangf2',
//    num:8
// }]

// 不对未初始化的值进行任何操作，即index也不会被打印
const arr2 = [1,2,,4];
arr2.forEach((item,index)=>{
    console.log(item,index)
})
// 1 0
// 2 1
// 4 3

// item等于2之后会跳出循环
try {
    arr2.forEach((item,index)=>{
        console.log(item)
        if(item === 2){
            throw new Error(index)
        }
    })
} catch (error) {
    console.log(error)
}

every（查找）

返回值始终为true或者false；如果每一项都符合return条件，则返回true，否则返回false
不改变原数组（如果原数组的内容是引用类型是可以改变的）
执行次数等于数组长度
不对未初始化的值进行任何操作（for循环中有介绍）
项目中常用于：检查是否数组中每一项都符合某个条件
支持浏览器：IE9+

const arr = [1,2,3];
console.log(arr.every(item => item>0)) // true
console.log(arr.every(item => item>1)) // false

reduce

返回return计算的值，接收两个参数

- 第一个参数callback（包含四个参数）

- - preValue，上一次调用callback返回的值；如果指定initialValue，则将initialValue作为第一次调用的值；否则将array[0]作为第一次调用的值
  - currentValue，数组中正在遍历的值，在第一次调用的时候如果指定了initialValue，其值为array[0]，否则为array[1]
  - currentIndex，数组中正在遍历的元素的索引
  - array，当前被遍历的数组

- 第二个参数initialValue（作为callback的初始值）

不改变原数组（如果原数组的内容是引用类型是可以改变的）
执行长度：如果没有initialValue，执行长度等于array.length-1；如果有initialValue，执行长度等于array.length
不对未初始化的值进行任何操作（for循环中有介绍）
项目中主要用于累加
如果数组为空，且没有initialValue，会抛出错误，所以最好设置初始值
支持浏览器：IE9+

const array = [1,, 2, 3, 4, 5];
const flag = array.reduce((pre,cur,index)=>{
  cur = 1;
  console.log(index) // 0 2 3 4 5
  return pre + cur;
},0)
console.log(flag) // 5
console.log(array) // [1, empty, 2, 3, 4, 5]

reduceRight

和reduce完全一样，只是该函数从右边开始遍历

查找（执行次数可能小于数组长度的方法）

find

返回数组中满足return条件的第一项元素，如果都不满足返回undefined
不改变原数组（如果原数组的内容是引用类型是可以改变的）
执行次数可能小于数组长度
不会跳过未初始化的值
项目中常用于：只需有一项满足条件即可的情况，并且需要知道该项的内容
支持浏览器：IE不支持、谷歌45+、Edge12+

const arr = [{
	name:'yangf',
	num:1
},{
	name:'yangf1',
	num:2
},{
	name:'yangf2',
	num:3
}]
const arr1=arr.find((item,index)=>{
	console.log(index) // 这里只会打印一次
	return item.num ===1;
})
console.log(arr1) 
//  {
//		name:'yangf',
//		num:1
//  }
		
const arr2 = [2,3,,5];
const arr3=arr2.find((item,index)=>{
    console.log(index) // 这里下标会打印0，1，2，3
    return item === 5;
})
console.log(arr3) // 5

findIndex

类似于find函数，不同之处是该函数返回的是第一个匹配元素的索引；如果没有匹配的返回-1
不改变原数组（如果原数组的内容是引用类型是可以改变的）
执行次数可能小于数组长度
不会跳过未初始化的值
项目中常用于：只需有一项满足条件即可的情况，并且需要知道该项的索引值
支持浏览器：IE不支持、谷歌45+、Edge12+

const arr = [2,3,,5];
const index1 = arr.findIndex((item,index)=>{
    console.log(index) // 0,1,2,3
    return item > 5;
})
console.log(index1) // -1

findLast

和find一样，只是该方法是从后往前面查找，返回的是第一个匹配的项，没有匹配返回undefined
不改变原数组（如果原数组的内容是引用类型是可以改变的）
执行次数可能小于数组长度
不会跳过未初始化的值
支持浏览器：IE不支持、谷歌97+、Edge97+

findLastIndex

和findIndex一样，该方法从后面往前查找，返回第一个匹配项的索引，没有匹配返回-1
支持浏览器：IE不支持、谷歌97+、Edge97+

includes

判断数组是否包含某个元素，如果包含某个元素返回true，否则返回false；接收两个参数

- 第一个参数必须是个值，不支持回调；
- 第二个参数是查找的起始索引(formIndex)，默认为0

- - 如果为负值，按arr.length+fromIndex的索引开始查找，如果值大于等于数组长度直接返回false；如果计算出的索引小于0，会搜索整个数组

不改变原数组
查找对比的时候使用===
执行次数可能小于数组长度（MDN说第二个参数大于等于数组长度直接返回false，且不搜索该数组）
支持浏览器：IE不支持、谷歌47+、Edge14+

const arr = [1,2,3];
console.log(arr.includes(2)) // true
// 从第三个元素开始查找，没有2
console.log(arr.includes(2,2)) // false
// 从第三个元素开始查找，有3
console.log(arr.includes(3,2)) // true
// 第二个参数大于等于数组长度，返回false
console.log(arr.includes(3,3)) // false
// -100+3等于-97，相当于从索引0开始查找
console.log(arr.includes(3, -100)); // true
// -1+3等于2，从第三个元素开始查找
console.log(arr.includes(2, -1)); // false

indexOf

返回给定元素在数组中的索引值，如果没有返回-1；接收两个参数

- 第一个参数，要查找的元素
- 第二个参数，开始查找的位置（索引值），默认0

- - 如果该值大于等于数组长度，不会查找返回-1
  - 如果是负值，负一则从最后一个元素开始查找，负二则从倒数第二个元素开始查找；查找的顺序是往后的并不是往前的（需要特别注意）
  - 如果负值的绝对值大于等于数组长度，会在整个数组中查找

查找对比的时候使用===
浏览器兼容：IE9+

const arr = [1,2,3];
console.log(arr.indexOf(2)) // 1
console.log(arr.indexOf(2,2)) // -1
console.log(arr.indexOf(3,2)) // 2
console.log(arr.indexOf(3,3)) // -1
console.log(arr.indexOf(3, -100)); // 2
console.log(arr.indexOf(2, -1)); // -1

lastIndexOf

相对于indexOf，lastIndexOf是从后往前查找，返回的也是元素在数组中的索引值，没有返回-1；接收两个参数

- 第一个参数，要查找的元素
- 第二个参数，开始查找的位置（索引值），默认为arr.length-1

- - 如果该值大于或等于数组的长度，则整个数组会被查找
  - 如果为负值，也是从后往前查找，该值表示从后往前的偏移（-1代表最后一个值开始往前，-2代表倒数第二个值开始往前），如果负值的绝对值大于数组长度，返回-1

查找对比的时候使用===
浏览器兼容：IE9+

const arr = [1,2,3];
console.log(arr.lastIndexOf(2)) // 1
// 从索引值为2的位置（最后一个）开始向前查找
console.log(arr.lastIndexOf(2,2)) // 1
// 从索引值为2的位置（最后一个）开始向前查找
console.log(arr.lastIndexOf(3,2)) // 2
// 从索引值3大于数组长度，所以会查找整个数组
console.log(arr.lastIndexOf(3,3)) // 2
// 索引值为负数，绝对值大于数组长度，默认不查找
console.log(arr.lastIndexOf(3, -100)); // -1
// 索引值为负，从该值从后往前的偏移（即-1为最后一个值，-2为倒数第二）个值开始往前查找
console.log(arr.lastIndexOf(2, -1)); // 1

some

如果至少有一项满足return条件，返回true，全部都不满足返回false
不会改变原数组（如果原数组的内容是引用类型是可以改变的）
函数执行次数可能小于数组长度
不对未初始化的值进行任何操作（for循环中有介绍）
项目中常用于：和find差不多，只是返回值不一样
支持浏览器：IE9+

const array = [1,, 2, 3, 4, 5];
const flag = array.some((item,index)=>{
    console.log(index) // 0,2
    return item%2 === 0;
})
console.log(flag) // true

其他处理数组方法

concat

用于合并两个或多个数组或者某些值
不会改变原数组
返回拼接后的新数组
如果原始数组中有引用数据类型，新数组中对原数组是浅拷贝(只是将对象引用复制到新数组中)
浏览器兼容：很好，IE6+

const arr1 = [1,{name:'xiaoxixi'},3];
const arr2 = [4,5,6];
const arr3 = [7,8,9];
const arr4 = arr1.concat(arr2);
const arr5 = arr1.concat(arr2,7,8,9);
const arr6 = arr1.concat(arr2,arr3);
arr4[1].name = 'liuruixi';
console.log(arr1); // (6) [1, {name:'liuruixi'}, 3]
console.log(arr4); // (6) [1, {name:'liuruixi'}, 3, 4, 5, 6]
console.log(arr5); // (9) [1, {name:'liuruixi'}, 3, 4, 5, 6, 7, 8, 9]
console.log(arr6); // (9) [1, {name:'liuruixi'}, 3, 4, 5, 6, 7, 8, 9]

copyWithin

复制数组中的一部分到同一数组中的另一个位置
不会改变原数组的长度
语法：arr.copyWithin(target,start,end)

1. target：从该位置开始替换数据，如果没有值返回原数组
2. start：从该位置开始复制数据，默认为0
3. end：到该位置之前停止复制数据，默认是arr.length，如果end小于start不会发生复制
4. 如果值是负数从末尾开始替换，-1代表最后一位

支持浏览器：IE不支持、谷歌45+、Edge12+

[1, 2, 3, 4, 5].copyWithin(-2); // [1, 2, 3, 1, 2]
// 从倒数第二位开始替换数据，复制的数据是从倒数第三位到最后一位
[1, 2, 3, 4, 5].copyWithin(-2, -3, -1); // [1, 2, 3, 3, 4]

at

接收一个参数（整数）），返回该参数为索引的数组项

- 如果参数为正数，参数为数组索引
- 如果参数为负数，最后一个项目开始倒数

支持浏览器：IE不支持，谷歌92+
如果浏览器支持比较好，获取最后一个元素用起还是比较方便

const array = [1,, 2, 3, 4, 5];
console.log(array.at(2)) // 2
// 使用.at获取数组后面的元素
console.log(array.at(-1)) // 5
console.log(array.at(-2)) // 4

// 使用数组长度获取最后一个元素
console.log(array[array.length - 1]); // 5

// 使用 slice() 方法,注意会返回一个数组
const sliceWay = array.slice(-1);
console.log(sliceWay[0]); // 5

// 使用pop
console.log(array.pop())

fill

用一个固定值填充数组中从起始索引到终止索引内的全部元素，不包括终止索引
接收三个参数

- value，用来填充数组的元素；value可以是任意值
- start，起始索引
- end，终止索引

不可以填充空数组；可以填充未初始化的值
浏览器支持：不支持IE，谷歌45+

const arr = [1];
arr.fill({name:'yfeng'},0,5);
console.log(arr)
// [{name:'yfeng'}]
// 数组中依然是只有一个值的
const arr1 = [1,,];
arr1.fill(2,0,5);
console.log(arr1) // [2,2]

flat

扁平化数组；按照该参数指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回
接收一个参数depth

- 默认值为1
- 使用 Infinity，可展开任意深度的嵌套数组

会过滤未初始化的项，如果初始的值为undefined、null等是不会被过滤的
不改变原数组，是返回的新数组
浏览器支持：不支持IE，谷歌69+

const arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat()); // [0, 1, 2, 3, 4]
const arr2 = [0, 1, 2, [[[3, 4]]]];
console.log(arr2.flat());  // [0, 1, 2, [[3, 4]]]
console.log(arr2.flat(2)); // [0, 1, 2, [3, 4]]
console.log(arr2.flat(Infinity)); // [0, 1, 2, 3, 4]
var arr3 = [1, 2, , undefined,null,4, 5];
console.log(arr3.flat()); // [1, 2, undefined, null, 4, 5]  中间的未初始化项不在了

from

将一个类似数组或者可迭代对象创建为一个新的、浅拷贝的数组实例
接收两个参数

- 第一个参数为想要转换的类似数组或可迭代对象（必传）
- 第二个参数为回调（非必须）

常用：数组去重合并
浏览器支持：不支持IE，谷歌45+

// 字符串转数组
console.log(Array.from('foo')); // ['f','0','0'] 
// set转数组
const set = new Set(['foo', 'bar', 'baz', 'foo']);
console.log(Array.from(set));// ["foo","bar","baz"]
// map转数组
const map = new Map([[1, 2], [2, 4], [4, 8]]);
console.log(Array.from(map));// [[1, 2], [2, 4], [4, 8]]
console.log(Array.from(map.values()));// [2,4,8]
console.log(Array.from(map.keys()));// [1,2,4]
// 指定回调
const arr = [1,2,3];
console.log(Array.from(arr, x => x + x));// [2,4,6]
Array.from({length: 5}, (v, i) => i); // [0,1,2,3,4]
// 数组去重合并
const arr1 = [1,2,3];
const arr2 = [2,3,4,5];
console.log(Array.from(new Set(arr1.concat(arr2)))); // [1,2,3,4,5]
// 写成公用方法
function combine(){
    let arr = [].concat.apply([], arguments);  //没有去重复的新数组
    return Array.from(new Set(arr));
}

join

将一个数组中的所有元素连接成一个字符串并返回；如果只有一个元素，则返回该元素
接收一个参数，按照该参数拼接；如果不传参数，则用,拼接；如果想元素之间没有任何字符传入空字符串
如果一个元素是undefined或者null，返回时该元素为空字符串
不改变原数组
浏览器支持：很好

const a = ['Wind', 'Rain', 'Fire'];
console.log(a.join()); // "Wind,Rain,Fire"
console.log(a.join(", ")); // "Wind, Rain, Fire"
console.log(a.join(" + ")); // "Wind + Rain + Fire" 
console.log(a.join("")); // WindRainFire
const arr = [undefined,null,'yangfeng'];
console.log(arr.join()); // ",,yangfeng"

pop

从数组中删除最后一个元素，并返回该元素的值
数组为空返回undefined
会改变原数组
浏览器支持：很好

const myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

const popped = myFish.pop();

console.log(myFish); // ['angel', 'clown', 'mandarin']

console.log(popped); // 'sturgeon'

push

将一个或多个元素添加到数组的末尾，并返回该数组的新长度
会改变原数组
浏览器支持：很好

var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");
console.log(sports);
// ["soccer", "baseball", "football", "swimming"]
console.log(total);
// 4

reverse

将数组中元素的位置颠倒，并返回该数组
会改变原数组
浏览器支持：很好

const a = [1, 2, 3];
console.log(a); // [1, 2, 3]
console.log(a.reverse()); // [3, 2, 1]
console.log(a); // [3, 2, 1]

shift

从数组中删除第一个元素，并返回该元素的值
会改变原数组
浏览器支持：很好

let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];
console.log(myFish.shift()); // 'angle'
console.log(myFish); // ['clown', 'mandarin', 'surgeon']

slice

浅拷贝数组，接收两个参数；开始位置（包含），结束位置（不包含）
不改变原数组
如果没有可复制元素，返回空数组
浏览器支持：很好

var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
var citrus = fruits.slice(1, 3);
console.log(fruits);
// ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
console.log(citrus);
// ['Orange','Lemon']
var citrus1 = fruits.slice(-1,-3);
console.log(citrus1); // []

sort

对数组的元素进行排序，并返回数组；默认排序顺序是在将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列时构建的
接收一个函数为参数compareFunction，用于指定按某种顺序进行排列的函数；函数里面接收两个参数a和b

- compareFunction(a, b)

- - 小于 0，那么 a 会被排列到 b 之前
  - 等于 0 ， a 和 b 的相对位置不变
  - 大于 0 ， b 会被排列到 a 之前
  - 如果没有返回值，否则排序的结果将是不确定的

要比较数字而非字符串，比较函数可以简单的以 a 减 b则会将数组升序排列
改变原数组
执行次数受原数组的排序情况影响

const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1); // [1, 100000, 21, 30, 4]
const numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  console.log(a);// 执行7次
  return a - b;
});
console.log(numbers); // [1, 2, 3, 4, 5]
const numbers1 = [5, 4, 3, 2, 1];
numbers1.sort(function(a, b) {
  console.log(a);// 执行4次
  return a - b;
});
console.log(numbers1); // [1, 2, 3, 4, 5]
var items = [  { name: 'Edward', value: 21 },  { name: 'Sharpe', value: 37 },  { name: 'The', value: -12 }];
// sort by value
items.sort(function (a, b) {
  return (a.value - b.value)
});
console.log(items);
// [{name: 'The', value: -12},{name: 'Edward', value: 21},{name: 'Sharpe', value: 37}]

splice

删除或替换现有元素或者原地添加新的元素来修改数组；以数组形式返回被修改的内容
参数

- start：指定开始修改的位置，如果超出了数组长度，从数组末尾开始修改；如果是负值，表示从数组末位开始的第几位
- deleteCount：将要删除的元素个数，如果该参数大于start之后的元素的总数，则start之后的元素都将被删除，如果该参数为0或者负数，则不移除元素
- 要添加进数组的元素，如果不指定，则函数只删除数组元素

会改变原数组
浏览器支持：很好

const myFish = ["angel", "clown", "mandarin", "sturgeon"];
const removed = myFish.splice(2, 0, "drum");
console.log(myFish); // ['angel', 'clown', 'drum', 'mandarin', 'sturgeon']
console.log(removed); // []
// 舍去中间的参数将不做处理
const myFish1 = ["angel", "clown", "mandarin", "sturgeon"];
const removed1 = myFish1.splice(2, "drum");
console.log(myFish1); // ['angel', 'clown', 'mandarin', 'sturgeon']
console.log(removed1); // []

const myFish2 = ["angel", "clown", "mandarin", "sturgeon"];
const removed2 = myFish2.splice(2, 0, "drum","guitar");
console.log(myFish2); // ['angel', 'clown', "drum","guitar", 'mandarin', 'sturgeon']
console.log(removed2); // []

const myFish3 = ["angel", "clown", "mandarin", "sturgeon"];
const removed3 = myFish3.splice(2, 0, ["drum","guitar"]);
console.log(myFish3); // ['angel', 'clown', ["drum","guitar"], 'mandarin', 'sturgeon']
console.log(removed3); // []

const myFish4 = ["angel", "clown", "mandarin", "sturgeon"];
const removed4 = myFish4.splice(2, 1, "drum","guitar");
console.log(myFish4); // ['angel', 'clown', "drum","guitar", 'sturgeon']
console.log(removed4); // ['mandarin']

unshift

将一个或多个元素添加到数组的开头，并返回该数组的新长度
会改变原数组
浏览器支持：很好

const array1 = [1, 2, 3];
console.log(array1.unshift(4, 5)); // 5
console.log(array1); // [4,5,1,2,3]

let arr = [4,5,6];
arr.unshift(1,2,3);
console.log(arr); // [1, 2, 3, 4, 5, 6]

arr = [4,5,6]; // 重置数组
arr.unshift(1);
arr.unshift(2);
arr.unshift(3);
console.log(arr); // [3, 2, 1, 4, 5, 6]
arr.unshift([-4, -3]);
console.log(arr);// [[-4,-3],3,2,1,4,5,6]

读取数组元素

下标正向读取

const fruits = ['banana', 'apple', 'peach'];
console.log(fruits[1]) // apple
console.log(fruits.at(1)) // apple

下标反向读取

const fruits = ['banana', 'apple', 'peach'];
console.log(fruits[fruits.length - 2]) // apple
console.log(fruits.at(-2)) // apple

创建数组

Array构造器

传入参数的方式有两种

1. 传入一个参数，如果参数是数字，创建一个长度等于该数字的数组，如果不是数字，则生成包含该参数的数组
2. 传入多个参数，创建一个包含所有传入参数的新数组

console.log(new Array(10)) //(10) [empty × 10]
console.log(new Array(10,10)) // (2) [10,10]
console.log(new Array('w')) // ['w']

注意：

使用单个参数并且参数为数字创建数组时

创建的数组的长度范围为 0 到 2^32 - 1
并且该数组不包含任何实际的元素（并不是undefined）
虽然访问的时候会打印undefined，即使访问超出数组长度的元素打印的也是undefined，所以不能说明创建的数组值是undefined

const arr = new Array(10);
console.log(arr[0]) // undefined
console.log(arr[11]) // undefined

数组字面量

const fruits = ['Apple', 'Banana'];

注意：

使用下标给数组设置超出数组长度的值，也会出现数组中不包含任何元素的情况

const fruits = ['banana', 'apple', 'peach'];
fruits[5] = 'mango';
console.log(fruits) // (6) ['banana', 'apple', 'peach', empty × 2, 'mango']

Array.of()

创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型
Array.of() 和 Array 构造函数之间的区别在于处理整数参数
接收任意个参数，将按顺序成为返回数组中的元素
浏览器支持：不支持IE，谷歌45+

Array.of(1);         // [1]
Array.of(1, 2, 3);   // [1, 2, 3]
Array.of(undefined); // [undefined]

Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

判断是否是数组

Array.isArray(arr)
arr instanceof Array
arr.constructor === Array
Object.prototype.toString.call(arr) === '[object Array]'

const arr = {a:'1'}
console.log(Array.isArray(arr)); // false
console.log(arr instanceof Array); // false
console.log(arr.constructor === Array); // false
console.log(Object.prototype.toString.call(arr) === '[object Array]'); // false

const arr1 = [1];
console.log(Array.isArray(arr1)); // true
console.log(arr1 instanceof Array); // true
console.log(arr1.constructor === Array); // true
console.log(Object.prototype.toString.call(arr1) === '[object Array]'); // true

常用数组方法整理

遍历（执行次数等于数组长度的方法）

map

filter

forEach

every（查找）

reduce

reduceRight

查找（执行次数可能小于数组长度的方法）

find

findIndex

findLast

findLastIndex

includes

indexOf

lastIndexOf

some

其他处理数组方法

concat

copyWithin

at

fill

flat

from

join

pop

push

reverse

shift

slice

sort

splice

unshift

读取数组元素

下标正向读取

下标反向读取

创建数组

Array构造器

注意：

数组字面量

注意：

Array.of()

判断是否是数组