/*arr=['a','b']
1、forEach--->只遍历，不返回任何内容
arr.forEach(function(item,index,arr){})
2、map------->会返回回调函数中return的内容组成数组，这个数组的长度与原数组相同，而且按原数组对应位置返回内容
arr.map((item,index)=>{item++}) 没有return就是undefined [undefined,undefined]
3、reduce----->ECMAScript 3接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
array.reduce(function(total, currentValue, currentIndex, arr){return total+currentValue}, initialValue)
4、filter--->ECMAScript 1.6 filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进行检测。
注意： filter() 不会改变原始数组。
ages.filter((item,index,arr)=>(item>18))
5、some---->判断数组中元素是否满足条件，有一个满足则返回true，否则false
注意： some() 不会对空数组进行检测。
注意： some() 不会改变原始数组。
ages.some((item,index,arr)=>(item>18))
6、every---->检测数组所有元素是否都符合指定条件,有一个不满足则返回false
注意： every() 不会对空数组进行检测。
注意： every() 不会改变原始数组。
ages.every((item,index,arr)=>(item>18))
【7】、find--->查找出第一个符合条件的数组成员，并返回该成员，如果没有找到就返回undefined
let res=arr.find(val,index,arr)=>{return val>30})
【8】、findIndex---->找到的是位置，找不到返回-1
let res=arr.findIndex(val,index,arr)=>{return val>30})
【9】、fill--->填充arr.fill(填充的东西，[开始位置],[结束位置])
arr.fill('默认值'，1，2)
【10】、includes--->数组是否包含某个元素，包含返回true，不包含返回false
arr.includes(searchElement)
arr.includes(searchElement, fromIndex)
var arr = ['a', 'b', 'c'];
arr.includes('c', 3); //false
arr.includes('c', 100); // false
【11】、copyWithin->浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
array.copyWithin(target[必需。复制到指定目标索引位置], start[可选。元素复制的起始位置], end[可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。])
var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"];
fruits.copyWithin(2, 0, 2);=========>['Banana','Orange','Banana','Orange','Kiwi','Papaya']
12、lastIndexOf---->返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。但返回的位置是从前开始数的
stringObject.lastIndexOf(searchvalue,[fromindex])
13、indexOf----->返回的是 valuesearch 第一次在数组（字符串）出现的位置（从左往右）
14、<会改变原数组>pop 删除最尾部元素，并且返回这个被删除的元素
15、<会改变原数组>push 向尾部添加元素
16、<会改变原数组>shift 删除数组的头部元素，并且返回这个被删除的元素
17、<会改变原数组>unshift 在数组头部添加一个或多个元素，并返回数组的新长度
18、<会改变原数组>splice---》添加删除插入替换（从第几个开始，删除几个，添加的元素）
19、slice-->截取 let arr=[1,23,46,78].slice(3) 复制第三项到尾部的所有元素
20、<会改变原数组>sort--->
arr.sort((a,b)=>a-b):从小到大排序
arr.sort((a,b)=>b-a):从大到小排序
arr.sort((a,b)=>b.age-a.age):根据对象属性从大到小排序
arr.sort(()=>Math.random()-0.5):乱序排列
21、<会改变原数组>reverse
22、join
23、concat--->在原数组尾部连接新的元素
arr.concat(1,23,4)
【24】keys
【25】values 返回一个数组迭代器对象，该迭代器会包含所有数组元素的值。
【26】entries
p614.values()
Object.values(p614)
let p614=[1,23,4,'blue']
for(let key of p614.values()){
console.log(key)
}
let {keys,values,entries} = Object;
let obj = {
a : 1,
b : 2,
c : 3,
}
for(let key of keys(obj)){
console.log(key);
}
27、flat---->扁平化数组会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回
let arr1=[1,23,4,'blue',[1,23,[3,4,'three']]]
let cf=arr1.flat(Infinity)//使用 Infinity 作为深度，展开任意深度的嵌套数组
console.log(cf)
28、flatMap--->flatMap() 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 和 深度值1的 flat 几乎相同，
但 flatMap 通常在合并成一种方法的效率稍微高一些。 这里我们拿map方法与flatMap方法做一个比较。
var arr1 = [1, 2, 3, 4];
arr1.map(x => [x * 2]);
// [[2], [4], [6], [8]]
arr1.flatMap(x => [x * 2]);
// [2, 4, 6, 8]
// only one level is flattened
arr1.flatMap(x => [[x * 2]]);
// [[2], [4], [6], [8]]
29、reduceRight--->reduceRight() 方法的功能和 reduce() 功能是一样的，不同的是 reduceRight() 从数组的末尾向前将数组中的数组项做累加。
注意: reduce() 对于空数组是不会执行回调函数的。
30、toString---->返回一个由所有数组元素组合而成的字符串
31、toLocaleString
32、Array.isArray() 用于确定传递的值是否是一个 Array。
33、Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。
*/
// --------------------数组遍历（for循环）
// const arr = ['a', 'b'];
// let newArr=arr.map((item,index)=>(item+1))
// let pink=new Array('let')
// let reuslt=arr.find((item,index,arr)=>{
// return item==='cc'
// })
// let arr1=[1,23,4,'blue',[1,23,[3,4,'three']]]
// let cf=arr1.flat(Infinity)
// console.log(cf)
let ko=Array.from([1,,23])
console.log(ko)
var arr = [1, 2, 3, 4];
arr.flatMap(x => [x, x * 2]);
// is equivalent to
let popo=arr.reduce((acc, x) => acc.concat([x, x * 2]), []);
// [1, 2, 2, 4, 3, 6, 4, 8]
let green=arr.splice(3,1,'replace')
arr.sort((a,b)=>b-a)
console.log(arr,green)
// ES5 中得到 索引号/key值const arr = { a: 11, b: 12 };
for (const i in arr) {
// console.log(i, 'split');
}
/* ES6 还提供三个新的方法——entries()，keys()和values()——用于遍历数组。
它们都返回一个遍历器对象，可以用for...of循环进行遍历，
唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。 */
/*
for (const index of arr.keys()) {
console.log(index);
}
// 0
// 1
for (const elem of arr.values()) {
console.log(elem);
}
// 或者
for (const i of arr) {
console.log(i);
}
// 'a'
// 'b'
// 同时遍历值和索引号
for (const [index, elem] of arr.entries()) {
console.log(index, elem);
}
// -------------------------遍历对象 for...in
const o = { a: '1', b: 2 };
for (const k in o) {
console.log(o[k]);
}
// 变量 key
for (const k of Object.keys(o)) {
console.log(k);
}
// 变量 value
for (const val of Object.values(o)) {
console.log(val);
}
// 变量 key 和 value
for (const [k, v] of Object.entries(o)) {
console.log(k, v);
}
*/
