arrayLike想要转换成数组的伪数组对象或可迭代对象。
mapFn 可选如果指定了该参数，新数组中的每个元素会执行该回调函数。
thisArg 可选可选参数，执行回调函数 mapFn 时 this 对象。

// 没有length属性返回空数组let obj = {0:'a',1:'b',2:'c'}Array.from(obj); // []

// key不是数字或包含数字的字符串返回undefinedlet obj = {name:'九九欧',age:18,length:2}Array.from(obj); // [undefined, undefined]// key是数字但不是以0开始let obj = {2:'a',3:'b',4:'c',length:3}Array.from(obj); // [undefined, undefined, "a"]// 满足所有条件let obj = {0:'a',1:'b',2:'c',length:3}Array.from(obj); // ["a","b","c"]

从类数组对象(arguments)生成数组
let fn = function(){console.log(Array.from(arguments));}fn(1,2,3) // [1,2,3]从 String 生成数组Array.from('九九欧'); // ["九","九","欧"]从Set生成数组Array.from(new Set(["九","九","欧","欧"])); // ["九","欧"]从Map生成数组Array.from(new Map([[1, 'a'], [2, 'b']])); // [[1, 'a'], [2, 'b']]生成一个从0开始到指定数字的定长连续数组Array.from({length: 10}, (v, i) => i); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    Array.of(9);// [9]Array(9);// [empty × 9]

    Array.isArray([])           // trueArray.isArray({})           // falseArray.isArray('a')          // falseArray.isArray(1)            // falseArray.isArray(null)         // falseArray.isArray(undefined)    // false

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

    let ary = [1,2,3];ary.push(4);console.log(ary); // [1,2,3,4]

    let ary1 = [1,2,3];let ary2 = [4,5,6];let ary3 = Array.prototype.push.apply(ary1,ary2)console.log(ary1); // [1,2,3,4,5,6]console.log(ary3); // 6

    let ary = [1,2,3];let result = ary.shift();console.log(ary);     // [2,3]console.log(result);  // 1

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

compareFunction 可选用来指定按某种顺序进行排列的函数。如果省略，则元素按照转换为的字符串的各个字符的Unicode位点进行排序。
firstEl第一个用于比较的元素。
secondEl第二个用于比较的元素。

    let ary = [2,4,1,6,7,3,8,9,5];ary.sort(function(a,b){return a-b;})console.log(ary); // [1,2,3,4,5,6,7,8,9]

    let ary = [2,4,1,6,7,3,8,9,5];ary.sort(function(a,b){return a-a;})console.log(ary); // [2,4,1,6,7,3,8,9,5]

    let ary = [2,4,1,6,7,3,8,9,5];ary.sort(function(a,b){return b-a;})console.log(ary); // [9,8,7,6,5,4,3,2,1]

    let ary = [9,8,7,6,5,4,3,2,1,0]ary.sort();console.log(ary);  // [0,1,2,3,4,5,6,7,8,9]let ary = ["e","d","c","b","a"]  ary.sort();console.log(ary); // ["a","b","c","d","e"]

start指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；  如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
deleteCount （可选）整数，表示要移除的数组元素的个数。如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
item1, item2, ...（可选）要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。

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

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

    let ary = [1,2,3,3,5,6]ary.splice(-2);console.log(ary); // [1,2,3,4]

    let ary = [1,2,3,4,5]ary.reverse();console.log(ary); // [5,4,3,2,1]

target0 为基底的索引，复制序列到该位置。如果是负数，target 将从末尾开始计算。如果 target 大于等于 arr.length，将会不发生拷贝。如果 target 在 start 之后，复制  的序列将被修改以符合 arr.length。
start0 为基底的索引，开始复制元素的起始位置。如果是负数，start 将从末尾开始计算。如果 start 被忽略，copyWithin 将会从0开始复制。
end0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括end这个位置的元素。如果是负数，end将从末尾开始计算。如果end被忽略，copyWithin方法将会一直复制至数组结尾（默认为 arr.length）。

    [1, 2, 3, 4, 5].copyWithin(-2)         // [1, 2, 3, 1, 2][1, 2, 3, 4, 5].copyWithin(0, 3)       // [4, 5, 3, 4, 5][1, 2, 3, 4, 5].copyWithin(0, 3, 4)    // [4, 2, 3, 4, 5][1, 2, 3, 4, 5].copyWithin(-2, -3, -1) // [1, 2, 3, 3, 4]

value用来填充数组元素的值。
start （可选）起始索引，默认值为0。
end （可选）终止索引，默认值为 this.length（不包含终止索引）

    const ary = [1, 2, 3, 4];console.log(ary.fill(0, 2, 4)); // [1, 2, 0, 0]const ary = [1, 2, 3, 4];console.log(ary.fill(5, 1));    // [1, 5, 5, 5]const ary = [1, 2, 3, 4];console.log(ary.fill(6));       // [6, 6, 6, 6]

    const ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];console.log(ary.fill(0, 2)); // [1, 2, 0, 0, 0, 0, 0, 0, 0, 0]

valueN可选将数组和/或值连接成新数组。如果省略了valueN参数参数，则concat会返回一个它所调用的已存在的数组的浅拷贝。

    const ary1 = ['九','九'];const ary2 = ['欧'];let ary3 = ary1.concat(ary2);console.log(ary3); // ['九','九','欧']

    const ary1 = [1,2,3];const ary2 = [4,5,6];const ary3 = [7,8,9];let ary4 = ary1.concat(ary2,ary3);console.log(ary4); // [1,2,3,4,5,6,7,8,9]

    const ary1 = [1,2,3];const ary2 = [7,8,9];let ary3 = ary1.concat(4,5,6,ary2);console.log(ary3); // [1,2,3,4,5,6,7,8,9]}

    let ary = [1, 2, [3, [4,[5,[6,[7]]]]]];console.log(ary.flat());          // [1,2,3,[4,[5,[6,[7]]]]]console.log(ary.flat(2));         // [1,2,3,4,[5,[6,[7]]]]console.log(ary.flat(3));         // [1,2,3,4,5,[6,[7]]]
// 传入的参数为“Infinity”时，无论是几维数组都会变成1维数组console.log(ary.flat(Infinity));  // [1,2,3,4,5,6,7]

    let ary = [1, 2, , 4, 5];console.log(ary.flat()); // [1, 2, 4, 5]

callback：可以生成一个新数组中元素的函数，包含一下三个参数：
currentValue：当前正在数组中处理的元素
index(可选)：数组中正在处理的当前元素的索引
array：被调用map的数组
thisAry（可选）：执行callback函数值，this的值

    let ary = [1, 2, 3, 4];console.log(ary.flatMap(x => [x * 2]));    // [2, 4, 6, 8]console.log(ary.flatMap(x => [[x * 2]]));  // [[2], [4], [6], [8]]

    let names = ['九', '九', '欧'];// 步骤 1: maplet result = names.map((name, index) => [name, index]);    // [ ['九', 1], ['九', 2 ], ['欧'，3]]// 步骤 2: flatresult.flat();                                             // [ '九', 1, '九', 2 ,'欧',3]let names = ['九', '九', '欧'];let result = names.flatMap((name, index) => [name, index]); // [ '九', 1, '九', 2 ,'欧',3]

separator 可选指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用逗号（,）分隔。如果separator是空字符串("")，则所有元素    之间都没有任何字符。

    const ary = ['九', '九', '欧'];let ary = ary.join();       // "九,九,欧"let ary = ary.join(', ');   // "九, 九, 欧"let ary = ary.join(' + ');  // "九 + 九 + 欧"let ary = ary.join('');     // "九九欧"

begin （可选）提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取。slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。如果省略 begin，则 slice 从索引 0 开始。如果 begin 大于原数组的长度，则会返回空数组。
end （可选）提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引    为 1, 2, 3的元素）。如果该参数为负数，则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。如果 end 被省略，则 slice 会一直提取到原数组末尾。如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。

    const ary = [1,2,3,4,5];console.log(ary.slice(1,4));    // [2,3,4]console.log(ary.slice(0,100));  // [1,2,3,4,5]console.log(ary.slice(50,100)); // []

    function fn() {return Array.prototype.slice.call(arguments);}console.log(fn(1, 2, 3)); // [1, 2, 3]

    const array = ['九', '九', '欧'];let str = array.toString();console.log(str);        // 九,九,欧console.log(typeof str); // string

locales 可选带有BCP 47语言标记的字符串或字符串数组。
options 可选一个可配置属性的对象，对于数字 Number.prototype.toLocaleString()对于日期  Date.prototype.toLocaleString().

searchElement要查找的元素
fromIndex 可选开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找，以此类推。 注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被    查询。其默认值为0.

    const ary = [5,6,7,8,5];ary.indexOf(5);     // 0ary.indexOf(1);     // -1ary.indexOf(5, 2);  // 4ary.indexOf(5, -2); // 4

searchElement被查找的元素。
fromIndex 可选从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查  找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

    const ary = [5, 6, 7, 8, 5];ary.lastIndexOf(5);     // 4ary.lastIndexOf(1);     // -1ary.lastIndexOf(5, 2);  // 0ary.lastIndexOf(5, -2); // 0

valueToFind需要查找的元素值。
fromIndex 可选从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length  + fromIndex 的索引开始搜 （即使从末尾开始往前跳 fromIndex 的绝对值个索引，    然后往后搜寻）默认为 0。

    [1, 2, 3].includes(2);                 // true[1, 2, 3].includes(4);                 // false[1, 2, null].includes(null);           // true[1, 2, undefined].includes(undefined); // true[1, 2, NaN].includes(NaN);             // true

    var array = ['a', 'b', 'c'];console.log(array.toSource()); // ["a", "b", "c"]

callback为数组中每个元素执行的函数，该函数接收一至三个参数：
currentValue数组中正在处理的当前元素。
index 可选数组中正在处理的当前元素的索引。
array 可选forEach() 方法正在操作的数组。
thisArg 可选当执行回调函数 callback 时，用作 this 的值。

    const ary = [1,2,3,4,5];ary.forEach(item =>{if(item === 1){ary.push(6) // 遍历开始后数组新增的项不会被遍历}console.log(item);  })// 1// 2// 3// 4// 5

    const ary = [1,2,3,4,5];ary.forEach(item =>{if(item === 1){ary.pop()//在遍历到数组第一项时就把最后一项删除了，被删除的项不会被遍历}console.log(item);  })// 1// 2// 3// 4

    const ary = [1,2,3,4,5];ary.forEach(item =>{if(item === 3){ary.shift();//遍历到第2项时，以访问的元素被删除，则下一项跳过遍历}console.log(item);  })// 1// 2// 3// 5

    let ary = [1, 2, 3, 4, 5]let result = ary.forEach(item => {})console.log(result) // undefined

    const ary = [1, 2, 3, 4, 5];for (let i = 0; i < ary.length; i++) {if(ary[i] === 3){console.log("找到了");break;}console.log(ary[i]);}// 1// 2// 找到了ary.forEach(item => {if(item === 3){console.log("找到了");}console.log(item);})// 1// 2// 找到了// 3// 4// 5

    const ary = [1, 2, 3, 4, 5];ary.forEach(item => {if (item === 3) {console.log("找到了");return;}console.log(item);})// 1// 2// 找到了// 4// 5

    const ary = [1, 2, , 4];ary.forEach(item => {console.log(element);});// 1// 2// 4

    try {let ary = [1, 2, 3, 4, 5];ary.forEach(item => {if (item === 3) {throw new Error("EndIterative");}console.log(item);});} catch (e) {if (e.message != "EndIterative") {throw e;}}// 1// 2

    function flatten(arr) {const result = [];arr.forEach((item) => {if (Array.isArray(item))result.push(...flatten(item));elseresult.push(item);})return result;}

callback用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，   false 则不保留。它接受以下三个参数：
element数组中当前正在处理的元素。
index可选正在处理的元素在数组中的索引。
array可选调用了 filter 的数组本身。
thisArg可选执行 callback 时，用于 this 的值。

    var ary1 = [1, 2, 3, 4, 5];var ary2 = ary1.filter(value => value > 3);console.log(ary2); // [4,5]

    let users = [{ 'user': '九九', 'age': 18 },{ 'user': '八八', 'age': 19 },{ 'user': '七七', 'age': 20 },]let filtered = users.filter(n => n.age===18)console.log(filtered)   // [{'user': '九九'}]

    let ary = [1,1,2,2,3,3,4,4,5,5]let result = ary.filter((item, index, arr) => arr.indexOf(item) === index)// indexOf只返回找到的第一个值的下标console.log(result); // [1,2,3,4,5]

    let ary = ['A', '', 'B', null, undefined, 'C', '  ']let result = ary.filter((item, idx, arr) => item && item.trim())console.log(result) //["A", "B", "C"]

callback生成新数组元素的函数，使用三个参数：
currentValuecallback 数组中正在处理的当前元素。
index可选callback 数组中正在处理的当前元素的索引。
array可选map 方法调用的数组。
thisArg可选执行 callback 函数时值被用作this。

    let numbers = [1, 4, 9];let result = numbers.map(Math.sqrt);let numbers = [1, 4, 9];let result = numbers.map(num => num * 2);console.log(result); // [2,8,18]

callback用来测试每个元素的函数，它可以接收三个参数：
element用于测试的当前值。
index可选用于测试的当前值的索引。
array可选调用 every 的当前数组。
thisArg执行 callback 时使用的 this 值。

    let arr1 = [12, 5, 8, 130, 44];let arr2 = [12, 54, 18, 130, 44];arr1.every(x => x >= 10); // falsearr2.every(x => x >= 10); // true

callback用来测试每个元素的函数，接受三个参数：
element数组中正在处理的元素。
index 可选数组中正在处理的元素的索引值。
array可选some()被调用的数组。
thisArg可选执行 callback 时使用的 this 值。

    let arr1 = [1,2,3,4,5];            let arr2 = [1,2,3,4,5,12];         arr1.some(x => x > 10); // falsearr2.some(x => x > 10); // true

callback执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数，包含四个参数：
accumulator累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见  于下方）。
currentValue数组中正在处理的元素。
index 可选数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，  否则从索引1起始。
array可选调用reduce()的数组
initialValue可选作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将  使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。

    let arr = [1, 2, 3, 4]                               let sum = arr.reduce((acc, cur) => {                 return acc + cur;                               });                                                        console.log(sum); // 10

    let arr = [[0, 1],[2, 3],[4, 5]]    let flattened = arr.reduce(            (acc, cur) => acc.concat(cur)  );                                        console.log(flattened); // [0,1,2,3,4,5]

callback一个回调函数，用于操作数组中的每个元素，它可接受四个参数：
accumulator累加器：上一次调用回调函数时，回调函数返回的值。首次调用回调函数时，如果 initialValue 存在，累   加器即为 initialValue，否则须为数组中的最后一个元素（详见下方 initialValue 处相关说明）。
currentValue当前元素：当前被处理的元素。
index可选数组中当前被处理的元素的索引。
array可选调用 reduceRight() 的数组。
initialValue可选 首次调用 callback 函数时，累加器 accumulator 的值。如果未提供该初始值，则将使用数组中的最后一个元素，并跳过该元素。如果不给出初始值，则需保证数组不为空。否则，在空数组上调用 reduce 或 reduceRight 且未提供初始值（例如 [].reduce( (acc, cur, idx, arr) => {} ) ）的话，会导致类型错误 TypeError: reduce of empty array with no initial value。

    let arr = ["a", "b", "c"];let iterator = arr.entries();console.log(iterator.next().value); // [0, "a"]console.log(iterator.next().value); // [1, "b"]console.log(iterator.next().value); // [2, "c"]console.log(iterator.next().value); // undefined, 迭代器处于数组末尾时, 再迭代就会返回undefined

callback在数组每一项上执行的函数，接收 3 个参数：
element当前遍历到的元素。
index可选当前遍历到的索引。
array可选数组本身。
thisArg可选执行回调时用作this 的对象。

    let arr = [1, 3, 5, 7, 8, 9, 10];let result = arr.find(value => {     if (value % 2 == 0) {       return value             }                                 });                                       console.log(result); // 8

callback针对数组中的每个元素, 都会执行该回调函数, 执行时会自动传入下面三个参数:
element当前元素。
index当前元素的索引。
array调用findIndex的数组。
thisArg可选。执行callback时作为this对象的值。

    let arr = [1, 3, 5, 7, 8, 9, 10];let result = arr.findIndex(value => {if (value % 2 == 0) {       return value             }                                 });                                       console.log(result); // 4

    let arr = ["abc", "xyz"];                                               let iterator = arr.keys();                                               console.log(iterator.next()); // Object {value: 0, done: false}       console.log(iterator.next()); // Object {value: 1, done: false}       console.log(iterator.next()); // Object {value: undefined, done: true}

    let arr = ["abc", "def"];             let iterator = arr.values();           console.log(iterator.next().value); //abcconsole.log(iterator.next().value); //def