数组的方法

      join()
      push()和pop()
      shift() 和 unshift()
      sort()
      reverse()
      concat()
      slice()
      splice()
      indexOf()和 lastIndexOf() （ES5新增）
      forEach() （ES5新增）
      map() （ES5新增）
      filter() （ES5新增）
      every() （ES5新增）
      some() （ES5新增）
 

    // 1. join()
    //     就是把数组转换成字符串  给他顶一个连接字符  默认是(,) 格式:join("") 括号里写字符串("必加引号")。

   var arr = [1, 2, 3, 5]
    console.log(arr.join())
    console.log(arr.join("="))

    // 2. push() / pop()
    // push() : 可以接受一个或者多个参数内容添加到数组末尾，并返回修添加后的数组的长度，(原数组会发生改变)。
    //      格式：arr.push(" ")，括号里面写内容("字符串要加引号"),
    // pop()  : 从数组尾部删除一个元素，返回这个被删除的元素，减少数组的length。(原数组会发生改变)。
    //      格式：arr.pop( ),

    var arr = ["Lily", "lucy", "Tom"];
    var count = arr.push("Jack", "Sean");
    console.log(arr);
    console.log(count);

    var aee = ["Lily", "lucy", "Tom"];
    var ele = aee.pop();
    console.log(aee);
    console.log(ele);


    // 3. shift() / unshift()
    // shift() : 从数组头部删除一个元素，返回这个被删除的元素；如果数组为空则返回undefined,(原数组会发生改变)。
    //      格式：arr.shift(" ")，括号里面写内容  ("字符串要加引号"),
    // unshift() : 可以接受一个或者多个参数，内容添加到数组的头部，返回添加后的数组的长度，并返回数组的长度，(原数组会发生改变)。
    //      格式：arr.unshift(),

    var arr = ["Lily", "lucy", "Tom"];
    var count = arr.unshift("Jack", "Sean");
    console.log(arr);
    console.log(count);

    var aee = ["Lily", "lucy", "Tom"];
    var ele = aee.shift();
    console.log(aee);
    console.log(ele);

    // 4. sort()
    // sort() : 将数组里的项从小到大排序。
    // 格式：arr.sort(),
    // sort()方法比较的是字符串，没有按照数值的大小对数字进行排序，要实现这一点，就必须使用一个排序函数。(原数组不会发生改变)

    var add = ["a", "d", "c", "b"];
    console.log(add.sort());

    var ass = [6, 5, 4, 3, 2, 1]
    console.log(ass.sort())

    function sortNumber(a, b) {
        // return a - b
        return b - a

    }

    console.log(ass.sort(sortNumber));

    // 5. reverse()
    // reverse() : 反转数组项的顺序，不接受参数。 (原数组不被修改)
    // 格式：arr.reverse( )
    var aff = [99, 88, 77, 66]
    console.log(aff.reverse())

    // 6. concat()
    // concat() : 将参数添加到原数组中。这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。
    // 在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。
    // (将参数放入原数组后返回，原数组本身不变，如果参数是数组，将值提出来。)
    // 格式：arr.concat()，括号里面写内容  ("字符串要加引号"), (原数组会发生改变)

    var agg = [1, 2, 3, 4, 5]
    var ahh = agg.concat([11, 22])
    console.log(agg);
    console.log(ahh);

    // 7. slice()
    // slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。(原数组会发生改变)
    // slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下，
    // slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。
    //    格式：arr.slice(1,3)

    var ajj = [1, 3, 5, 7, 9, 11];
    var ajj1 = ajj.slice(1);
    var ajj2 = ajj.slice(1, 4);
    console.log(ajj1);
    console.log(ajj2);

    // 8. splice()
    // splice(): 删除、插入和替换。 (原数组会发生改变)
    //    删除：指定 2 个参数：要删除的第一项的位置和要删除的项数。
    // 　　　　格式：arr.splice( 1 , 3  )
    //    插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。
    // 　　　　格式：arr.splice(  2,0,4,6  )
    //    替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
    // 　　　　格式：arr.splice(  2,0,4,6  )

    var akk = [1, 3, 5, 7, 9, 11];
    var arrRemoved = akk.splice(0, 2);
    console.log(arrRemoved);

    var arrRemoved2 = akk.splice(2, 0, 4, 6);
    console.log(arrRemoved2);

    var arrRemoved3 = akk.splice(1, 1, 2, 4);
    console.log(arrRemoved3);

    // 9. indexOf() / lastIndexOf()
    //   indexOf(): 接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。
    // 　　　　格式：arr.indexof( 5 ) (原数组会发生改变)
    //   lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的末尾开始向前查找。
    // 　　　　书写格式：arr.lastIndexOf(  5,4  )    (原数组会发生改变)

    var all = [1, 3, 5, 7, 9, 11];
    console.log(all.indexOf(5));
    console.log(all.lastIndexOf(5));

    // 10. forEach()
    // forEach(): 对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，
    // 默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。   (原数组不会发生改变)
    // 格式：arr.forEach()

    var azz = [1, 2, 3, 4, 5];
    azz.forEach(function (x, index, a) {
        console.log(x + '|' + index);
    });

    // 11. map()
    // map(): 指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。    (原数组会发生改变)
    // 格式：arr.map()

    var axx = [1, 2, 3, 4, 5];
    var axx2 = axx.map(function (item) {
        return item * item;
    });
    console.log(axx2);

    // 12. filter()
    // filter(): “过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。(原数组会发生改变)
    // 格式：arr.filter()
    var acc = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    var acc1 = acc.filter((item, index) => {
        return index === 0 || item > 8
    })
    console.log(acc1);

    // 13. every()
    // every(): 判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true，则返回false。 (原数组不会发生改变)
    // 格式：arr.every()
    var avv = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    var avv1 = avv.every(item => {
        return item < 10    // false
    })
    var avv2 = avv.every(item => {
        return item < 11    // true
    })
    console.log(avv1);
    console.log(avv2);

    // 14. some()
    // some(): 判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true，则返回false。(原数组不会发生改变)
    // 格式：arr.some()

    var abb = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    var abb1 = abb.every(item => {
        return item < 11    // true
    })
    var abb2 = abb.every(item => {
        return item < 8    // false
    })
    console.log(abb1);
    console.log(abb2);