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);

巴特西

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

最新文章

热门文章