ES6数组方法

    <script>
      // 1、检测是否为数组
      let a = [1, 2, 3];
      console.log(a);
      console.log(a instanceof Array); // true
      console.log(Array.isArray(a)); // true
      console.log("--------------------");

      // 2、数组元素的增加与删除

      // 2.1、push 将一个或多个元素添加到数组的末尾，并返回新数组的长度
      let b = [1, 2, 3];
      let c = b.push(4);
      console.log(b); // [1, 2, 3, 4]
      console.log(c); // 4
      console.log("--------------------");

      // 2.2、unshift 将一个或多个元素添加到数组的开头，并返回新数组的长度
      let e = [1, 2, 3];
      let d = e.unshift(45);
      console.log(e); // (4) [45, 1, 2, 3]
      console.log(d); // 4
      console.log("--------------------");

      // 2.3、pop 从数组中删除最后一个元素，并返回最后一个元素的值，原数组的最后一个元素被删除。数组为空时返回undefined。
      let f = [1, 2, 3];
      let h = [];
      let g = f.pop();
      let i = h.pop();
      console.log(f);
      console.log(g);
      console.log(h);
      console.log(i);
      console.log("--------------------");

      // 2.4、shift 删除数组的第一个元素，并返回第一个元素，原数组的第一个元素被删除。数组为空时返回undefined。
      let k = [1, 2, 3];
      let l = k.shift();
      console.log(k);
      console.log(l);
      console.log("--------------------");

      // 2.5 splice(start[, deleteCount, item1, item2, ...]) 从数组中添加/删除元素，返回值是由被删除的元素组成的一个新的数组，如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组

      /**
       *  start 指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从1计数）。
       *  deleteCount (可选)，从start位置开始要删除的元素个数。如果 deleteCount 是 0，则不移除元素。这种情况下，至少应添加一个新元素。如果deleteCount大于start之后的元素的总数，则从start后面的元素都将被删除（含第 start 位）。
       *  item1, item2, …(可选)，要添加进数组的元素,从start位置开始。如果不指定，则 splice() 将只删除数组元素。
       */

      let m = [1, 2, 3];
      let n = ["red", "yellow", "pink"];
      let r = n.splice(0, 2); // 截取前两位
      console.log(n); // ["pink"]
      console.log(r); // ["red", "yellow"]

      let o = m.splice(0, 0, 45, 56); // 在首位添加 45,56
      console.log(m); //  [45, 56, 1, 2, 3]
      console.log(o); // []
      console.log("--------------------");

      // 3、数组与字符串的相互转化
      // join(',')将数组中的元素通过separator连接成字符串，并返回该字符串，separator默认为","。不会改变原数据
      let p = [1, 2, 3];
      let s = p.join("**");
      console.log(p); // [1, 2, 3]
      console.log(s); //1**2**3
      console.log("--------------------");
      // 字符串转数组
      let str = "1 2 3";
      let str1 = "hellow";
      let t = str.split(" ");
      let u = str1.split("");
      console.log(t); //["1", "2", "3"]
      console.log(u); // (6) ["h", "e", "l", "l", "o", "w"]
      console.log("--------------------");

      //4、数组的截取和合并
      /**
       * 数组的截取 - array.slice(start, end) 方法
       * slice()通过索引位置，从数组中返回start下标开始，直到end下标结束（不包括）的新数组，该方法不会修改原数组，只是返回一个新的子数组。
       *
       *  start (必填)，设定新数组的起始位置（下标从0开始算起）；如果是负数，则表示从数组尾部开始算起（-1 指最后一个元素，-2 指倒数第二个元素，以此类推）。
       *  end (可选)，设定新数组的结束位置；如果不填写该参数，默认到数组结尾；如果是负数，则表示从数组尾部开始算起（-1 指最后一个元素，-2
       指倒数第二个元素，以此类推）。
       */

      let v = [1, 2, 3];
      let w = v.slice();
      console.log(w, v); // (3) [1, 2, 3] (3) [1, 2, 3]
      let x = v.slice(0);
      console.log(x, v); // (3) [1, 2, 3] (3) [1, 2, 3]
      let y = v.slice(-1);
      console.log(y, v); // [3] (3) [1, 2, 3]
      console.log("--------------------");

      // 5、数组的合并 - array.concat([item1[, item2[, . . . [,itemN]]]])方法
      let z = [1, 2, 3];
      let z1 = [1, 2, 3];
      let z2 = ["pink", 2, true];
      let A = z.concat(11, 22);
      let B = z1.concat(z2);
      console.log(A); // [1, 2, 3, 11, 22]
      console.log(B); // [1, 2, 3, "pink", 2, true]
      console.log("--------------------");

      // 6、数组元素的排序
      // sort()方法用于对数组的元素进行排序，并返回原数组。如果不带参数，按照字符串UniCode码的顺序进行排序。
      let C = [1, 5, 8, 4, 3];
      // 按照数值大小进行排序-升序
      C.sort((a, b) => {
        return a - b;
      });
      console.log(C); // [1, 3, 4, 5, 8]
      // 按照数值大小进行排序-降序
      let D = C.sort((a, b) => {
        return b - a;
      });
      console.log(D); //[8, 5, 4, 3, 1]
      console.log("--------------------");

      // reverse() 方法将数组中元素的位置颠倒，第一个数组元素成为最后一个数组元素，最后一个数组元素成为第一个。在原数组上操作，然后返回原数组。
      let E = [1, 5, 3];
      E.reverse();
      console.log(E); // [3, 5, 1]
      console.log("--------------------");

      // 7、元素在数组中的位置
      // indexOf lastIndexOf   这两个方法都返回查找的项在数组中的位置，或者在没找到的情况下返回-1。
      let F = [2, 9, 7, 8, 9].indexOf(9);
      let G = [2, 9, 7, 8, 9].indexOf(9, 2);
      console.log(F); // 1
      console.log(G); // 4
      let H = [2, 9, 7, 8, 9].lastIndexOf(9);
      let I = [2, 9, 7, 8, 9].lastIndexOf(9, 2);
      console.log(H); // 4
      console.log(I); // 1
      console.log("--------------------");

      // find(callback[, thisArg])方法，用于找出第一个符合条件的数组元素。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。找到以后就跳出查找，不在继续 如果没有符合条件的成员，则返回undefined。
      // findIndex(callback[, thisArg])返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。
      let J = [1, -1, 5];
      let K = J.find((item) => {
        return item < 0;
      });
      console.log(K); // -1
      console.log("--------------------");

      // includes(searchElement[, fromIndex = 0])方法返回一个布尔值，表示某个数组是否包含给定的值。searchElement：要查找的元素；fromIndex：开始查找的索引位置。
      console.log([1, 2, 3].includes(2)); // true
      console.log([1, 2, 3].includes(3, 3)); // false
      console.log([1, 2, 3].includes(3, -1)); // true
      console.log("--------------------");

      // 8、数组的遍历与迭代
      /**
       * array.filter(callback, thisArg)方法使用指定的函数测试所有元素,并创建一个包含所有通过测试的元素的新数组。
       *
       *  callback 用来测试数组的每个元素的函数，返回true表示保留该元素（通过测试），false则不保留。回调函数的参数 element:当前元素值；index：当前元素下标； array:当前数组
       *  thisArg 可选。执行 callback 时的用于 this 的值。
       */
      let L = [5, 6, 1, 2];
      let M = L.filter((item) => {
        return item > 2;
      });
      console.log(L); // (4) [5, 6, 1, 2]
      console.log(M); // (2) [5, 6]
      console.log("--------------------");

      /**
       * array.every(callback[, thisArg])方法检测数组中的每一个元素是否都通过了callback测试，全部通过返回true，否则返回false。
       *
       * 回调函数的参数：element:当前元素值；index：当前元素下标； array:当前数组
       */
      let N = [1, 2, 3, 4];
      let O = N.every((item) => {
        return item > 0;
      });
      let P = N.every((item) => {
        return item > 1;
      });
      console.log(O); // true
      console.log(P); // false

      /**
       * array.some(callback[, thisArg])判断数组中是否包含可以通过callback测试的元素，这里只要某一个元素通过测试，即返回true。callback定义同上。
       */
      let Q = N.some((item) => item > 2);
      console.log(Q); // true
      console.log("--------------------");

      /**
       * array.map(callback[, thisArg])方法返回一个由原数组中的每个元素调用callback函数后的返回值组成的新数组。
       */
      let R = [1, 2, 3, 4, 5];
      let S = R.map((item) => {
        return item * 2;
      });

      console.log(R); // [1, 2, 3, 4, 5]
      console.log(S); // [2, 4, 6, 8, 10]
      console.log("-------------");

      /**
       * array.forEach(callbak)为数组的每个元素执行对应的方法。
       * 注意：不会有返回值也不会影响原数组。
       */
      let T = R.forEach((item) => {
        return item * 2;
      });
      console.log(R); // [1, 2, 3, 4, 5]
      console.log(T); // undefined
      console.log("-------------");

      /**
       * array.reduce(callback[, initialValue])方法返回针对数组每项调用callback函数后产生的累积值。
       */

      const total = [0, 1, 2, 3].reduce((sum, value) => {
        return sum + value;
      }, 0);
      console.log(total); // total is 6

      const flattened = [
        [0, 1],
        [2, 3],
        [4, 5],
      ].reduce((a, b) => {
        return a.concat(b);
      }, []);
      console.log(flattened); // flattened is [0, 1, 2, 3, 4, 5]
    </script>