JavaScript中Array(数组) 对象

JavaScript中Array 对象

JavaScript中创建数组有两种方式

（一）使用直接量表示法：

var arr4 = []; //创建一个空数组
var arr5 = [20]; // 创建一个包含1项的数组
var arr6 = ["lily","lucy","Tom"]; // 创建一个包含3个字符串的数组
//查看数组的length长度（也就是说，length可以重新给数组定义长度，比原来的长，后面加逗号；比原来的短，会把之前定义的数组截断后，输出。）

　　var arr=["a","z","o","p","f","g"];
　　alert(arr.length);//6

　　//比原来的数组长
　　arr.length=10;

　　alert(arr);//a,z,o,p,f,g,,,,
　　alert(arr.length);//10

　　// 比原来的数组短　　

　　arr.length=3;
　　alert(arr);//a,z,o
　　alert(arr.length);//3

（二）使用new Array 构造函数：

var arr1 = new Array(); //创建一个空数组
var arr2 = new Array(20); // 创建一个包含20项的数组
var arr3 = new Array("lily","lucy","Tom"); // 创建一个包含3个字符串的数组

JavaScript中数组的方法也有好多，下面我们就一一介绍一下吧！~

1、indexOf()返回指定元素的位置，若元素不存在返回-1.（从前往后）

     lastIndexOf()返回指定元素的位置，若元素不存在返回-1.（从后往前）

var arr=[1,2,3];
alert(arr.indexOf(3));//2
alert(arr.indexOf(4));//-1
alert(arr.lastIndexOf(3));//2

2、slice()参数对应的是要返回项的起始位置和结束位置，若只有一个参数，该方法返回从参数指定位置到数组结尾的所有项，如果有两个参数则返回起始位置到结束位置之间的项但不包括结束位置项，返回的结果是一个新的数组，原数组不变.（如果是负数的话，是从后往前数，而且是从下标为1开始）

var arr=[1,2,3,4,5,6];
alert(arr.slice(0,3));//1,2,3
alert(arr.slice(3));//4,5,6

3、push()向数组末尾添加若干元素，返回添加元素后数组的长度.

var arr=[1,2,3];
alert(arr.push(4,5,6));//6 

4、pop()删除数组末尾最后一个元素，返回被删除的元素，若数组为空则返回undefined.

var arr=['a','b','c',];
alert(arr.pop());//c
var arr=[];
alert(arr.pop());//undefined

5、unshift()在数组头部添加若干元素，返回添加元素后数组的长度.

var arr=['a','b','c','d'];
alert(arr.unshift(1,2,3));//7

6、shift()删除数组头部的第一个元素，并返回被删除的元素，若数组为空则返回undefined.

var arr=[1,2,3];
alert(arr.shift());//1
var arr=[];
alert(arr.shift());//undefined 

7、sort()对数组进行排序，返回排序以后的数组，默认把所有元素转化为字符之后再进行排序，排序以后会改变原数组.（默认顺序是以ASCII排序的）

//对数字的数组排序，必须给它创建一个函数
function sortNumber(a,b){
return a-b;
}
var arr=[2,1,111,22,333];
alert(arr.sort(sortNumber));//1,2,22,111,333

//对英文字母进行排序
var arr=["a","z","o","p","f","g"];
alert(arr.sort());//a,f,g,o,p,z

    注意： 可以通过一个自定义的比较函数来进行排序，比较函数接收两个参数，如果第一个参数应该位于第二个参数之前应该返回负数，如果第一个参数应该位于第二个参数之后应该返回正数，若相等返回0，排序之后会改变原数组.

function compare(val1,val2){
       return val1-val2;
            }
var arr = [3,2,9,4];
alert(arr.sort(compare));//返回2,3,4,9

8、reverse()对数组中的数据进行反转，返回反转后的数组.

var a=[1,2,3];
alert(a.reverse());//3,2,1

9、splice()从指定位置删除若干元素，然后再从该位置添加若干元素，结果返回被删除的元素，第一个参数表示起始删除的位置，第二个参数表示要删除元素的个数，之后的元素表示要添加的元素.

var arr=[1,2,3,4,5,6];
alert(arr.splice(1,2,'a','b'));//2,3
alert(arr);//1,a,b,4,5,6

10、concat()把当前数组与另一个数组连接起来，并返回新的元素，原来的数组不被改变，concat可以接收任意一个元素和数组，并把数组拆开放入新的数组中.

var arr=['a','b','c','d'];
alert(arr.concat([1,2,3]));//a,b,c,d,1,2,3
alert(arr);//a,b,c,d

11、join()将数组中的每一个元素用指定的字符串连接起来，返回字符串.

//join（）把数组转换为字符串类型
var arr=[1,2,3,4,5,6];
alert(arr.join('-'));//1-2-3-4-5-6 

12、map()(指映射)对数组中的每一项运行函数，返回函数运行结果组成的数组，函数的参数是一个函数，而该函数接收三个参数：数组当前值，数组索引、数组.

//咱们可以用平方根给它举个例子
var arr=[1,2,3,4];
//alert(arr.map(Math.sqrt));//这个也是平方
//alert(arr.map(function(x){
               //相当于x的平方
                return x * x;
              }));  //返回1,4,9,16

13、reduce()从数组的第一项开始，逐个遍历到最后，函数接受两个参数，一个是在数组上调用的函数和归并的初始值（可选），而调用数组的函数.接受四个参数：前一个值、当前值、当前值索引、当前数组，第一次调用时，前一个值是数组第一项，当前值是数组第二项.

var arr=[1,2,3,4,5,6];
var result = arr.reduce(function(prev,cur,index,array){
             return prev+cur
                })
alert(result);//返回21(就是他们相加)

14、filter()对数组中的每一项运行函数，返回该函数返回true的元素组成的数组.

var arr = [1,-3,2,-4,-6,0];
var newArr = arr.filter(function(x){
              if(x>=0){
                   return true;
              }else{
                  return false;
              }
})
alert(newArr)//返回1,2,0

15、toString()将当前对象以字符串的形式返回.

var arr = ['1','2'];
alert(arr.toString());//返回1,2
alert(typeof arr.toString());//string

16、valueOf()调用该方法返回的依旧是数组.

var arr = [1,2];
alert(arr.valueOf());//alert返回的都是字符串，故返回1,2，而arr.valueOf()是数组.
//之前判断类型都是typeof，像Array判断类型只会输出object，而instanceof就不是，他会判断是不是数组.
alert(arr.valueOf() instanceof Array);//返回true
alert(typeof arr.valueOf());//object

17、toLocaleString()方法可根据本地时间把 Date对象转换为字符串，并返回结果.

var born = new Date("July 21, 1983 01:15:00")
document.write(born.toLocaleString());//1983/7/21 上午1:15:00

18、forEach()对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值.参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身.

var arr = [1, 2, 3, 4, 5];
arr.forEach(function(x, index, a){
console.log(x + '|' + index + '|' + (a === arr));
});
// 输出为：
// 1|0|true
// 2|1|true
// 3|2|true
// 4|3|true
// 5|4|true

19、filter()：判断一个数组的元素，与给出的值做一个比较，符合条件作出筛选（必须的定义函数）

var ages1=[23,34,56,66,888];
function cha1(age1){
       if(age1>=34){
              return age1;
       }   
}    
document.write(ages1.filter(cha1));            

20、every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;
}); 
console.log(arr2); //true
var arr3 = arr.every(function(x) {
return x < 3;
}); 
console.log(arr3); // false 

21、some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
return x < 3;
}); 
console.log(arr2); //true
var arr3 = arr.some(function(x) {
return x < 1;
}); 
console.log(arr3); // false

22、reduce()和 reduceRight()　

　　[reduce()接受一个函数作为累加器，数组中每个值（从左到右）开始缩减，最中计算为一个值。total的初始值=数组的初始值]

　　这两个方法都会实现迭代数组的所有项，然后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后。而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。

　　这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。

　　传给 reduce()和 reduceRight()的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。

 　　下面代码用reduce()实现数组求和，数组一开始加了一个初始值10。

var values = [1,2,3,4,5];
var sum = values.reduceRight(function(prev, cur, index, array){
return prev + cur;
},10);
console.log(sum); //25

这里我们可以接触一下：

获取数组最大值与最小值：

var array=[1,222,32,4];
alert(Math.max.apply(null,array)); //222
alert(Math.min.apply(null,array)); //1