Array

改变原数组

• pop() 删除数组的最后一个元素并返回删除的元素
• push() 向数组的末尾添加一个元素，并返回新的长度
• shift() 删除并返回数组的第一个元素
• unshift() 向数组的开头添加一个或多个元素，并返回新的长度
• reverse() 反转数组的元素排序
• sort() 对数组的元素进行排序
• splice() 用于插入 删除 和 替换数组元素

不会改变原数组的

• concat() 连接两个或多个数组，并返回结果
• every() 检测数组元素的每个元素是否都符合条件
• some() 检测数组元素中是否有元素符合指定条件
• filter() 检测数组元素，并返回符合条件所有元素的数组
• indexOf() 搜索数组中的元素，并返回它所在的位置
• join() 把数组的所有元素放入一个字符串
• toString() 把数组转换为字符串，并返回结果
• lastIndexOf() 返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索
• map() 通过指定函数处理数组的每个元素，并返回处理后的数组
• slice() 选取数组的的一部分，并返回一个新数组
• valueOf() 返回数组对象的原始值
• flat() 数组扁平化
• reduce()

flat()

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

数组降维（数组扁平化）

var arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]
 
var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
 
var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]
 
//使用 Infinity 作为深度，展开任意深度的嵌套数组
arr3.flat(Infinity); 
// [1, 2, 3, 4, 5, 6]

数组去重排序

let arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];
let newarr = Array.from(new Set(arr.toString().split(','))).sort((a,b)=>a-b)
//["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14"]

arr.toString()  //"1,2,2,3,4,5,5,6,7,8,9,11,12,12,13,14,10"
.split(',')    //["1", "2", "2", "3", "4", "5", "5", "6", "7", "8", "9", "11", "12", "12", "13", "14", "10"]s
.sort((a,b)=>a-b)      //["1", "2", "2", "3", "4", "5", "5", "6", "7", "8", "9", "10", "11", "12", "12", "13", "14"]

Array.from(new Set(arr.flat(Infinity))).sort((a,b)=>{ return a-b})

移除数组空项

var arr4 = [1, 2, , 4, 5];
arr4.flat(); // [1, 2, 4, 5]

some、every

• 相同：

  1. every和some都有三个参数，即item-当前项，index-当前项的索引值，array-数组本身；

• 不同：

  1. every相当于逻辑关系中的且，只有所有参数都满足条件时，才返回true，一旦有一个不满足，则逻辑中断，返回false
  2. some相当于逻辑关系中的或，只要有一个参数满足条件，就中断遍历，返回true，若遍历完所有参数，没有符合的项，返回false

some 检测数组中是否有满足条件的 返回结果是一个布尔值 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。 如果没有满足条件的元素，则返回false

every方法用于检测数组所有元素是否都符合指定条件 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。 如果所有元素都满足条件，则返回 true。

let arr = [ 1, 2, 3, 4, 5, 6 ]; 
console.log( arr.some( function( item, index, array ){ 
    console.log( 'item=' + item + ',index='+index+',array='+array ); 
    return item > 3; 
})); 

item=1,index=0,array=1,2,3,4,5,6
item=2,index=1,array=1,2,3,4,5,6
item=3,index=2,array=1,2,3,4,5,6
item=4,index=3,array=1,2,3,4,5,6
true

-------------------------------

let arr = [ 1, 2, 3, 4, 5, 6 ]; 
console.log( arr.every( function( item, index, array ){ 
    console.log( 'item=' + item + ',index='+index+',array='+array ); 
    return item > 3; 
}));

item=1,index=0,array=1,2,3,4,5,6
false

遍历数组

let array = [1,2,3,4];
array.forEach((item, index, array) => {
　　console.log(item);
});

let array2 = [1, 2, 3, 4];
let temp2 = array2.map((item, index, array) => {
　　return item * 10;
});
console.log(temp2);　　//  [10, 20, 30, 40];
console.log(array2);　　// [1, 2, 3, 4]

var array9 = [1,4,9,16];
const map9 = array9.map(x => x *2);
console.log(map9);


let array3 = [1, 2, 3, 4];
let temp3 = array3.filter((item, index, array) => {
　　return item >  3;
});
console.log(temp3);　　// [4]
console.log(array3);　　// [1, 2, 3, 4]


let array4 = [1, 2, 3, 4];
let temp4 = array.reduce((x, y) => {
	console.log("x,"+x);
	console.log("y,"+y);
	console.log("x+y,",Number(x)+Number(y));
	return x + y;
});
console.log(temp4);　　// 10
console.log(array4);　　// [1, 2, 3, 4]


let array5 = [1, 2, 3, 4];
let bo5 = array.every((item, index, array) => {
　　return item > 2;
});
console.log(bo5);　　　　// false;


let array6 = [1, 2, 3, 4];
let temp6 = array.some((item, index, array) => {
　　return item > 5;
});
console.log(temp6);　　// false

• 基础for循环：如for(int i=0;i<5;i++){}。缺点为书写比较麻烦

• for in ：缺点比较明显，它不仅遍历数组中的元素，还会遍历自定义的属性，甚至原型链上的属性都被访问到。此外，它遍历效率比较低

• for of：与 forEach 不同的是，它可以正确响应 break、continue 和 return语句。它不仅可以遍历数组，还可以遍历类数组对象和其他可迭代对象。并且它不会遍历自定义属性，这点可以区别于for in 注意：for of无法遍历对象。for of适用遍历数组对象/字符串/map/set等拥有迭代器对象（iterator）的集合。

reduce()

概念

• reduce() 方法对数组中的每个元素执行一个由您提供的reduce函数(升序执行)，将其结果汇总为单个返回值。
• reduce方法可做的事情特别多，就是循环遍历能做的，reduce都可以做，比如数组求和、数组求积、数组中元素出现的次数、数组去重等等。

arr.reduce(function(prev,cur,index,arr){
...
}, init);

prev 必需。累计器累计回调的返回值; 表示上一次调用回调时的返回值，或者初始值 init;
cur 必需。表示当前正在处理的数组元素；
index 可选。表示当前正在处理的数组元素的索引，若提供 init 值，则起始索引为- 0，否则起始索引为1；
arr 可选。表示原数组；
init 可选。表示初始值。

应用

数组求和求积

let arr = [1,2,3,4,5]
console.log(arr.reduce((a,b) => a + b)) // - 15
console.log(arr.reduce((a,b) => a * b))  // - 120

数组去重

var arr = [1, 3, 4, 5, 3, 2 ,2];
一    var newArr  = arr.reduce((pre. cur) => {
            if (!pre.includes(cur)){
                    return pre.concat(cur);
            } else {
                    return pre
            }
    }, []);

二    var newArr = [];
        for (var i = 0; i<arr.length; i++) {
                if (newArr.indexOf(arr[i]) == -1) {
                        newArr.push(arr[i]);
                };
        };

三    var newArr = new Set (arr);

console.log(newArr)

数组对象属性求和

var arr = [
	{name: 'Bob', age: 20},
	{name: 'Mike', age: 20},
	{name: 'Suger', age: 20}
];
var sum = arr.reduce((pre, cur) => {
	retuen cur.age + pre;
}, 0)
console.log(sum);

计算元素出现次数

var names = ['suger', 'Boo', 'Titf', 'suger'];
var nameNum = names.reduce((pre, cur) => {
	if (cur in pre) {
		pre[cur]++
	} else {
		pre[cur] = 1
	}
	return pre;
}, [])
console.log(nameNum);