温故而知新——数组常用方法方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它

数组的方法有很多，当初只是一味的学习记忆，却从未总结过，这里方法的特性进行总结，并且标注了一些注意事项

修改数组自身的方法

`push()`

向数组的末尾添加一个或更多元素并返回新的长度（可以和扩展运算符结合使用）

let arr = [1, 2, 3]
//添加一个元素
let len1 = arr.push(4)
console.log(arr, len1)//[1, 2, 3, 4] 4
//添加多个元素 
let len2 = arr.push(5, 6, 7)
console.log(arr, len2)//[1, 2, 3, 4, 5, 6, 7] 7
let arr2 = ['a', 'b', 'c']
//和扩展运算符结合使用，可以用来合并数组，将第二个数组融入第一个
arr.push(...arr2)
console.log(arr)//[1, 2, 3, 4, 5, 6, 7, "a", "b", "c"]

`pop()`

删除数组的最后一个元素并返回删除的元素(当数组为空时返回undefined)

let arr = [1, 2, 3];
let el = arr.pop();
console.log(arr, el);//[1, 2] 3

`unshift()`

向数组的开头添加一个或更多元素并返回新的长度,同理可以和扩展运算符结合使用

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

`shift()`

删除数组的第一个元素并返回删除的元素

let arr = [1, 2, 3];
//此时要注意每个下标对应的元素发生了改变
let el = arr.shift();
console.log(arr, el);//[2, 3] 1

`reverse()`

颠倒数组元素顺序,将数组中元素的位置颠倒并返回该数组

let list = [10000, 11000, 18000, 21000, 15000, 16500]
list.reverse()
console.log(list)// [16500, 15000, 21000, 18000, 11000, 10000]

`sort()`

方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的,sort()方法接收一个函数function(a,b)作为参数，此时数组会按照调用该函数的返回值排序,

compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
compareFunction(a, b)等于 0 ， a 和 b 的相对位置不变
compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。

let arr = [1, 30, 4, 21, 100000];
arr.sort();
console.log(arr);// [1, 100000, 21, 30, 4]
// 传入函数作为参数（升序排列）
arr.sort((a, b) => {
    return a - b;
})
console.log(arr);//[1, 4, 21, 30, 100000]

`splice()`

splice(index,len,item)
splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值
index:数组开始下标
len: 替换/删除的长度
item:替换的值(可以是多个)，删除操作的话 item为空
返回值：由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

替换  ----item为替换的值 
let arr = ['a', 'b', 'c', 'd'];
let retArr = arr.splice(1, 2, 'ttt');
//替换掉的也算被删除
console.log(arr, retArr);//['a','ttt','d']  ["b", "c"]

删除 ----  item不设置
let arr = ['a', 'b', 'c', 'd'];
let retArr = arr.splice(1, 2);
console.log(arr, retArr);//["a", "d"] ["b", "c"]

添加----  len设置为0,item为添加的值
let arr = ['a', 'b', 'c', 'd'];
let retArr = arr.splice(1, 0, 'ttt');
console.log(arr, retArr);//["a", "ttt", "b", "c", "d"] []

数组中的迭代方法

`filter()`

检测数组元素，并返回一个数组,包含所有符合条件的元素
callback参数：value，index，array，this
value:当前正在处理的元素
index:当前正在处理的元素的下标（可选）
array:数组本身（可选）
this:执行回调时用于this的值（可选）

let list = [28, 29, 35, 43, 29, 26, 35, 22, 41, 39];
let arr = list.filter((val) => val >= 35);
console.log(arr);//[35, 43, 35, 41, 39]

`forEach()`

遍历数组无返回值
callback参数：同上

let list = [10000, 11000, 18000, 21000, 15000, 16500];
list.forEach((item, index) => {
    console.log(item);//10000, 11000, 18000, 21000, 15000, 16500
});

`map()`;

和forEach();一样区别在于map方法会返回一个数组，新数组的元素是原数组里的元素调用回调函数后返回的结果

let list = [10000, 11000, 18000, 21000, 15000, 16500];
let arr = list.map((item, index) => item * 2);
console.log(arr);//[20000, 22000, 36000, 42000, 30000, 33000]

`every()`;

检测数组中的所有元素是否都符合指定条件，返回一个布尔值
callback参数：同上
注：如果有一个元素不满足条件，则表达式返回false, 剩余的元素不会再执行检测如果全满足条件的元素，或者数组为空，则返回true

let ages = [3, 10, 18, 20];
let retBool = ages.every((age) => age >= 18)
console.log(retBool);//false

some(); 检测数组中的元素是否满足指定条件，返回一个布尔值
callback参数：同上
注：如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测如果没有满足条件的元素，或者数组为空，则返回false

let ages = [3, 10, 18, 20];
let retBool = ages.some((age) => age >= 18)
console.log(retBool);//true

`find()`;

返回第一个符合条件的数组成员,否则返回undefined
callback参数：同上

let arr = [1, 5, 10, 15];
let retVal = arr.find((value) => value > 9);
console.log(retVal);//10

`findIndex()`

方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置
当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。如果没有符合条件的元素返回 -1

let ages = [3, 10, 18, 20];
let retval = ages.findIndex( val => val > 3)
console.log(retval);

`reduce(function(total,currentValue,index,arr),initialValue)`

callback参数：total，currentValue，currentIndex，arr
total: 初始值, 或者计算结束后的返回值
currentValue：当前元素
currentIndex：当前元素的索引（可选）
arr:当前元素所属的数组对象（可选）
initialValue：传递给函数的初始值（可选）

let numbers = [15.5, 2.3, 1.1, 4.7];
//数组求和
function getSum(total, num) {
    return total + num;
}
numbers.reduce(getSum, 0);//23.6

在使用迭代方法时应注意数组中的元素是对象的情况,这里我们以map为例

const arr = [
    { name: 'Tom', age: 16 },
    { name: 'Aaron', age: 18 },
    { name: 'Denny', age: 20 }
]
const result = arr.map(item => {
    item.age = item.age + 2; 
    return item
});
console.log('arr', arr);// [ { name: 'Tom', age: 16 },{ name: 'Aaron', age: 18 },{ name: 'Denny', age: 20 }]
console.log('result', result);// [ { name: 'Tom', age: 16 },{ name: 'Aaron', age: 18 },{ name: 'Denny', age: 20 }]
//所以我们以前说的“map()不会改变原始数组”这句话并不严谨。
//而应该是“当数组中元素是值类型，map不会改变原数组；当是引用类型，则可以改变原数组”

数组的存取方法

`concat()`;

合并两个或多个数组，并返回一个新数组（建议使用扩展运算符代替）

let a = [1, 2];
let b = [4, 5];
let c = a.concat(b);
let d = a.concat(b, c)
console.log(c, d)//[1, 2, 4, 5]   [1, 2, 4, 5, 1, 2, 4, 5]
 //扩展运算符实现
let e = [...a,...b]
console.log(e)//[1, 2, 4, 5]

`join()`

在数组元素之间插入字符串，返回一个新的字符串
注：如果数组只有一个成员，那么将直接返回该成员

let arr = [1, 2, 3];
let arr2 = [5];
let str1 = arr.join(",");
console.log(str1);//1,2,3
let str2 = arr2.join(",");
console.log(str2);//5

`slice(start,end)`

截掉取数组的的一部分，并返回一个新数组
start 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推
end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是也可为负数

let list = [10000, 11000, 18000, 21000, 15000, 16500];
let retArr = list.slice(-5, 4)
console.log(retArr)// [11000, 18000, 21000]

`indexOf()`

返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

let namelist = ["刘庆蒙", "李玉昭"];
let indx = namelist.indexOf("刘庆蒙");
console.log(indx);//0

indexOf() 方法对大小写敏感！

其他方法

`Array.from()`

将类数组转变为真正的数组

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};

console.log(arrayLike)//{ 0: "a", 1: "b", 2: "c", length: 3 }
let arr = Array.from(arrayLike);
console.log(arr)// ["a", "b", "c"]

`flat()`

数组扁平化处理

let arr = [1, 2, [3, [4, 5]]]
let arr2 = arr.flat()
console.log(arr2)//[1,2,3,[4,5]]
//传入一个整数参数，表示想要拉平的层数，默认为1。
let arr3 = arr.flat(2)
console.log(arr3)//[1,2,3,4,5]

`Array.of()`

将一组值，转换为数组

let arr1 = Array.of(3, 11, 8)
console.log(arr1)//[3, 11, 8]
let arr2 = Array.of(3)
console.log(arr2)//[3]
//链式调用
let len = Array.of(3).length
console.log(len)//1

总结

遍历数组时使用map和foreach
数组的添加删除使用splice、push、pop、shift、unshift
检查数组是否符合条件使用every、some
查找数据使用find、findIndex
筛选使用filter
需要用到累加器时使用reduce

温故而知新——数组常用方法

修改数组自身的方法

push()

pop()

unshift()

shift()

reverse()

sort()

splice()

数组中的迭代方法

filter()

forEach()

map();

every();

find();

findIndex()

reduce(function(total,currentValue,index,arr),initialValue)