javascript中数组的方法你真的都了解吗？

本篇文章主要讲述ES5中的数组，包括数组两种创建方式，属性，以及 9 大类 ，总共23个操作方法，非常全面，看完之后ES5数组这一部分基本都了解了，下一篇文章，我会讲述ES6中对数组的加成，新增了哪些方法，以及定型数组，类数组和类数组的所有方法，记得关注哦！

数组作为javascript中最常用的数据类型之一，掌握好数组的方法在日常的开发中是非常有必要的，javascript中的数组相比其他语言来说更灵活，因为数组的每一项都可以是不同的数据类型，可以是对象，数组，字符串，数值等等，接下来一点一点的了解吧！

1.数组的创建

说到数组首先肯定是创建，只有创建或者声明一个变量是数组之后才可以使用它，以及他的一些属性和方法。数组的创建有两种方式，即，构造函数式和数组字面量式。

  • 第一种构造函数式创建，利用new Array来创建，下面先上一段例子：

    var arr =  new Array();
var arr1 = new Array(3);
var arr2 = new Array("xiao mage");
var arr3 = new Array(12,34,);
var arr4 = new Array(,,,,,);
console.log(arr);               //[]
console.log(arr1);          //[empty*3]
console.log(arr2);          //["xiao mage"]
console.log(arr3);          //在谷歌浏览器中报错，不能多逗号，注意
console.log(arr4);          //在谷歌浏览器中报错，这样也是不行的

    分析一下，第一行创建了一个空数组；第二行创建了一个长度为3的空数组，注意这个3是数组的长度为3，不是数组的第一项是数值3，切记！在下一篇讲到的类数组方法Array.of()方法就可以创建数值3；第三个是创建了一个字符串数组，里面只有一个值；第四行，第五行都目前chrome浏览器无法编译通过，写法有问题，特意列出来注意一下。 在使用Array 的时候new也可以省略，其效果也是一样的。

  • 第二种是数组字面量创建数组，即直接用[]。 
    var arr = [];                   //[]
var arr1 =[12,34,];             //[12,34]
var arr2 = [,,,,] ;             //[empty*4]
var arr3 = ["xiaomage"];        //["xiaomage"]
var arr4 = [1,2,3,4,5];         //[1,2,3,4,5]
var arr5 = [1,{"a":1,"b":2},[434,798],"xiaomage"];
console.log(arr);               //[]
console.log(arr1);          //[12,34]
console.log(arr2);          //[empty*4]
console.log(arr3);          //["xiaomage"]
console.log(arr4);          //[1,2,3,4,5]
console.log(arr5);          //[1, {…}, Array(2), "xiaomage"],展开就是[1,{"a":1,"b":2},[434,798],"xiaomage"]

    再分析一下，第一行也是创建了一个空数组;第二行创建了一个长度为2的数组，数组中包含12,34，在有的浏览器中长度为3，注意一下。第三行创建了一个长度为4的空数组，数组的每一项值是undefined，有的浏览器也可能数组的长度是5。第四行创建了一项含有字符串的数组；第五行创建一个全是数值的数组，最后一行创建了一个长度为4的数组，每一项都是不同的数据类型。

    注意： 1. var arr = new Array(,,,,);是报错的，而var arr = [,,,,];是可以创建数组的；以及var arr = new Array(12,34,)也是报错的，而var arr = [12,34，]是可以的，这些注意不要搞混淆了，日常工作中都不推荐此种方法创建数组； 2. 虽然两种方法都可以创建数组，但是数组字面量要比构造函数的性能好，原因是：json格式的语法浏览器引擎能直接解析，而new Array需要调用Array的构造器。日常工作中可以使用前者，方便快速省性能。

2. length属性

大家都知道length属性表示数组的长度为多少，现在用构造函数式和数组字面量式创建一个长度为10的空数组，试试看：

var  arr = new  Array(10);
console.log(arr.length) ;               //10
var arr1 = [];
console.log(arr1.length);               //0
arr.length = 10;
console.log(arr);                       //[empty*10]
var arr2 = [,,,,,,,,,,];
console.log(arr2.length);               //10

现在用数组的length属性来操作数组的长度,不用arr.pop()和arr.shift()方法怎么来搞呢？

var arr1 = [0,1,2,3,4,5,6,7,8,9];
console.log(arr1.length);          //10
arr1.length = 8;
console.log(arr1);                //[0,1,2,3,4,5,6,7]

var arr2 = [1,2];
arr2.length = 100;
console.log(arr2) ;                 //[1, 2, empty × 98]
console.log(arr2[10]);               //undefined
arr2[99]  = 'xiaomage';
console.log(arr2)                   //[1, 2, empty × 97, "xiaomage"]
console.log(arr2.length);
arr2[arr2.length] = 1100000;
console.log(arr2);                  //[1, 2, empty × 97, "xiaomage",1100000]

分析一下：首先arr1 是一个长度为10的数组，当把数组的长度成为8的时候，此时会从数组的第一个元素开始向后截取8个作为数组的新值，此操作会改变数组。 arr2是一个长度为2的数组，将数组的长度设为100后，将依次为数组的剩余97项设置值为undefined，当再改变某一项的元素的时候就是正常的赋值了，最后一个给数组添加一项，当前数组的最后一项的索引是length-1,当arr.length就是添加一项。

3.数组的检测

数组作为引用类型之一，检测方法有两种：instanceof和isArray。其中instanceof适用于在一个网页或者一个全局作用域的情况比较实用，随着前端框架越来越多，在项目 中引入太多的框架的时候，每个框架对数组可能进行过二次封装，这样导致一个问题就是instanceof 返回的结果可能会不同，使用时得注意，基本用法如下：

var arr = [] ;
console.log(arr instanceof Array)；          //true

基于以上的问题，ES5又新增了新的检测方法，isArray 来确定某个值到底是不是数组，而不用管其他的作用域问题。写法如下：

var arr = [];
console.log(Array.isArray(arr));        //true

4.类栈操作相关

数据结构栈的特点就是后进先出(LIFO, last-in-first-out) ，比喻成容器罐好理解点，最后放的在上面，拿的时候也先从上面拿，操作推入和弹出，都发生在栈的顶部，javascript数组中有专门的方法push()和pop()来模拟栈的操作。

push()方法，接受不限制个数的参数，在数组的末尾插入元素，返回值是修改后的数组的长度，此方法会改变原数组；pop()方法，不接受参数，从数组的末尾来删除最后一个元素，返回值是删除的元素，此方法也会改变原数组。下面我们来看看具体用法：

var arr = [92,09,13,'xiaomage'];
console.log(arr.length);                    //4
var count = arr.push('daqianduan',89);
console.log(count);                         //6
console.log(arr);                           //[92, 9, 13, "xiaomage", "daqianduan", 89]
var item = arr.pop();
console.log(item);                          //89
console.log(arr);                           //[92, 9, 13, "xiaomage", "daqianduan"]

5.类队列操作相关

上面聊完了栈，现在来看看队列，相信这两个词大家都不陌生，队列的特点是：先进先出（FIFO , first-in-first-out）,看做是一个空的管道比较好理解，从一端进入，另一端出去。javscript数组提供了shift()和push()方法来模拟队列的特点。

shift() , 从数组的头部删除一个元素，返回值是删除的元素，此方法会改变原数组，看看使用情况：

var arr = [25,78,{'a':1,'b':10},'javascript'];
var count = arr.push([12,34]);
console.log(count);                 //5
console.log(arr);                   //[25, 78, {…}, "javascript", Array(2)]
var item = arr.shift();
console.log(item);                  //25
console.log(arr);                   //[78, {…}, "javascript",Array(2)]
console.log(arr.length);            //4

跟shift()方法结果刚好相反的是unshift()方法，shift()是从数组头部删除元素，而unshift()刚好是从头部添加元素，接受不限个数的参数，返回值是改变后的数组的长度，此方法会改变数组，其实，这个方法效果跟push()一样，只不过一个在数组前面插入，一个在后面插入，看看效果：

var arr = ['xiaomage',[15],90,23];
arr.push('string1',10);
console.log(arr);                               //["xiaomage", Array(1), 90, 23, "string1", 10]
var count = arr.unshift([34,45],'string2');
console.log(count);                             //8
console.log(arr);                               //[Array(2), "string2", "xiaomage", Array(1), 90, 23, "string1", 10]
arr.shift();
console.log(arr);                               //[Array(2), "string2", "xiaomage", Array(1), 90, 23, "string1", 10]
arr.pop();
console.log(arr);                               //["string2", "xiaomage", Array(1), 90, 23, "string1"]

6.数组的重排序方法

说到数组的重排序方我们肯定想到的是reverse()和sort()方法，来了解一下这两个方法，首先：

reverse()方法是将数组进行反转，调换顺序，比较简单哈，返回结果是改变顺序后的数组，此方法会改变原数组。

var arr = [0 ,1 ,2 ,4,5,10,15];
var arr2 = arr.reverse();
console.log(arr2);                  //[15, 10, 5, 4, 2, 1, 0]
console.log(arr);                   //[15, 10, 5, 4, 2, 1, 0]

即返回的结果就是原数组改变后的结果，二者是相等的，但是这个方法只能反转不方便啊，比如说我想把数组按照升序或者降序排列，reverse就干不了，这时候就得用到sort()方法了。

sort()方法，默认是按照升序排列的，返回的结果也是改变后的数组，此方法会改变原数组。

var arr = [0,1,10000000,15,10,5];
var arr1 = arr.sort();
console.log(arr);                   //[0, 1, 10, 10000000, 15, 5]
console.log(arr1);                  //[0, 1, 10, 10000000, 15, 5]

首先，同学们可能会疑问，怎么返回的结果跟我预想的不一样呢，不应该是[0 , 1 , 5, 10 ,15 , 10000000]吗？这是因为当调用sort()方法的时候，首先sort()会把数组的每一项值都先调用toString()方法变成对应的字符串，即[‘0‘,‘1‘,‘10000000‘,‘15‘,‘10‘,‘5‘]；第二步再进行字符串的比较，挨个字符比较。上一篇《一篇文章搞定javascript中的字符串》我讲过字符串的比较方法，不了解的回过去看一下哈，然后得出结果[0, 1, 10, 10000000, 15, 5]。

这里同学可能就有疑问，我就想要结果[0 , 1 , 5, 10 ,15 , 10000000]。也不是不可以，这时候我们可以使用sort()方法的参数来进行处理，此方法接受一个比较函数来作为一个参数，里面我们可以自定义我们想要的结果，是想让升序呢，还是降序都可以实现。

var arr = [0,1,10000000,15,10,5];
var arr1 = arr.sort(compareArray);
console.log(arr1);                      //[0, 1, 5, 10, 15, 10000000]
console.log(arr);                       //[0, 1, 5, 10, 15, 10000000]

function compareArray(item1,item2){
    if(item1 < item2 ){
        return -1 ;
    }else if(item1 > item2 ){
        return 1 ;
    }else{
        return  0 ;
    }
}

是的，我们想要的结果得到了，这里解释一下compareArray，次方法作为sort()方法的参数，接受两个参数，分别是要比较的数组的两项，返回结果是三种，大于0 ，小于0，或者等于0.然后sort根据返回的结果，如果小于零则不用换位置，如果大于零则需要调换位置，等于零则代表相等，不做处理，进行下一次的比较。

前面我们看了升序的写法，那么降序也是一样的，只不过把返回值调换一下就可以了。

var arr = [0,1,10000000,15,10,5];
var arr1 = arr.sort(compareArray);
console.log(arr1);                      //[10000000, 15, 10, 5, 1, 0]
console.log(arr);                       //[10000000, 15, 10, 5, 1, 0]
function compareArray(item1,item2){
    if(item1 < item2 ){
        return 1 ;
    }else if(item1 > item2 ){
        return -1 ;
    }else{
        return  0 ;
    }
}

//这里我只是把sort的参数方法提出来了，下面这样写也是等价的。
var arr2 = arr.sort(function(item1 , item2){
     if(item1 < item2 ){
        return 1 ;
    }else if(item1 > item2 ){
        return -1 ;
    }else{
        return  0 ;
    }
});
console.log(arr2);

看着一个数组的比较，写了这么多的代码，有没有高级写法，简写的让自己的代码看起来更有逼格一点呢，当然有啊，这里我们用到ES6来改写一下：

var arr = [0,1,10000000,15,10,5];
arr.sort((item1 , item2)=> item1 - item2);
console.log(arr);               //[0, 1, 5, 10, 15, 10000000]

简单明了，这是升序的结果，如果想要降序用item2 - item1就可以。这里稍微解释一下，第一，箭头函数是原始函数的简写，方便轻巧，第二，当箭头函数中代码块中只有一行语句并且包含return时，可以省略{}和return。关于ES6后面的文章中我会在后面的文章中写，记得关注。

7.数组的转换方法

数组的转换方法有三个toString(),toLocaleString(),valueOf().

toString()，将数组转换成字符串 ,返回值是改变后的字符串，此方法不会改变数组。

var arr = [1, 'xiaoma' , [1,2,3], 10000];
var str = arr.toString();
console.log(arr);           //(4)?[1, "xiaoma", Array(3), 1000]
console.log(str);           //1,xiaoma,1,2,3,1000

toLocaleString()，在有的时候，结果和toString()一样，当然也不总是 一样，，这得跟当地的编码有关，使用时也得注意，此方法转换时每一项都调用toLocaleString()。

var arr = [1, 'xiaoma' , [1,2,3], 1000000];
var str = arr.toLocaleString();
console.log(arr);           //[1, "xiaoma", Array(3), 1000000]
console.log(str);           //1,xiaoma,1,2,3,1,000,000
var arr2 = str.split(',');
console.log(arr2);          //(8)?["1", "xiaoma", "1", "2", "3", "1", "000", "000"]

在我们地区，超过三位以上的数字会以 ’,‘ 隔开的。所以得到的结果会和toString()不同。

valueOf()，该方法是数组对象的默认内置方法，返回Array对象的原始值，该原始值由Array对象派生的所有对象继承，此方法不会改变原数组。

var arr = [1, 'xiaoma' , [1,2,3], 1000000];
var arr2 = arr.valeuOf();
console.log(arr);           //[1, "xiaoma", Array(3), 1000000]
console.log(arr2);          //?[1, "xiaoma", Array(3), 1000000]

注意：所有的对象含有toString(),toLocaleString(),valueOf()这三个内置方法，并不是数组独有。

8.数组的操作方法

  • concat():顾名思义，连接，将一些数组拼接到一起形成一个新的数组，此方法不改变原数组。可以接受任意多个参数,参数可以是数组，字符串，数值都可以。当不传参数的时候只返回原数组的副本。
var arr = ['xiaoma' , 324, 90, 33] ;
var arr1 = arr.concat();
var arr2 = arr.concat('javascript',[1,3,,4],[5,6,7],10);
console.log(arr);           //["xiaoma", 324, 90, 33]
console.log(arr1);          //["xiaoma", 324, 90, 33]
console.log(arr2);          //["xiaoma", 324, 90, 33, "javascript", 1, 3, empty, 4, 5, 6, 7, 10]
  • slice():即截取，接受一个或者两个参数，第一个参数是要截取的起始项，第二个参数是截止项。当只有一个参数的时候，默认是从起始项到数组末尾，该方法返回的是一个新数组,不改变原数组。
var arr = ['xiaoma', [1,2,3],10,45,{'a':1,'b':2},'javascript'];
var newArr = arr.slice(1);
var newArr2 = arr.slice(2,4);
console.log(arr);               //["xiaoma", Array(3), 10, 45, {…}, "javascript"]
console.log(newArr);            //[Array(3), 10, 45, {…}, "javascript"]
console.log(newArr2);           //?[10, 45]

当slice的参数中含有负数的参数的时候，则用数组的长度+负参数作为新的参数值再开始截取，计算后的第二个参数比第一个参数小时，则返回的是一个空数组。

var arr = ['xiaoma', [1,2,3],10,45,{'a':1,'b':2},'javascript'];
var newArr = arr.slice(-3,-2);  //重新计算相当于slice(3,4)
console.log(newArr);                //[45]
var newArr2 = arr.slice(-3,-4);     //slice(3,2)
console.log(newArr2);               //[]
  • splice(): slice 是截取数组，而splice是向数组中插入元素或者删除元素，或者替换元素，参数的个数的不同起到的作用也不同。

    1. 删除元素，两个参数，第一个是起始位置，第二个是要删除的个数。此方法会改变原数组,返回值是删除的新数组，不改变原数组。
  var arr = [1,2,3,4,5,6,7,8];
  var item = arr.splice(3,3);
  console.log(item);            //[4, 5, 6]
  console.log(arr);         //(6)?[1, 2, 3, 7, 8]

2.插入元素，三个参数，第一个参数是起始位置，第二个参数删除的个数为0，第三个是要插入的元素，如果要插入多个项，则会有第四个，五个参数，总之，从第三个开始都是要插入的项数，返回值是[]，会改变原数组。

var arr = [1,2,3,4,5,6,7,8];
var item = arr.splice(4,0,"xiaomage");
console.log(arr);       //(9)?[1, 2, 3, 4, "xiaomage", 5, 6, 7, 8]
console.log(item);      //[]
var item2 = arr.splice(5,0,[10,23,45],"js","web");
console.log(arr);       //(12)?[1, 2, 3, 4, "xiaomage",[10,23,45], "js", "web", 5, 6, 7, 8]
console.log(item2);     //[]
  1. 替换元素，三个以上的参数，其中第二个参数不能为0，否则就是插入元素了，先删除后替换。返回值是删除原数组的元素所组成的数组
var arr = [1,2,3,4,5,6,7,8];
var item = arr.splice(3,2,100000,10000001,10002);
console.log(arr);           //(9)?[1, 2, 3, 100000, 10000001, 10002, 6, 7, 8]
console.log(item);          //?[4, 5]

分析一下，首先是从第三个开始删除了两项，得到[4,5]，然后再在此位置上插入了三项，删除项和替换项不一定要相等。

9. 查找位置相关的方法

javascript数组提供查找位置的方法有两种，indexOf()和lastIndexOf(). 查找的时候当数组中有重复的元素是只返回首次出现的元素的位置。

  1. indexOf(): 如果在数组中能查找到则返回其索引值，如果找不到则返回-1。此方法接受两个参数，第一个参数是要查找的元素，第二个参数是查找的起始位置， 如果没有第二个参数则默认从0开始查， 如果第二个参数是负数的话，则将其作为数组末尾值得一个抵消，即-1表示从最后一个元素开始向后查找，-2表示从倒数第二个元素查找。 如果第二个参数大于数组的长度，表示 已经超出查找范围了，直接返回-1。一直都是从前向后查找，跟参数是不是 负数，查出范围没关系，此方法不会改变原数组。
  2. lastIndexOf(): 与indexOf()不同的是这个方法是从后向前查找，其他的都一样。
var arr = ?[1, 2, 3, 100000, 10000001,[34,45],6,3 ,10002, 6, 7, 8];
var count = arr.indexOf(6);
var count5 = arr.indexOf(6,100);
var count1 = arr.indexOf([34,45]);
console.log(count);                     //6
console.log(count5)                     //-1
console.log(count1);                    //-1
var count2 = arr.indexOf("xiaoamge");
console.log(count2);                    //-1
var count3  = arr.lastIndexOf(3);
console.log(count3);                    //7
var count4 = arr.lastIndexOf([34.45]);
console.log(count4);                    //-1

10.数组的迭代方法

数组的迭代在ES5中是有5个，分别是every,filter,forEach,map,some,这五个方法接受两个参数，第一个是函数，是要作用在数组的每一项上面的函数，第二个参数是作用域对象，可选，默认是this即数组对象本身。第一个参数函数接受三个参数，分别是数组的每一项，第二个是索引，第三个是当前的数组。下面分别来看一下其含义和用法：

  • every() : 英文意思，简单理解是每一个，即作用在数组每一项上面的函数的返回都为true的时候，Array.every才返回true，此方法不会改变原数组。看一个例子,有一个学生的成绩数组，判断是不是都及格了，看看怎么写：
var arr = [99,57,67,88,100,78];
var result = arr.every(function(item, index ,array){
    return item > 60 ;
});
console.log(result);            //false
console.log(arr);               //[99,57,67,88,100.78]

var arr2 = [100,98,87,76,61];
var result2 = arr2.every(function(item, index , array){
    return item >60 ;
});
console.log(result2);           //true
  • filter() : 过滤，即把符合指定条件的过滤出来，比较简单，看看例子，把及格的学生筛选出来：
var arr = [99,57,67,88,60,100,78];
var newArr = arr.filter(function(item , index ,array){
    return item >= 60 ;
});
console.log(newArr);            //[99, 67, 88, 60，100, 78]
  • forEach() : 遍历数组的每一项然后进行后续的逻辑操作 ， 此方法没有返回值。
var arr = [99,57,67,88,60,100,78] ;
var newArr = [] ;
arr.forEach(function(item , index ,array){
    if(item >=60){
        newArr.push('及格') ;
    }else {
        newArr.push('不及格') ;
    };
});
console.log(newArr);            //["及格", "不及格", "及格", "及格", "及格", "及格", "及格"]
  • map() : 遍历整个数组的每一项，返回指定操作后的结果。
var arr = [99,57,67,88,60,100,78] ;
var newArr = arr.map(function(item , index ,array){
    //return item * 10 +10 ;        //[1000, 580, 680, 890, 610, 1010, 790]
    return item>=60 ? '及格' : '不及格' ;
});
console.log(newArr) ;           //["及格", "不及格", "及格", "及格", "及格", "及格", "及格"]
  • some() :此方法跟every()不同的是，every只有都满足条件的时候才返回true ,some是只要有一个满足条件就返回true。every 类似于 && ，而some 类似于 ||。看个例子，查看班级里面有没有成绩超过90分的同学，并且计算有几个：
var arr = [45, 60 , 80, 90 ,99 ,94];
var count = 0 ;
var result = arr.some(function(item , index , array){
   return item >90 ;
});
console.log(result) ;       //true

var count = arr.filter(function(item , index ,array){
    return item >=90;
}).length;

console.log(count) ;        //3

11.数组的缩小方法

ES5中提供了两个数组缩小的方法，reduce()和reduceRight()， 两个方法都会遍历数组的所有项，然后返回一个操作后的最终结果。这两个方法都接受两个参数，第一个，作用在数组项上的函数，第二个，是 作为缩小基础的初始值，可选。

  • reduce() : 接受四个参数，分别是前一个值（prev），当前值（cur），索引 (index），以及当前数组本身(array)，参数名字随便起。当reduce的第二参数有值的时候，第一次遍历的时候，函数的的第一个参数(prev)就是这个初始值，没有值时,第一次遍历的时候前一个值（prev）和当前值（cur）分别是数组的前两项。有点斐波那契数列的感觉，遍历的时候是从前向后。来看一个字符串拼接操作应用：
var arr= ['hello' ,'_this' , '_is' , '_javascript' ,'_Array'];
var result = arr.reduce(function(prev, cur ,index , array ){
    console.log(prev , cur) ;
    // xiomage_  hello
    // xiomage_hello  _this
    // xiomage_hello_this  _is
    // xiomage_hello_this_is  _javascript
    // xiomage_hello_this_is_javascript  _Array
    return prev + cur ;
},'xiomage_');
console.log(result);        //xiomage_hello_this_is_javascript_Array
  • reduceRight() : 和reduce唯一不同的是从后向前遍历，类似于indexof和lastIndexOf()的查找顺序，一个前面开始，一个从后面开始。
var arr = [1,2,3,4,5,6];
var result = arr.reduceRight(function(prev,cur,index,array){
    return prev + cur ;
});
console.log(result);            //21

好了，ES5数组的所有的方法已经讲完了，总共9大类，23个函数，你都了解了吗？

下一篇文章，我会讲述ES6中对数组的加成，新增了哪些方法，以及定型数组，类数组和类数组的所有方法，记得关注哦！

原文地址：https://www.cnblogs.com/majianwen/p/10704540.html

时间： 2024-10-11 01:42:14

javascript中数组的方法你真的都了解吗？的相关文章

JavaScript中数组Array方法详解

ECMAScript 3在Array.prototype中定义了一些很有用的操作数组的函数,这意味着这些函数作为任何数组的方法都是可用的. 1.Array.join()方法 Array.join()方法将数组中所有元素都转化为字符串并连接在一起,返回最后生成的字符串.可以指定一个可选的符号或字符串在生成的字符串中来分隔数组的各个元素.如果不指定分隔符,默认使用逗号.注意:此方法不会改变原始数组 var arr = ['a', 'b', 'c']; console.log(arr.join());

JavaScript中数组的方法总结

js数组元素的添加和删除一直比较迷惑,今天终于找到详细说明的资料了,先给个我测试的代码^-^var arr = new Array();arr[0] = "aaa";arr[1] = "bbb";arr[2] = "ccc";//alert(arr.length);//3arr.pop();//alert(arr.length);//2//alert(arr[arr.length-1]);//bbbarr.pop();//alert(arr[ar

JavaScript中数组迭代方法（jquery）

var arr = [1,2,4,5,6]; //1.forEach(让数组中的每一项做一件事)arr.forEach(function(item,index){    console.log(item);    //1,2,4,5,6}); //2.map(让数组通过某种计算产生一个新数组)var newArr = arr.map(function(item,index){    return item*2;});console.log(newArr);//[2,4,8,10,12] //3.

JavaScript中数组的方法和字符串方法总结

数组是首先的一个对象, 可以通过Array构造器创建一个数组,数组方法总结如下 cacat()  链接两个数组 join()  将数组链接成字符串 pop() 删除最后一个元素  shift()  删除第一个元素 push() 末尾增加一个或者多个元素 返回新的长度,可以增加多个参数作为数组的新元素 unshift() 删除第一个元素或者更多的元素返回新的长度 slice() 返回某个指定的元素  返回值是选定的元素 ,参数是数组的索引值 改变数组个数 sort() 可以对数组元素进行排序, 默

JavaScript中数组Array.sort()排序方法详解

JavaScript中数组的sort()方法主要用于对数组的元素进行排序.其中,sort()方法有一个可选参数.但是,此参数必须是函数. 数组在调用sort()方法时,如果没有传参将按字母顺序(字符编码顺序)对数组中的元素进行排序,如果想按照其他标准进行排序,就需要进行传一个参数且为函数,该函数要比较两个值,并且会返回一个用于说明这两个值的相对顺序的数字. 1.对数字数组进行由小到大的顺序进行排序. 代码: var arr = [22,12,3,43,56,47,4]; arr.sort();

javascript中数组比较大小方法

javascript中数组取最大值和最小值 1.排序法 我们给数组进行排序,可以按照从小到大的顺序来排,排序之后的数组中第一个和最后一个就是我们想要获取的最小值和最大值.排序我们会用到数组的 sort 方法. var arr = [12,56,25,5,82,51,22]; arr.sort(function (a, b) { return a-b; }); // [5,12,22,25,51,56] var min = arr[0]; // 5 var max = arr[arr.length

javascript中的toString()方法

javascript中的toString()方法,主要用于Array.Boolean.Date.Error.Function.Number等对象.下面是这些方法的一些解析和简单应用,做个纪律,以作备忘. (1)Array.toString():将数组转换成一个字符串,并且返回这个字符串.描述:当数组用于字符串环境中时,javascript会调用这一方法将数组自动转换成一个字符串.toString()在把数组转换成字符串时,首先要将数组的每个元素都转换成字符串(通过调用这些元素的toString方

私人定制javascript中数组小知识点(Only For Me)

先上笑话,1.刚看到一个游泳的,想起公司组织去三亚旅游,老板跳海里,各种挣扎,捞上来老板第一句话:我记得我会游泳的啊. 2.媳妇说:老公对不起,我把你新买的自行车撞散架了! 老公:没事宝贝,你若安好,便是晴天! 媳妇说:老公你太有诗意了. 老公:滚犊子,安不好我整死你! 数组的概念 javascript数组是值得有序集合,不过它实属一个javascript对象的特殊形式,这是一个很重点的定性. 创建数组 1.var a=new Array();//等同于[] 2.var a=new Array(

js中数组的方法

数组在笔试中经常会出现的面试题,javascript中的数组与其他语言中的数组有些不同,为了方便之后数组的方法学习,下面小编给大家整理了关于数组的操作方法,一起看看吧. 数组创建: 1.JavaScript中创建数组有两种方式,第一种是使用 Array 构造函数: var arr1 = new Array(); //创建一个空数组 var arr2 = new Array(20); // 创建一个包含20项的数组 var arr3 = new Array("lily", "l