数组常用的方法

 // 1.0 Array.from() 方法从一个类似数组或可迭代的对象中创建一个新的数组实例。
    const bar = ["a", "b", "c"];
    Array.from(bar);
    console.log(bar);
    console.log(Array.from('foo'));

    // 2.0 concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
    let arr1 = ["a", "b", "c"];
    let arr2 = ["d", "e", "f"];
    let arr3 = arr1.concat(arr2);
    console.log(arr3);// [ "a", "b", "c", "d", "e", "f" ]
    console.log(arr1);// ["a", "b", "c"]
    console.log(arr2);// ["d", "e", "f"]


    // every() 方法测试数组的所有元素是否都通过了指定函数的测试。
    function isBigEnough(element, index, array) {
      return (element >= 10);
    }
    var passed = [12, 5, 8, 130, 44].every(isBigEnough);// passed is false
    console.log("1",passed);
    passed = [12, 54, 18, 130, 44].every(isBigEnough); // passed is true
    console.log("2",passed);


    // filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
    function isBigEnough(value) {
      return value >= 10;
    }
    var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
    console.log('filtered',filtered);//[12,130,44]

    // map() 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
    let numbers = [1, 5, 10, 15];
    let doubles = numbers.map((x) => {
       return x * 2;
    });
    console.log("doubles",doubles);


    var kvArray = [{key: 1, value: 10},
               {key: 2, value: 20},
               {key: 3, value: 30}];
    var reformattedArray=[];
    reformattedArray = kvArray.map(obj=>{
       var rObj = {};
       rObj[obj.key] = obj.value;
       return rObj;
    });
    console.log('reformattedArray',reformattedArray);


    // some() 方法测试数组中的某些元素是否通过由提供的函数实现的测试。
    const isBiggerThan10 = (element, index, array) => {
      return element > 10;
    }
    [2, 5, 8, 1, 4].some(isBiggerThan10);  // false
    [12, 5, 8, 1, 4].some(isBiggerThan10); // true

    // find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
    function isBigEnough(element) {
      return element >= 15;
    }
    var index=[12, 5, 8, 130, 44].find(isBigEnough); // 130
    console.log('index',index);

    // findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
    function isBigEnough(element) {
      return element >= 15;
    }
    var index1=[12, 5, 8, 130, 44].findIndex(isBigEnough); // 3
    console.log("index1",index1);


    // forEach() 方法对数组的每个元素执行一次提供的函数。
    let a = ['a', 'b', 'c'];
    a.forEach(function(element,index,array) {//currentValue(当前值),index(索引),array
        console.log(element);
        console.log(index);
        console.log(array);
    });

    // includes() 方法用来判断一个数组是否包含一个指定的值，如果是，酌情返回 true或 false。
    let s = [1,2,3];
    console.log(s.includes(2)); // true
    console.log(s.includes(4)); //false

    // indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
    let f = [2, 9, 7, 8, 9];
    f.indexOf(2); // 0
    f.indexOf(6); // -1
    f.indexOf(7); // 2
    f.indexOf(8); // 3
    f.indexOf(9); // 1

    // lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

    // join() 方法将数组（或一个类数组对象）的所有元素连接到一个字符串中。
    // keys() 方法返回一个新的Array迭代器，它包含数组中每个索引的键。
    var arr = ["a", , "c"];
    var denseKeys = [...arr.keys()];
    var dd=arr.keys();
    console.log(denseKeys);
    console.log(dd);


    // pop()方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。
    // push() 方法将一个或多个元素添加到数组的末尾，并返回数组的新长度。
    // shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
    // unshift() 方法将一个或多个元素添加到数组的开头，并返回新数组的长度。
    let b = [1, 2, 3];
    b.length; // 3
    b.pop(); // 3
    console.log(b);

    // reduce() 方法对累加器和数组中的每个元素 (从左到右)应用一个函数，将其减少为单个值。
    var total = [0, 1, 2, 3].reduce(function(sum, value) {
      return sum + value;
    }, 0);
    console.log(total);

    // reverse() 方法将数组中元素的位置颠倒。
    // slice()   方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。原始数组不会被修改。
    var berfore=['a','b','c','d'];
    var sliced=berfore.slice(1,3);
    console.log('berfore',berfore);
    console.log('sliced',sliced);

    // sort() 方法在适当的位置对数组的元素进行排序，并返回数组。 sort 排序不一定是稳定的。默认排序顺序是根据字符串Unicode码点。

    // splice() 方法通过删除现有元素和/或添加新元素来更改一个数组的内容。
    // toString() 返回一个字符串，表示指定的数组及其元素。

    // 3.0 copyWithin() 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小。
    // arr.copyWithin(目标索引, [源开始索引], [结束源索引])
    console.log(["alpha", "beta", "copy", "delta"].copyWithin(1, 2, 3));

    // 4.0 entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。
    var arr = ["a", "b", "c"];
    var iterator = arr.entries();
    console.log(iterator);
    console.log(iterator.next().value);