ES6数组

array.from()：

array.from()函数的用法: 将两种对象转换成数组。
1.部署了Iterator接口的对象，比如：Set，Map，Array。
2.类数组对象，什么叫类数组对象，就是一个对象必须有length属性，没有length，转出来的就是空数组。
1、将类数组对象转换为真正数组：
let arrayLike = {
    0: 'tome', 
    1: '20',
    2: '男',
    4: ['jane','john','Mary'],
    'length': 5
}
let arr = Array.from(arrayLike)
console.log(arr) // ['tome','20','男',['jane','john','Mary']]
如果将上面代码中length属性去掉呢？实践证明，答案会是一个长度为0的空数组。
将代码再改一下，就是具有length属性，但是对象的属性名不再是数字类型的，而是其他字符串型的，代码如下：
let arrayLike = {
    'name': 'tome', 
    'age': '20',
    'sex': '男',
    'friends': ['jane','john','Mary'],
    length: 4
}
let arr = Array.from(arrayLike)
console.log(arr)  // [ undefined, undefined, undefined, undefined ]
发现结果是长度为4，元素均为undefined的数组
由此可见，要将一个类数组对象转换为一个真正的数组，必须具备以下条件：
1、该类数组对象必须具有length属性，用于指定数组的长度。如果没有length属性，那么转换后的数组是一个空数组。
2、该类数组对象的属性名必须为数值型或字符串型的数字
属性名代表了数组的索引号，如果没有这个索引号，转出来的数组中对应的元素就为空。
ps: 该类数组对象的属性名可以加引号，也可以不加引号;
2、将Set结构的数据转换为真正的数组：　
let arr = [12,45,97,9797,564,134,45642]
let set = new Set(arr)
console.log(Array.from(set))  // [ 12, 45, 97, 9797, 564, 134, 45642 ]
Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。如下：
let arr = [12,45,97,9797,564,134,45642]
let set = new Set(arr)
console.log(Array.from(set, item => item + 1)) // [ 13, 46, 98, 9798, 565, 135, 45643 ]
转换map
将Map对象的键值对转换成一个一维数组。
实际上转换出来的数组元素的序列是key1,value1,key2,value2,key3,value3.....
const map1 = new Map();
map1.set('k1', 1);
map1.set('k2', 2);
map1.set('k3', 3);
console.log('%s', Array.from(map1))    //k1,1,k2,2,k3,3
3、将字符串转换为数组：
let  str = 'hello world!';
console.log(Array.from(str)) // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d", "!"]
Array.from可以接受三个参数
Array.from(arrayLike[, mapFn[, thisArg]])
arrayLike：被转换的的对象。
mapFn：map函数。
thisArg：map函数中this指向的对象。
第二个参数，map函数
用来对转换中，每一个元素进行加工，并将加工后的结果作为结果数组的元素值。
第三个参数，map函数中this指向的对象
我们可以将被处理的数据和处理对象分离，将各种不同的处理数据的方法封装到不同的的对象中去，处理方法采用相同的名字。
在调用Array.from对数据对象进行转换时，可以将不同的处理对象按实际情况进行注入，以得到不同的结果，适合解耦。
这种做法是模板设计模式的应用，有点类似于依赖注入。　

array.every()：

every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
every() 方法使用指定函数检测数组中的所有元素：
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。
注意： every() 不会对空数组进行检测。
注意： every() 不会改变原始数组。
语法：array.every(function(currentValue,index,arr), thisValue)
检测数组 ages 的所有元素是否都大于等于输入框中指定的数字:
<p>最小年龄: <input type="number" id="ageToCheck" value="18"></p>
<button onclick="myFunction()">点我</button>
<p>是否所有年龄都符号条件? <span id="demo"></span></p>
<script>
var ages = [32, 33, 12, 40];
function checkAdult(age) {
    return age >= document.getElementById("ageToCheck").value;
}
function myFunction() {
    document.getElementById("demo").innerHTML = ages.every(checkAdult);
}
</script>

array.fill();

fill()函数，使用制定的元素填充数组。
该函数有三个参数。
arr.fill(value, start, end)
value：填充值。
start：填充起始位置，可以省略。
end：填充结束位置，可以省略，实际结束位置是end-1。
const arr3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
arr3.fill(7, 2, 5)
console.log('%s', arr3)   //1,2,7,7,7,6,7,8,9,10,11

array.filter();

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
filter函数可以看成是一个过滤函数，返回符合条件的元素的数组
注意： filter() 不会对空数组进行检测。
注意： filter() 不会改变原始数组。
语法：array.filter(function(currentValue,index,arr), thisValue)
let arr1 = [1,2,3];
let arr2 = arr1.filter((value,key,arr) => {
    console.log(value)    // 1，2，3
    console.log(key)      // 0，1，2
    console.log(arr)      // [1,2,3]
    return value >= 3 ? false : true;     
})
console.log(arr1); // [ 1, 2, 3 ]
console.log(arr2); // [ 1, 2 ]
filter() 去掉空字符串、undefined、null
let arr = ['','1','2',undefined,'3.jpg',undefined]
let newArr = arr.filter(item => item)
console.log(newArr)
filter() 数组去重
let arr = [1, 2, 2, 3, 4, 5, 5, 6];
let newArr = arr.filter((x, index,self)=>self.indexOf(x)===index) 
console.log(newArr)
去重推荐使用 set()方法
let arr = [1, 2, 2, 3, 4, 5, 5, 6];
let newArr =Array.from(new Set(arr)) 
console.log(newArr)
filter() 筛选数组对象
let arr = [
        {a:'苹果',b:'面包',c:'吃'},
        {a:'香蕉',b:'面包',c:'不吃'},
        {a:'香蕉',b:'苹果',c:'吃'},
        {a:'苹果',b:'香蕉',c:'不吃'},
      ]
console.log(arr.filter(item => item.a=== '苹果' ))//[{a:'苹果',b:'面包',c:'吃'},{a:'苹果',b:'香蕉',c:'不吃'}]

array.find()和array.findIndex()：

find()函数用来查找目标元素，找到就返回该元素，找不到返回undefined。
findIndex()函数也是查找目标元素，找到就返回元素的位置，找不到就返回-1。
他们的都是一个查找回调函数。
查找函数有三个参数。
value：每一次迭代查找的数组元素。
index：每一次迭代查找的数组元素索引。
arr：被查找的数组。
查找元素，返回找到的值，找不到返回undefined。
const arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
var ret1 = arr1.find((value, index, arr) => {
 return value > 4
})
var ret2 = arr1.find((value, index, arr) => {
 return value > 14
})
console.log('%s', ret1)             //5
console.log('%s', ret2)              //undefined
2.查找元素，返回找到的index，找不到返回-1。
var ret3 = arr1.findIndex((value, index, arr) => {
 return value > 4
})
var ret4 = arr1.findIndex((value, index, arr) => {
 return value > 14
})
console.log('%s', ret3)            //4
console.log('%s', ret4)          //-1

array.forEach();

语法：array.forEach(callback(currentValue, index, array){
    //do something
}, this)
array.forEach(callback[, thisArg])
参数：
callback  为数组中每个元素执行的函数，该函数接收三个参数：
currentValue(当前值)  数组中正在处理的当前元素。
index(索引)  数组中正在处理的当前元素的索引。
array   forEach()方法正在操作的数组。
thisArg可选   可选参数。当执行回调 函数时用作this的值(参考对象)。
返回值   undefined.、
forEach 方法按升序为数组中含有效值的每一项执行一次callback 函数，那些已删除（使用delete方法等情况）或者未初始化的项将被跳过（但不包括那些值为 undefined 的项）（如在稀疏数组上）。
callback 函数会被依次传入三个参数：
数组当前项的值
数组当前项的索引
数组对象本身
如果给forEach传递了thisArg参数，当调用时，它将被传给callback 函数，作为它的this值。否则，将会传入 undefined 作为它的this值。callback函数最终可观察到this值，这取决于 函数观察到this的常用规则。

array.includes();

indexOf用来查找某个元素的位置，如果不存在就返回-1，但是这个函数在判断数组是否包含某个元素时有两个小不足，第一个是它会返回-1和元素的位置来表示是否包含，在定位方面是没问题，就是不够语义化。另一个问题是不能判断是否有NaN的元素。
const arr1 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', NaN]
console.log('%s', arr1.indexOf(NaN))            //-1
Array.includes()函数判断是否包含某一元素，除了不能定位外，解决了indexOf的上述的两个问题。它直接返回true或者false表示是否包含元素，对NaN一样能有有效。
const arr1 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', NaN]
console.log('%s', arr1.includes('c'))             //true
console.log('%s', arr1.includes('z'))            //false
console.log('%s', arr1.includes(NaN))            //true
includes()函数的第二个参数表示判断的起始位置。可以是负数。

array.keys();

entries()，keys()和values() —— 用于遍历数组。它们都返回一个遍历器对象，可以用for...of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。
let arr=[1,2,234,'sdf',-2];
for(let a of arr.keys()){
    console.log(a)
}//结果：0,1,2,3,4  遍历了数组arr的索引

array.map();

映射（一一对应）。[].map();基本用法跟forEach方法类似：
array.map(callback,[ thisObject]);
但是callback需要有return值（如果没有，就像会返回undefined）
var arr = [1,2,3,4];
arr.map((item,index,arr) => {
    return item*10 //新数组为10,20,30,40
})
//map遍历数组，返回一个新数组，不改变原数组的值。

array.reduce()和array.reduceRight():

参数：
prev：它是上一次调用回调时返回的结果，每次调用的结果都会给prev
cur：当前的元素
index：当前的索引
arr：循环的数组
返回值：
函数累计处理的结果
求阶乘
var a = [1,2,3,4,5,6,7,8,9,10]
var str = a.reduce(function(prev,cur,index,arr){
    return prev * cur ;
})
str //3628800
 将二维数组转换成一维
var a= [[0,1],[2,3],[4,5],[6,7],[8,9]];
var str = a.reduce(function(prev,cur){
    return prev.concat(cur)
}) 
str    //(10) [0,1, 2, 3, 4, 5, 6, 7, 8, 9]
 数组去重
var arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
var str = arr.sort().reduce((prev, cur)=>{
    if(prev.length===0 || prev[prev.length-1]!==cur){
        prev.push(cur);
    }
    return prev;
}, []);
str // (5) [1, 2, 3, 4, 5]
var arr = [1,2,3,4];
arr.reduce((result,item,index,arr) => {
    console.log(result) // 1  3  6  result为上次一计算的结果
    console.log(item)  // 2  3  4
    console.log(index) // 1  2  3
    return result+item //最终结果为10
})
//reduce 让数组的前后两项进行某种计算。然后返回其值，并继续计算。不改变原数组，返回计算的最终结果，从数组的第二项开始遍历。

array.some();

some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。
some() 方法会依次执行数组的每个元素：
如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
如果没有满足条件的元素，则返回false。
注意： some() 不会对空数组进行检测。
注意： some() 不会改变原始数组。
语法：array.some(function(currentValue,index,arr),thisValue)
function isBigEnough(element, index, array) {
  return (element >= 10);
}
passed = [12, 5, 8, 1, 4].some(isBigEnough);
// passed is true

array.sort()

sort()方法主要用于对数组的元素进行排序。其中，sort()方法有一个可选参数。但是，此参数必须是函数。 数组在调用sort()方法时，如果没有传参将按字母顺序（字符编码顺序）对数组中的元素进行排序，如果想按照其他标准进行排序，就需要进行传一个参数且为函数，该函数要比较两个值，并且会返回一个用于说明这两个值的相对顺序的数字。
var arr = [22,12,3,43,56,47,4];
arr.sort();
console.log(arr); // [12, 22, 3, 4, 43, 47, 56]
arr.sort(function (m, n) {
 if (m < n) return -1
 else if (m > n) return 1
 else return 0
});
console.log(arr); // [3, 4, 12, 22, 43, 47, 56]
var arr = [{'name': '张三', age: 26},{'name': '李四', age: 12},{'name': '王五', age: 37},{'name': '赵六', age: 4}];
var objectArraySort = function (keyName) {
 return function (objectN, objectM) {
  var valueN = objectN[keyName]
  var valueM = objectM[keyName]
  if (valueN < valueM) return 1
  else if (valueN > valueM) return -1
  else return 0
 }
}
arr.sort(objectArraySort('age'))
console.log(arr) // [{'name': '王五', age: 37},{'name': '张三', age: 26},{'name': '李四', age: 12},{'name': '赵六', age: 4}]

array.splice()

splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
注释：该方法会改变原始数组。
arrayObject.splice(index,howmany,item1,.....,itemX)
index    必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany    必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, ..., itemX    可选。向数组添加的新项目。
如，向数组的起始位置插入一个新的元素  -1
var  arr = [1,2,3,4,5,6]
arr.splice(0,0, -1)  //返回[]，第二个参数为0，即不删除任何元素
console.log(arr)                    //> [-1, 1, 2, 3, 4, 5, 6]

slice()
可从已有的数组中返回选定的元素。
语法：arrayObject.slice(start,end)
start 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
用JSON parse/ strinigfy 进行深度复制
可以使用 JSON.parse(JSON.stringify(arr)) 对对象或数组进行快速深度复制，此种方法无法复制 function 等无法序列化的对象，比如：
var o = [1, 2]
var arr = [ 3, 4, o ]
var clone = JSON.parse(JSON.stringify(arr))
console.log(clone)                         //> [3, 4, Array[2]]
clone[2].push(3)
console.log(o)
> [1, 2]  //o元素没有变化

普通数组去重：set（）

似于数组，但它的一大特性就是所有元素都是唯一的，没有重复。
我们可以利用这一唯一特性进行数组的去重工作。
单一数组的去重。
let set6 = new Set([1, 2, 2, 3, 4, 3, 5])
console.log('distinct 1:', set6)                       //distinct 1: Set { 1, 2, 3, 4, 5 }
多数组的合并去重
let arr1 = [1, 2, 3, 4]
let arr2 = [2, 3, 4, 5, 6]
let set7 = new Set([...arr1, ...arr2])
console.log('distinct 2:', set7)                        //distinct 2: Set { 1, 2, 3, 4, 5, 6 }

json数组去重；

需求描述：去除JSON数组中paymode字段相同的项，并将paymoney累加。
paylist:[{paymode:'1',payname:"现金"，paymoney:"20"},
{paymode:'2',payname:"支付宝"，paymoney:"50"},{paymode:'1',payname:"现金"，paymoney:"40"}]
function UniquePay(paylist){
  var payArr = [paylist[0]];
  for(var i = 1; i < paylist.length; i++){
    var payItem = paylist[i];
    var repeat = false;
    for (var j = 0; j < payArr.length; j++) {
     if (payItem.paymode == payArr[j].paymode) {
        payArr[j].paymoney = parseFloat(payArr[j].paymoney)+parseFloat(payItem.paymoney);
         repeat = true;
         break;
     }
   }
       if (!repeat) {
         payArr.push(payItem);
       }
  }
  return payArr;
}
通用的JSON数组去重
/*
 * JSON数组去重
 * @param: [array] json Array
 * @param: [string] 唯一的key名，根据此键名进行去重
 */
function uniqueArray(array, key){
  var result = [array[0]];
  for(var i = 1; i < array.length; i++){
    var item = array[i];
    var repeat = false;
    for (var j = 0; j < result.length; j++) {
      if (item[key] == result[j][key]) {
        repeat = true;
        break;
      }
    }
    if (!repeat) {
      result.push(item);
    }
  }
  return result;
}