数组

一.数组的定义方式

a)字面量方式定义

var arr=[1,2,3,'lisi',false];

b)构造有内容的数组

var arr =new

Array(1,true,'hello',[1,2],{x:1});

c)构造有长度的数组

var arr = new Array(5);

数组长度:length属性可以获取数组长度；

arr.length

读取数组元素:通过下标来读取数组内容,下标从0开始,最后一个元素的下标是arr.length-1

添加数组元素:

var arr = [];

arr[0]=1;

arr[1]=2;

更改数组的元素:

arr[1]=3;

清空数组:

arr.length = 0;

3.数组的遍历

for(var i=0;i<=arr.length; i++){

console.log(arr[i]);

}

5.数组的引用类型

数组的类型是object(引用类型)对象类型

 

var a=[1,2,3];//a存放的是数组的首地址

var b=[1,2,3];

console.log(a == b);//flase

var c=b;//将b的值赋给变量c

console.log(b == c);//true

console.log(c[3]);//3

b[1]=12;

console.log(c[1]);//12

二.数组的常用方法

1.concat()

连接两个或多个数组，返回一个新的数组

语法:

var a = [1,2,3];

var b =[4,5,6];

//a连接b后的数组赋给变量c

var c= a.concat(b);

console.log(c);//[1,2,3,4,5,6]

2.join()

将数组元素拼接为字符串并返回，不会改变原数组

语法:

var arr = [1,2,3];

var str = arr .join();

console.log(str);//1,2,3

var str1=arr.join('#');

console.log(str1);//1#2#3

3.pop()

删除数组的最后一个元素，返回这个被删除的元 素，如果数组为空，返回未定义

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

console.log(arr.pop());//4

console.log(arr);//[1,2,3]

4.push()

将一个或多个元素添加到数组的尾部，并返回数组的长度

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

console.log(arr.push(6,7));//6

console.log(arr);//(1,2,3,4,6,7);

5.shift()

删除数组的第一个元素,并返回这个删除的的元素，数组的其他元素前移

6.unshift()

将一个或多个元素添加到数组的开始,数组其他元素自动后移，返回数组的长度.

7.reverse()

反转数组元素,前后逆转

9.slice(start,end)

返回一个新数组,不会改变原来的数组

start:

end:截取的结束位置

从0开始,包括start,不包括end

语法:

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

console.log(arr.slice(2,5));//[3,4,5]

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

1) 如果开始是NaN,那就从0开始算

2）如果只有一个参数，这个参数作为开始，直到结束

3）如果结束超过范围，从开始到结束

4）如果都是负数，倒着数

5）如果结束比开始小，得到空数组

10.splice(开始位置，删除长度，插入的元素)

1）两个参数

从开始位置根据删除长度删除元素。然后返回删除的元素(包括开始位置),后边的自动前移

语法:

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

console.log(arr.splice(2,3));//[3,4,5]

console.log(arr);//[1,2,6,7]

2)三个参数

从开始位置根据删除长度删除元素并且添加元素到删除的位置(可添加一个或多个)，然后返回被删除的元素。

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

console.log(arr.splice(2,3,10,20));//[3,4,5]

console.log(arr);//[1,2,10,20,6,7]

3)如果删除的长度是0,只会在开始的位置插入元素,不会删除元素

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

console.log(arr.splice(2,0,10));//[]

console.log(arr);//[1,2,3,10,4,5,6,7]

11.sort()

对数组排序

1)如果数组内容是0-9的数字

var arr= [3,4,6,3,7,4,8,9,0];

var arr1=arr.sort();

console.log(arr1);//[0,3,3,4,4,6,7,8,9]

console.log(arr);//[0,3,3,4,4,6,7,8,9]

2)如果数字不是0-9之间,可以使用排序函数实现

var arr = [4,32,43,5,22,77,23];

console.log(arr.sort());//[22,23,32,4,43,5,77]

arr.sort(function(a,b){

//升序

return a-b;

//降序

return b-a;

});

3)如果是字母,将按照字母的编码进行排序

var arr=['e','p','a','f'];

console.log(

arr.sort());//['a','e','f','p']

4)使用sort方法对对象排序

var arr=[

{'name':'zhangsan','age':23},

{'name':'lisi','age':18},

{'name':'wang','age':27},

{'name':'zhao','age':72},

];

arr.sort(function(a,b){

 //按年龄升序

                return a.age - b.age;

                //按年龄降序

                return b.age - a.age;

})

12.冒泡排序

排序过程:

[6,94,15,88,55,76,39,21]

[6, 15, 88, 55, 76, 39, 21, 94]

[6, 15, 55, 76, 39, 21, 88, 94]

[6, 15, 55, 39, 21, 76, 88, 94]

[6, 15, 39, 21, 55, 76, 88, 94]

[6, 15, 21, 39, 55, 76, 88, 94]

[6, 15, 21, 39, 55, 76, 88, 94]

[6, 15, 21, 39, 55, 76, 88, 94]

[6, 15, 21, 39, 55, 76, 88, 94]

排序思想:

每一次对比相邻两个数的大小，小的在前，大的在后，如果前边的数据大于后边的数据就交换位置,依次向后比,需要两个循环嵌套，外层循环确定比较几轮，内层循环比较每一轮。

二.伪数组

1.什么是伪数组

像数组一样有length属性,也有0，1，2，3等下标，可以存放元素，但是不能调用数组的常用方法。

常见的伪数组：

arguments

getElementsByTagName

getElementsByClassName

上面三个获取的都是伪数组

将伪数组转为数组

var arr = [].slice.call(伪数组);

将伪数组转为数组赋给变量arr

三.数组方法

1.indexOf(数组项,开始查找位置)

查找数组项,返回索引位置,没找到返回-1

第二个参数为可选值,表示从这个位置开始找,返回的是第一个出现的下标,如果没有或者是NaN默认从0开始。

2.lastIndexOf(数组项,结束查找位置)

查找数组项，返回索引位置,没找到返回-1

第二个参数为可选值,表示结束查找的位置，返回最后一次出现的下标，如果第二个参数没写默认找到arr.length -1,如果是NaN则默认找到0