// 1） 添加元素移除元素相关【改变原值】

        //push(p1,p2,...);
            //入栈，在数组的最后添加一个元素. 参数：要入栈的元素. 返回值：数组长度
        var arr = [1,2,3,4,5];
        var result = arr.push("txt","tom","lucy");
        console.log(arr);    //新数组：    [1,2,3,4,5,"txt","tom","lucy"]
        console.log(result);    //新数组长度：    8


        //pop();    
            //出栈，从数组的最后取出一个元素. 参数：none. 返回值：     出栈的元素
        var arr = [1,2,3,4,5];
        var result = arr.pop();
        console.log(arr);    //新数组：    [1,2,3,4]
        console.log(result);    //取出的元素：    5


        //shift();
            //出队，将数组中第一个元素取出来. 参数：none. 返回值：出队的元素
        var arr = [1,2,3,4,5];
        var result = arr.shift();
        console.log(arr);    //新数组：    [2,3,4,5]
        console.log(result);    //取出的元素：    1


        //unshift(p1,p2,...);    
            //插队，将元素插入在数组的最前面. 参数：要插队的元素. 返回值：插队后队列的长度
        var arr = [1,2,3,4,5];
        var result = arr.unshift("txt","tom","lucy");
        console.log(arr);    //新数组：    ["txt","tom","lucy",1,2,3,4,5]
        console.log(result);    //新数组长度：    8


//2）排序方法【改变原值】

        //sort();
            //按照字符在字符编码表中出现的位置进行排序
        var arr = [19,47,51,4,2,32,24,6];
        var result = arr.sort();
        console.log(arr);    //新数组     [19,2,24,32,4,47,51,6]
        console.log(result);    //返回值        [19,2,24,32,4,47,51,6]


        //sort(comparator);
            //comparator为一个比较器函数，函数可以接受两个值a,b；当a位于b之前的时候返回
        var arr = [19,47,51,4,2,32,24,6];
        console.log(arr);    //原数组        [19,47,51,4,2,32,24,6]
        var result = arr.sort(function(a,b){
            if(a<b){
                return 1;
            }else{
                return -1;
            }
        });
        console.log(arr);    //新数组        [51,47,32,24,19,6,4,2]
        console.log(result);    //返回值        [51,47,32,24,19,6,4,2]


//3）序列化方法【不改变原值】

        //toString();
            //将数组转换为字符串，数组中的元素通过逗号连接
        var arr = [1,2,3,4,5];
        var result = arr.toString();
        console.log(arr);    //原数组        [1,2,3,4,5]
        console.log(typeof result);        //返回值类型     string
        console.log(result);    //返回值     1,2,3,4,5


        //join("v");
            //将数组转换为字符串，数组中的元素通过v连接
        var arr = [1,2,3,4,5];
        var result = arr.join("#");
        console.log(arr);    //原数组        [1,2,3,4,5]
        console.log(result);    //返回值     1#2#3#4#5


        //JSON.stringfy();
            //将数组转换为JSON字符串
        var result = JSON.stringify([1,2,3,4,5]);
        console.log(typeof result);        //返回值类型     string
        console.log(result);    //返回值     [1,2,3,4,5]


//4)截取方法

        //concat();    【不改变原值】
            //将参数中的数组和当前数组合并为一个数组. 参数：多个数组. 返回值：合并后的数组
        var arr1 = [1,2,3];
        var arr2 = [4,5,6];
        var arr3 = [7,8,9];
        var result = arr1.concat(arr2,arr3);
        console.log(arr1);        //原数组     [1,2,3]
        console.log(arr2);        //原数组     [4,5,6]
        console.log(arr3);        //原数组     [7,8,9]
        console.log(result);    //返回值     [1,2,3,4,5,6,7,8,9]


        //slice(begin,end);    【不改变原值】
            //从当前数组中截取一个子数组并且范围. 参数: begin 起始位置;  end 结束位置. 返回值：截取到的子数组
        var arr = [1,2,3,4,5,6,7,8,9];
        var result = arr.slice(2,7);    //从索引为2的元素开始截取（7-2）个元素
        console.log(arr);        //原数组     [1,2,3,4,5,6,7,8,9]
        console.log(result);        //返回值     [3，4，5，6，7]


        //splice(bengin,delete,[p1,p2,...]);    【改变原值】
            //从数组中删除、插入、更新元素. 参数：begin 起始位置（删除，插入); delete 删除的个数; p1,p2,... 插入的值. 返回值：删除的元素组成的数组
        var arr = [1,2,3,4,5];
        var result = arr.splice(1,2,"txt","tom","lucy");
        console.log(result);    //删除的元素：        [2,3]
        console.log(arr);    //删除后插入形成的新数组：         [1,"txt","tom","lucy",4,5]


//5)迭代方法
        
        //forEach(function(item,index,arr){})
            //遍历当前数组.  参数：function(item,index,arr){}.  每次遍历一次，这个匿名函数就会被调用一次，forEach将当前遍历的元素，索引，当前数组当做实参传递给这个匿名函数
        var arr = [1,2,3,4,5];
        var result = arr.forEach(function(a,b,c){
            console.log(a);        //数组的项    1 /n    2 /n    3 /n    4 /n    5
            console.log(b);        //数组的索引        0 /n    1 /n    2 /n    3 /n    4
            console.log(c);        //数组本身    [1,2,3,4,5] /n    [1,2,3,4,5] /n    [1,2,3,4,5] /n    [1,2,3,4,5] /n    [1,2,3,4,5]
        });
        console.log(result);    //返回值        undefined


        //every(function(item,index,arr){})
            //判断数组中所有的元素是否满足回调函数中给定的条件.  参数：function(item,index,arr){}.  当每次回调函数返回值为true，every方法的结果为true,当回调函数返回值为false,every方法的结果就为false
        var arr = [1,2,3,4,5];
        var result = arr.every(function(item,index,arr){
            return item >3;
        });
        console.log(result);    //返回值        false


        //some(function(item,index,arr){})
            //判断数组中是否有满足条件的元素.  参数：function(item,index,arr){}.  当回调函数返回true,some方法的结果就为true,当每次回调函数返回false,some方法的结果才为falses
        var arr = [1,2,3,4,5];
        var result = arr.some(function(item,index,arr){
            return item >3;
        });
        console.log(result);    //返回值        true


        //filter(function(item,index,arr){})
            //参数：function(item,index,arr){}.  当回调函数返回true,当前元素就会被添加到返回值数组中.  返回值：数组
        var arr = [1,2,3,4,5];
        var result = arr.filter(function(item,index,arr){
            return item >3;
        });
        console.log(result);    //返回值        [4,5]


        //map(function(item,index,arr){})
            //参数：function(item,index,arr){}.  回调函数可以返回任意类型的值，这些值都会被添加到map方法的返回值数组中.  返回值：数组
        var arr = [
            {name:"tom",age:13},
            {name:"lucy",age:18},
            {name:"leilei",age:16}
        ];
        var result = arr.map(function(item){
            // return item.age;
            return item.name;
        });
        console.log(result);    //返回值        /* [13,18,16] */    ["tom","lucy","leilei"]


//6)查找方法

        //indexOf();
            //查找元素在数组中的位置.  参数:查找元素.  返回值：元素对应的索引.
        var arr = [1,2,3,4,5];
        var result = arr.indexOf(4);
        console.log(result);    //返回值        3


        //lastlndexOf();
            //查找元素在数组中的位置.  参数:查找元素.  返回值：元素对应的索引.
        var arr = [1,2,3,4,5];
        var result = arr.lastIndexOf(1);
        console.log(result);    //返回值        0