js数组【续】(相关方法)

一、数组的栈，队列方法【调用这些方法原数组会发生改变】
var arr = [2,3,4,5,6];
1.栈 LIFO (Last-In-First-Out)
a、push() 可接受任意类型的参数，将它们逐个添加到数组的末尾。【返回数组的长度】

    console.log(arr);  //[2,3,4,5,6]
    console.log(+arr.push(7)); //返回添加数据后数组的长度：6
    console.log(arr);  //[2,3,4,5,6,7]

b、pop() 从数组的末尾移除最后一项，减少数组的length值。【返回移除的项】

    console.log(arr.pop()); //取出栈顶元素并返回该栈顶元素值：7
    console.log(arr);  //[2,3,4,5,6]

2.队列 FIFO (First-In-First-Out)
a、shift() 移除数组中的第一个项，同时将数组的长度减一。【返回移除的项】

    console.log(arr.shift()); //hello
    console.log(arr); //[2,3,4,5,6]

b、unshift() 在数组的前端添加任意个项。【返回数组的长度】

    console.log(arr.unshift('hello')); //
    console.log(arr); //['hello',2,3,4,5,6]

二、数组的排序方法【reverse()方法、sort()方法】(原数组发生改变)
var arr = [23,56,12,43,6,23,26];
1、reverse()方法：【对数组项进行反转】

    console.log(arr);
    //反转 翻转 reverse  改变原数组
    console.log(arr.reverse());
    console.log(arr);

2、sort()方法【数组排序,返回排序后的数组】
a、sort()不带参数默认为升序

    console.log(arr.sort()); //按照字符串ASSIC码形式比较

b、sort()带指定排序函数
函数返回值：
    正值：交换
    负值：不交换

    console.log(arr.sort(com));
    console.log(arr);
    function com(a,b){
        //return a-b;  //升序
        //负数a,b不发生交换 a b  a<b 负值  不交换;  a b  a<b  升序排列
        //正数数a,b不发生交换   a b  a>b 正值  交换;   b  a   b<a  升序排列

        //return b-a;  //降序

        //升序
        if(a<=b){
                return -1;  //负数不发生交换
        }else{
                return 1;  //正数发生交换
        }

拓展：【万能比较器】

    var stu = [
        {
                name:'zhangsan',
                age:14,
        },
        {
                name:'lisi',
                age:20
        }
    ];

    stu.sort(compare('name','升序'));
    console.log(stu);
    stu.sort(compare('age','降序'));
    console.log(stu);

    //相关调用的比较函数
    function compare(attr,rules){
        return function(o1,o2){
                if(rules === '升序'){
                        if(o1[attr] <= o2[attr]){
                                return -1;
                        }
                        return 1;
                }else{
                        if(o1[attr] >= o2[attr]){
                                return -1;
                        }
                        return 1;
                }
        }
    }

3、查找最高(最低)的数组值
a.使用sort()方法先进行排序，然后再在排好序的数组中取值
b.使用Math.max.apply()和Math.min.apply()方法

    Math.max.apply(null,array);　　//获取array数组中的最大值
    Math.min.apply(null,array);　　//获取array数组中的最小值

三、截取方法：
1、数组拼接：concat()方法 【不改变原数组】
先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，返回副本数组。
eg:

    var arr = [3,4,5,2,4];
    var arr2 = [1,2,3,4,5];

    var result = arr.concat(arr2);
    console.log(arr);    //[3,4,5,2,4]
    console.log(result);    //[3,4,5,2,4,1,2,3,4,5]

    var result2 = arr.concat('hello');
    console.log(result2);    //[3,4,5,2,4,'hello']

自身定义方法myConcat()来实现concat()

    /*
        concat()方法
        1.不改变原数组，创建副本数组
        2.如果参数是数组，展开放入
        3.如果是其他参数添加到末尾
        4.返回副本
    */
    Array.prototype.myConcat = function(param){
        //创建副本数组
        var array = [];
        for(var i=0;i<this.length;i++){
                array.push(this[i]);
        }
        //判断添加数据类型
        if(Array.isArray(param)){
                for(var j=0;j<param.length;j++){
                        array.push(param[j]);
                }
        }else{
                array.push(param);
        }
        return array;
    };

    var result = arr.myConcat('hello');
    console.log(result);
    var result2 = arr.myConcat([7,8,9,10]);
    console.log(result2);
    console.log(arr);

2、数组切割：slice()方法 【不改变原数组】
slice(返回项的起始位置，结束位置);
一个参数：从该参数指定的位置开始，到当前数组末尾的所有项。
两个参数：起始到结束之间的项，但是不包含结束位置的项。
eg:

    //参数是一个为从开始位置截取到末尾；参数是两个的，截取部分为开始位置到结束位置不包括结束位置的值
    //返回截取部分的值,不改变原数组
    var arr = [123,34,5,67,3,6,8];
    var result = arr.slice(2);
    console.log(result);  //[5,67,3,6,8]
    console.log(arr);  //[123,34,5,67,3,6,8]

    var result2 = arr.slice(2,4);
    console.log(result2); //[5,67]

3、splice() 【改变原数组】
向数组的中部插入数据将始终返回一个数组，该数组中包含从原始数组中删除的项。
删除：指定一个参数(删除的开始的位置)【删除该参数索引及后面的所有元素】；指定两个参数(删除的起始位置，要删除的项数) 【返回删除的元素组成的数组】
插入：指定三个参数(起始位置，0，要插入的项任意数量的项)
替换：指定三个参数(起始位置，要删除的项数，要插入的任意数量的项)
eg:

    //删除
    var arr = [32,4,9,3,0];
    var result = arr.splice(1,3);
    console.log(result);  //[4,9,3]
    console.log(arr); //[32,0]

    //插入
　　 var arr = [32,4,9,3,0];
    arr.splice(1,0,'hello','sss');
    console.log(arr);  //[32,'hello','sss',4,9,3,0]

    //替换
    //从索引位置为1的删除两项后在开始位置处再插入一些元素
　　 var arr = [32,4,9,3,0];
    arr.splice(1,2,1,2);
    console.log(arr); //[32,1,2,3,0]

四、索引方法
indexOf lastindexOf 返回索引或-1
var arr = [2,5,67,'2',3,2,45];
1、indexOf()
从数组开头向后查找，使用全等操作符，找不到该元素返回-1。
参数：第一个参数为要查找的项，第二个参数（可选）为索引开始位置

    //参数：要查找的元素   开始查找的位置
    console.log(arr.indexOf(2)); //
    console.log(arr.indexOf(2,1)); //
    console.log(arr.indexOf(22)); //-1

2、lastIndexOf()
从数组末尾向前查找，使用全等操作符，找不到该元素返回-1。
参数：第一个参数为要查找的项，第二个参数（可选）为索引开始位置

    console.log(arr.lastIndexOf(2));  //
    console.log(arr.lastIndexOf(2,3)); //

3.常用于判断数组中是否含有该元素

    if(arr.indexOf(2) != -1){ }

五、迭代方法
参数： 每一项上运行的函数，运行该函数的作用域对象（可选）
1、every()
对数组中的每一运行给定的函数参数，如果该参数函数对每一项都返回true,则该函数返回true
eg:

    var arr = [23,45,1,4,3,45,7];
    var result = arr.every(function(item,index,arr){
        console.log(this); //{}
        return item>20;
    },{});
    console.log(result); //false

自己定义myEvery()方法来实现every()方法：
eg：

    var arr = [23,45,1,4,3,45,7];

    Array.prototype.myEvery = function(fun,funThis){
        //var result;
        for(var i=0;i<this.length;i++){
                var result = fun.call(funThis,this[i],i,this);
                if(!result){
                        //break;
                        return result;
                }
        }
        return result;
    };

    var result = arr.myEvery(function(item,index,arr){
        console.log(this); //{}
        return item>20;
    },{});
    console.log(result); //false

2、some(),3、filter(),4、map()使用的数组如下：
var stus = [
        {
                name:'zhangsan',
                age:20
        },{
                name:'lisi',
                age:13
        },{
                name:'wangwu',
                age:12
        }
];
2、some()
对数组中的每一运行给定的函数，如果该函数对任一项都返回true,则返回true
eg：

    //判断是否有未成年人，有返回true，否则返回：false
    var result = stus.some(function(item,index,arr){
         return item.age<18
    });
    console.log(result); //true

3、filter()
对数组中的每一运行给定的函数，会返回满足该函数的项组成的数组
eg：

    //filter
    //过滤出来所有成年人
    var result = stus.filter(function(item,index,arr){
        return item.age>18;
    });
    console.log(result);

    //查找所有未成年人的名字
    //先过滤出所有未成年人再映射出符合条件人名字
    var result = stus.filter(function(item,index,arr){
        return item.age<18;
    }).map(function(item,index,arr){
        return item.name;
    });
    console.log(result);

4、map()
对数组中的每一元素运行给定的函数,返回每次函数调用的结果组成的数组

    //map
    //查找处所有人的名字,返回数组
    var result = stus.map(function(item,index,arr){
        return item.name;
    });
    console.log(result);
    var result = stus.map(function(item,index,arr){
        return item.age*2;
    });
    console.log(result);

5、forEach()
对数组中的每一元素运行给定的函数,没有返回值，常用来遍历元素

    //数组的遍历
    var arr = [{
        name:'zhangsan'
    },{
        name:'lisi'
    },{
        name:'terry'
    }];
    //向数组各元素对象中添加age属性
    var ageInit = 10;
    arr.forEach(function(item,index,arr){
        item.age = ageInit++;
    });
    console.log(arr);