JavaScript-数组基础

数组实际上就是来源对象，脱胎于对象，继承于对象

数组对象是使用单独的变量名来存储一系列的值。

数组：字面意思上是一组数据，一组（一般情况下相同类型的）的数据（不一定都是数字）。
【注】数组是一种数据类型
【注】数组的作用是：使用单独的变量来存储一系列的值。

创建方式：

　　　　常规方式：

1 var  arr=new Array();
2 arr[0]="Bool";
3 arr[1]="Str";
4 arr[2]="Cent";

　　　　简洁方式：

1 var arr=new Array("Bool","Str","Cent");

　　　　字面量方式：

1 var arr=["Bool","Str","Cent"];

在对象中属性名填入任何内容都会隐式转换为字符

在数组中所有的下标都会转换为number

如果不能转换为number的（也就是转换后是NaN的），就会默认添加对象的属性名

数组的长度，仅记录下标的个数，不包含属性数量

数组不可以使用点语法获取下标变量，但是可以使用点语法取属性

数组属性及方法：

1、数组的长度 arr.length访问数组的个数

【注】length属性，不是只读的，可以设置的。

1 var arr = ["red", "blue", "pink"];
2 arr.length = 2;
3 console.log(arr);

2、数组的遍历

数组元素的访问和赋值，都是通过数组的下标完成
【注】下标就是索引，即元素的序号，从0开始，下标最大取值是：数组的长度（length）-1。
【注】下标可以是变量或者表达式。

1 var arr = [10,20,30,40,50];
2 console.log(arr[1+2]);

3、for循环

以下为通过循环给数组的每个元素赋值，赋成下标的平方。

1 var arr = [];
2 for(var i = 0; i < 10; i++){
3     arr[i] = i * i;
4 }
5 alert(arr);
6 //0,1,4,9,16,25,36,49,64,81

4、for in 遍历

快速遍历将数组中每一个元素从头到尾进行遍历

【注】forin效率要比for循环的效率高。

1 var arr = ["red", "blue", "pink"];
2 for(var i in arr){
3     document.write(arr[i] + "<br />");
4 }
5 alert(arr);
6 //red blue pink

5、push 在数组尾部添加一个或者多个元素，并且返回数组的新长度

1 var arr=[1,2,3,4,5];
2 arr.push(6);//在数组的尾部插入一个新元素
3 arr.push(6,7,8);//在数组的尾部插入多个新元素
4 var a=arr.push(6,7,8);//通过添加到尾部元素后返回数组的新长度
5 console.log(arr);

6、pop 删除数组尾部的最后一个元素，并且将这个被删除的元素返回

1 var arr=[1,2,3,4,5];
2 arr.pop();//pop中没有参数,删除数组的最尾部一个元素
3 var a=arr.pop();//pop删除数组的最尾部一个元素，并且将被删除的元素返回
4 console.log(arr,a);
5 
6 arr.length--; //等同 速度更快，但是不会返回被删除的元素
7 arr.pop();//速度慢，但是会返回被删除的元素
8 console.log(arr);

7、unshift 在数组头部添加一个或者多个元素，并且返回数组的新长度

1 var arr=[1,2,3,4,5];
2 arr.unshift(0);//在数组的头部插入一个新元素
3 arr.unshift(-3,-2,-1,0);//在数组的头部插入多个新元素
4 var a=arr.unshift(-3,-2,-1,0);//返回数组的新长度
5 console.log(arr);

8、shift 删除数组的第一个元素，并且返回被删除的元素

1 var arr=[1,2,3,4,5];
2 arr.shift();//将数组的第一个元素删除
3 var a=arr.shift();//将数组的第一个元素删除，并且返回这个被删除的元素
4 console.log(arr);

不管删除还是添加都会改变数组的长度.

9、concat 数组的合并，合并后会返回一个新数组，原来的两个数组不会变化

 1 var arr=[1,2,3,4];
 2 var arr1=[5,6,7,8];
 3 var arr2=arr.concat(arr1);
 4 // 数组除了可以合并数组，也可以合并元素，将多个元素与原数组合并，返回新数组
 5 var arr3=arr.concat(0,-1,-2);
 6 // concat既可以合并元素，也可以合并数组
 7 var arr4=arr.concat(0,arr1,["A","B"]);
 8 // 如果直接使用concat，就可以完成数组的复制功能
 9 var arr5=arr.concat();
10 console.log(arr5);

10、join 就是将数组的每个元素以指定的字符连接形成新字符串返回

var  arr=[1,2,3,4,5];
// 将数组合并为字符串返回，默认使用,连接
var str=arr.join();
// 在这里join的参数是字符串的连接符
var str=arr.join("|");
// ""作为连接符，会将数组元素首尾相连成为字符串
var str=arr.join("");
console.log(str);

1 //toString直接将数组转换为字符串
2 var arr=[1,2,3,4,5];
3 var str=arr.toString();
4 console.log(str);

11、splice

这个方法可以从指定的位置删除给定数量的元素，并且在这个位置插入需要的元素，并且返回被删除的元素组成的新数组

arr.splice(从什么位置开始,删除多少个元素,要插入的元素);

 1 //插入，删除，替换
 2 var arr=[1,2,3,4,5];
 3 没有任何参数时,返回一个空数组
 4 var arr1=arr.splice();
 5 // 第一个参数是0，表示从第0位开始，第二个参数删除多少个没有填，意味着删除到尾部
 6 var arr1=arr.splice(0);//将所有数据转移到新数组
 7 // 从第0位开始删除3个元素，返回到新数组arr1
 8 var arr1=arr.splice(0,3);
 9 // 从第几位开始可以是负数，从后向前数（倒数）,因为没有给要删除的数量，因此删除到尾部
10 var arr1=arr.splice(-2);
11 // 从数组的第0位开始，删除1个元素，并且在这个位置插入一个元素 -1,替换
12 var arr1=arr.splice(0,1,-1);
13 // 数组的最后一位替换位0
14 var arr1=arr.splice(-1,1,0);
15 // 将数组中第二位开始两位元素替换为10，11
16 var arr1=arr.splice(2,2,10,11);
17 // 在数组的第二位插入一个元素 -1
18 arr.splice(2,0,-1);
19 arr.splice(2,0,-1,-2,-3,-4);
20 console.log(arr);

12、slice 按指定位置截取复制数组的内容

 1 var arr=[1,2,3,4,,5,6,7];
 2 // 从第1位开始截取到第4位之前
 3 // 只能从前向后截取
 4 arr.slice(从什么位置开始，到什么位置之前结束)
 5 // 第二个参数不写，默认截取到尾部
 6 var arr1=arr.slice(1,4);
 7 console.log(arr1,arr);
 8 
 9 var arr1=arr.slice();//复制数组arr    
10 var arr1=arr.slice(0); //复制数组
11 var arr1=arr.slice(3);//从第三位截取到尾部复制
12 var arr1=arr.slice(-2);//从倒数第二位开始截取到尾部
13 var arr1=arr.slice(-3,-1);//从倒数第三位到倒数第一位
14 console.log(arr1);

13、indexOf

数组.indexOf(要查询得元素,从什么位置开始查询) 位置就是下标

1 var arr=[1,2,3,4,5,6];
2  for(var i=0;i<arr.length;i++){
3             if(arr[i]===4){
4                 console.log("aaa");
5             }
6         } 
7 // 在数组中查找元素4，如果查找到，返回该元素所在的下标，如果没有查找到，则返回-1
8 var  index=arr.indexOf(4);
9 console.log(index);

14、lastIndexOf 从后向前查找

lastIndexOf(查找得元素，从什么位置开始查找)

1 var arr=[1,3,1,2,3,5,2,3,4,6];
2 var index=arr.lastIndexOf(3);
3 console.log(index);

//去重
var arr=[1,3,1,2,3,5,2,3,4,6];
var arr1=[];
for(var i=0;i<arr.length;i++){
      if(arr1.indexOf(arr[i])===-1){
         arr1.push(arr[i]);
    }
}
console.log(arr1);

15、forEach

arr.forEach(function(数组中的元素，每个元素对应的下标，数组自身){

})

forEach没有返回值

1 var arr=[1,2,3,5,6,7,8,9];
2 arr.forEach(function(a,b,c){
3             console.log(a,b,c);
4 });

16、map 会返回一个与原数组长度相等的新数组

1 var arr=[3,5,7,9,1,2,4];
2 var arr2=arr.map(function(item,index,arr){
3     console.log(item,index,arr);
4 // 在map中使用return 就是在对应的下标中添加对应的数据
5     return "a";
6     return item+10;
7 });
8 console.log(arr2);

17、sort

arr.sort(function(后一项,前一项){})

1 var arr=[0,1,4,2,7,2,5,8,10,4,5,7,3,8,9];
2 arr.sort(function(a,b){
3      // console.log(a,b);
4       //return  a-b  从小到大    
5       //return  b-a 从大到小     
6      //    仅适用于数值
7       return a-b;
8 })
9 console.log(arr);

18、some

查找数组中是否有满足条件的元素，如果有就返回true，如果没有就返回false

遍历数组，如果有一个满足条件的元素，都会直接返回true，不继续向后遍历

1 var arr=[1,4,6,2,7,9,0];
2 var bool=arr.some(function(item,index,arr){
3      return item>5;
4 });
5 console.log(bool);

 1 //桥接模式
 2 function somes(arr,fn){
 3         // fn就是回调函数
 4       for(var i=0;i<arr.length;i++){
 5           var bool=fn(arr[i],i,arr);
 6            if(bool) return true;
 7       }
 8       return false;
 9 }
10 var b=somes(arr,abc);
11 function abc(item,index,arr){
12       return item>5;
13 }
14 console.log(b);

19、every

判断数组中是否每一个都满足条件，如果有一个不满足条件，直接跳出，否则的话所有都满足时返回为ture

1 var arr=[1,4,6,2,7,9,0];
2 var bool=arr.every(function(item,index,arr){
3        return item>2;
4 });
5 console.log(bool);

20、filter 过滤

var arr1=arr.filter(function(item,index,arr){

返回条件

});

筛选数组中满足条件的结果

1 var arr=[1,3,4,7,3,5,8,9];
2 var arr1=arr.filter(function(item,index,arr){
3       return item>5;
4 });
5 console.log(arr1);

21、reduce 归并

数组.reduce(回调函数(累积值,元素,下标,数组){},初始值)

如果reduce没有设置初始值，累计值是数组的第0位元素，遍历从下标1开始

如果reduce设置了初始值，累积值就是从这个初始值开始，遍历从下标0开始

 1 var arr=[10,3,4,7,3,5,8,9];
 2 // 从数组的第1位开始遍历，第0位没有遍历，下标从1开始
 3 // 刚开始value是数组的第0项，后面每次value都是undefined
 4 // 如果在函数中使用return 就会将返回值在下次数组的遍历中赋予value
 5 arr.reduce(function(value,item,index,arr){
 6     // 循环的次数是数组的个数-1
 7     // value就是上次遍历return的值，第0次遍历时（最开始时是数组的第0项）
 8     console.log(value);
 9      return value+1
10 }) 
11 
12 // 累积相加数组元素求和
13 // reduce返回的是一个值，就是遍历到最后一次return出来的值
14 var sum=arr.reduce(function(value,item){
15      return value+item;
16 });
17 console.log(sum);

原文地址：https://www.cnblogs.com/wyp-King/p/12772095.html