数组常用方法

    数组常用方法
    1. push
       语法 数组.push（要插入的数据）
       作用： 向数组末尾添加数据
       返回值 追加数组后，数组最新长度（leghth）
    2.pop
       语法 数组.push（）
       作用： 删除数组最后一条数据
       返回值 被删除的数
    3.unshift
       语法 数组.unshift（要添加的数据）
       作用： 向数组开头添加数据
       返回值 追加数组后，数组最新长度（leghth）
    3.shift
       语法 数组.shift（）
       作用： 删除数组第一条数据
       返回值 被删除的数
    5.reverse()
       语法 数组.reverse()
       作用： 翻转数组
       返回值 翻转后的数组
    6.sort()
       语法1. 数组.sort()
       语法2. 数组.sort(function(a,b) {return a - b})
       //如果有不能转化的数据，就会按照初始的位置排列
       //会按照数字大小升序排列
       语法3. 数组.sort(function(b,a) {return b - a})
        //会按照数字大小降序排列
       作用： 不传数据会将数据转化为字符串后一位一位的输出
       返回值 排序后的数组
    7.splice  
       语法 数组.splice（开始索引，多少个）
       语法 数组.splice（开始索引，多少个，插入数据1，插入数据1...）
       作用： 截取数组的部分内容
       作用： 截取数组的部分内容，并插入新的数据
       返回值 截取出来的部分内容组成的新数组
    8.splice  
       语法 数组.slice（开始索引，结束索引）
       作用： 截取数组的部分内容
       返回值 截取出来的部分内容组成的新数组   
       面试题，数组中有两个方法 splice和slice 的区别
       spilce会改变数组，slice不会改变数组
       介绍两者的区别

    9.concat
       语法 原始数组.concat（数组1，数组2...,数据1，数据2）
       作用： 进行数据拼接，把数组...数据之类的小括号里的内容，拼接到原始数组中
       返回值 拼接好的数组
    10.join
       语法 数组.join（连接符）
       作用： 使用连接符，把数组内符每一个数据连接成一个字符串，（不写连接符默认使用的是逗号）
       返回值 拼接好的字符串    
    11.indexof(语法1)
       语法 数组.indexof（要检查的数据）
       作用： 从前到后，（从左到右）检测该数据第一次在该数组中出现的索引
       返回值 找到返回该数据在数组内第一次出现的下标 没有找到返回-1
       语法 数组.indexof（要检查的数据，开始索引）开始索引不写默认是0
       作用： 在开始索引的位置，按照从左到右的顺序检查该数据第一次在该数组内出现的索引     
    12.lastindexof
       语法 数组.indexof（要检查的数据，开始索引）开始索引不写默认是0         
       作用： 从后到前，（从右到左）检测该数据第一次在该数组中出现的索引
       返回值 找到返回该数据在数组内第一次出现的下标 没有找到返回-1
    */
    //push
    var arr = [1, 2, 3]
    console.log(arr);
    arr.push(500)
    console.log('最新数组', arr);
    console.log(arr.length);
    //pop
    var po = [4, 5, 6]
    var p = po.pop()
    console.log(p);
    console.log(po);
    //unshift
    var u = [7, 8, 9]
    console.log(u);
    u.unshift(200)
    console.log(u);
    console.log(u.length);
    //shift
    var s = [1, 4, 7]
    console.log(s);
    var st = s.shift()
    console.log(st);
    console.log(s);
    //reverse()
    var r = [1, 2, 3]
    console.log(r);
    var r1 = r.reverse()
    console.log(r1);
    console.log(r);
    var z = [1, 200, 30, 10000]
    console.log('原始数组', z);
    var zz = z.sort()
    console.log(z);
    console.log(zz);
    //语法2
    var cc = z.sort(function (a, b) { return a - b })
    console.log(cc);
    //语法3
    var dd = z.sort(function (a, b) { return b - a })
    console.log(dd);
    //splice（方法1）
    var f = [1, 2, 3, 4, 5]
    console.log('原始数组', f);
    var f1 = f.splice(1, 3)
    console.log(f1);
    console.log('截取之后的数组', f);
    //splice（方法2）
    var f4 = [1, 2, 3, 4, 5]
    console.log('原始数组', f);
    var f5 = f4.splice(1, 3, '我是新来的')
    console.log(f5);
    console.log('截取之后的数组', f4);
    //slice 对原本数组没有任何影响
    //注意 包前不包后（包含开始位置的索引位置的数据，不包含结束位置索引的数据）
    //不写开始索引默认是0 ，不写开始索引默认是数组的length
    //参数支持写负数，表示倒数第几个
    // var f7 = [1, 2, 3, 4, 5]
    // console.log('原始数组', f7);
    // var f8 = f7.slice(1, 4)
    // console.log(f8);
    // console.log('截取之后的数组', f7);
    // var f7 = [1, 2, 3, 4, 5]
    // console.log('原始数组', f7);
    // var f8 = f7.slice(4)
    // console.log(f8);
    // var f7 = [1, 2, 3, 4, 5]
    // console.log('原始数组', f7);
    // var f8 = f7.slice()
    // console.log(f8);//[1, 2, 3, 4, 5]
    // var f7 = [1, 2, 3, 4, 5,6,7,8,9,10,11,12]
    // console.log('原始数组', f7);
    // var f8 = f7.slice(3,-2)
    // console.log(f8);
    //9.concat
    var A = [1,2,3]
    var B = A.concat([4,5,6],[10,20],'qwer',['a','c','d'])
    console.log('原始数组',A);
    console.log(B);
    console.log(A);
    //10.join
    var C = [1,2,3]
    console.log('原始数组',C);
    var D = C.join('!')
    console.log(D);
    var D = C.join()
    console.log(D);
    //11indexof
    var AA= [1,2,3,4,5,5,5,7,1,7,4,2,3]
    var BB = AA.indexOf(5)
    console.log(BB);//4
    var BB = AA.indexOf(100)
    console.log(BB);//-1
    var BB = AA.indexOf(5,3)
    console.log(BB);//4
    var BB = AA.indexOf(100,5)
    console.log(BB);//-1
    //12 lastindexof(要检查的数据，开始索引)
    var E = [4,5,1,2,3,3,4,5]
    var G = E.lastIndexOf(1,4)
    console.log(G);//2
    var G = E.lastIndexOf(1,1)//-1
    console.log(G);