JavaScript中的数组

JavaScript中的数组相当奇葩，有这么几点特殊性：

1. 同一个数组中的不同元素可以是任意类型
2. 数组长度是动态的，根据需要会增长或缩减
3. 数组可以是稀疏的，即元素的索引可以不连续，中间有空缺
4. 数组是对象的特殊形式，数组的索引可以作为对象的属性名使用
5. 数组不会越界，试图访问一个不存在的索引时，得到的是undefined

数组的简单使用

我们可以通过数组直接量来创建数组，一对方括号，中间是多个数组元素，之间用逗号隔开

var array0 = []                                         //创建空数组var array1 = [1 , 2 , 3]                                //创建一个包含多个数字的数组var array2 = ['a' , 'b' , 'c'];                         //创建一个包含多个字符串的数组var array3 = [1,2,'a',{m : 'hello' , n : 'world'}]      //创建一个包含多种类型的数组

通过索引下标来访问数组中的元素

array1[1]       //2array2[0]       //"a"array3[3].m     //"hello"array3[3].n     //"world"//向数组中写入值array1[0] = 100array1[0]       //100array1[23]      //undefined//获取数组的属性array2.length   //3

理解数组的length属性

数组的length属性可以获取或设置数组的长度，它包含两个行为，

1. 当为一个数组元素赋值，如果它的索引值大于或等于当前数组长度时，则将length值设置为index+1
2. 将数组的length属性设置为一个小于当前长度的非负整数时，当前数组中索引大于或等于该值得元素将被移除

先来看第一个例子

var array4 = [1,2,3]array4.length                   //初始长度为3array4[6] = 6                   //向一个较大的索引出赋值，此时数组将变为稀疏数组array4.length                   //7

接着往下写

array4.length=2                 //将数组的length属性设置为一个小于当前长度的非负整数array4                          //此时数组的值为[1, 2]，索引值大于或等于2的元素被移除了数组

数组常用的方法

var a = ['hello','world','js']          //初始化一个数组

join()方法

使用join()方法将所有元素拼接成一个字符串。可以指定拼接符号，默认为逗号(,)

a.join()                                //返回"hello,world,js"a.join('-')                             //返回"hello-world-js"

split()方法

字符串的split()方法是join()方法的逆向操作，split()方法将字符串按照特定字符拆分成数组

"hello-world-js".split('-')             //返回["hello", "world", "js"]

reverse()方法

reverse()方法返回逆序的数组，直接在原来的数组上重新排序，原数组会被修改

a.reverse()                     //返回["js", "world", "hello"]，此时数组a的值也是["js", "world", "hello"]

sort()方法

sort()方法将数组中的元素排序后返回，原数组会被修改。如果sort()方法不加参数的话，默认会按照字母表顺序排列，如果参数为一个排序算法的话则按照指定的算法来排序，

a.sort()                        //返回["hello", "js", "world"]，此时数组a的值也是["hello", "js", "world"]var a2 = [1,22,333,44]          //创建一个新数组a2.sort()                       //sort()方法默认会按照字母顺序来排序，结果为[1, 22, 333, 44]//下面通过指定一个排序算法，按照数字大小来排序a2.sort(function(a,b){    return a > b})//结果为：[1, 22, 44, 333]

concat()方法

concat()方法创建并返回一个新数组，它的元素包括调用concat()方法的原始数组和concat()方法的每一个参数，如果参数是数组，则连接的是数组中的元素，而不是参数数组本身，但concat()方法不递归参数中的嵌套数组。

["hello", "js", "world"].concat('javascript','python')      //结果是["hello", "js", "world", "javascript", "python"]["hello", "js", "world"].concat('nodejs',['ruby','swift'])  //结果是["hello", "js", "world", "nodejs", "ruby", "swift"]

slice()方法

slice(startIndex,endIndex)方法返回该数组的子数组，类似string.subString()方法。两个参数指定了子数组的起始和结束位置，子数组包含起始位置而不包含结束位置。如果只指定一个参数，则将它作为开始为止，返回从该位置到数组结束的所有元素。如果参数包含负数，则从后往前数。

var array = [1,2,3,4,5]array.slice(0,3)            //[1, 2, 3]array.slice(3)              //[4, 5]array.slice(1,-1)           //[2, 3, 4]

splice()方法

splice()方法是在数组中进行插入和删除的通用方法，它会在原来的数组上进行插入和删除，然后重新调整索引值，该方法执行完以后，改动的部分仍然是连续的。
先说删除功能。splice()的第一个参数是删除和插入的起始位置，第二个参数是删除的个数。如果省略第二个参数，则起始位置之后的所有元素将被移除。splice()方法返回由被删除的元素组成新数组，如果没有删除任何元素，则返回空数组。
再说插入功能。splice()方法的第三个及其以后的所有元素都会被插入到数组中，插入位置是第一个参数指定的位置（同删除位置）。

var a=[1, 2, 3, 4, 5, 6, 7, 8]a.splice(3,1)           //返回[4]，此时a是[1, 2, 3, 5, 6, 7, 8]var a=[1, 2, 3, 4, 5, 6, 7, 8]  a.splice(4)         //返回[5, 6, 7, 8]，此时a是[1, 2, 3, 4]var a=[1, 2, 3, 4, 5, 6, 7, 8]  a.splice(2,1,'a','b',['c','d']) //从位置2删除1个元素，然后把后面所有的参数从位置2插入数组//返回[3]，此时a是[1, 2, "a", "b", ["c", "d"], 4, 5, 6, 7, 8]

push()和pop()方法

push()和pop()方法允许将数组当成栈来使用，push()方法向数组尾部插入一个元素并返回数组的新长度，pop()方法从数组尾部删除一个元素并返回该元素。两个方法都会修改原数组。

var a= [1, 2, 3, 4, 5]a.push(6)               //返回6（数组长度），此时a为[1, 2, 3, 4, 5, 6]a.push(8)               //返回7（数组长度），此时a为[1, 2, 3, 4, 5, 6, 8]a.pop()                 //返回8（删除的元素），此时a为[1, 2, 3, 4, 5, 6]a.pop()                 //返回6（删除的元素），此时a为[1, 2, 3, 4, 5]

unshift()和shift()方法

unshift()和shift()方法的行为非常类似push()和pop()，不一样的是unshift()和shift()是在数组的头部而非尾部进行操作的。unshift()方法在数组的头部插入一个元素，并调整所有已存在的元素的索引，然后返回数组的新长度。shift()方法删除第一个元素，并调整所有剩余元素的索引，然后返回删除的元素。

ECMAScript5中的数组方法

ECMAScript5中一共定义了9个新的方法，主要是用来封装一些遍历、映射、过滤等操作。

forEach()方法

forEach()方法从头到尾遍历数组，为每个元素调用指定的函数，该函数作为forEach()方法的参数。该函数具有三个参数，分别是：数组元素，数组的索引，数组本身。forEach()方法设计时没有提供终止循环的简单方式。

var array = [1, 2, 3, 4, 5]array.forEach(function(e,i,a){    a[i]++ ;})//数组中的每个元素+1，此时array的值为[2, 3, 4, 5, 6]

map()方法

map()方法将调用的数组中的每个元素依次传递给指定的函数，该函数会返回一个值，map()方法的返回值是由指定的函数的返回值组成的数组。

var a = [1, 2, 3, 4, 5]var b = a.map(function(e){return e * e;})       //b为[1, 4, 9, 16, 25]

filter()方法

filter()方法返回该数组的一个子集，每个元素是否返回，由filter()方法的函数决定，该函数如果返回true，则该元素就位于子集中。

var a= [1, 2, 3, 4, 5]a.filter(function(e){return e <= 3 })       //返回[1, 2, 3]

every()和some()方法

every()和some()方法对数组做逻辑判断，判断的逻辑由every()和some()的参数（一个函数）的返回值决定，

• every()方法：如果每个元素调用该函数后都返回true，则every()方法返回true，任意一个元素调用函数后返回false，则遍历就终止了，并返回false。
• some()方法：一旦有一个元素调用该函数后返回true，some()方法就会终止遍历，并返回true，否则，继续遍历下一个元素直至返回true。如果所有的元素调用函数后都返回false，则some()方法返回false。

var a= [1, 2, 3, 4, 5]a.every(function(e){return e <= 2})     //并不是所有元素都小于等于2，所以返回falsea.some(function(e){return e <= 2})      //存在小于等于2的元素，所以返回true

reduce()和reduceRight()方法

reduce()和reduceRight()方法的功能类似于折叠数组，意思就是说，定义一个函数作为参数，该函数接受两个参数，第一个参数是上次该函数计算的结果，第二个参数是数组中的某个元素，返回值是本次计算的结果。先来看个例子

var a= [1, 2, 3, 4, 5]a.reduce(function(x,y){    console.log('x='+x+',y='+y);     return x+y ;     },0)

上面的程序最终的返回值是15，下面是输出的日志

x=0,y=1x=1,y=2x=3,y=3x=6,y=4x=10,y=5

数组中一共有五个元素，日志说明了reduce()函数进行了五次运算，在进行第一次运算时，由于还没有上次计算的结果，就使用recude()方法的第二个参数作为上次计算的结果，这是一个默认值，本次计算后返回1，1就作为了下次计算的第一个参数，然后返回3，3再作为下次计算的第一个参数。。。。。。直到所有的参数都被计算了一遍为止，最后返回最终的计算结果。

reduceRight()的计算方式和reduce()方法非常相似，只是遍历元素时索引是从大到小。

var a= [1, 2, 3, 4, 5]a.reduceRight(function(x,y){    console.log('x='+x+',y='+y);     return x+y ;     },0)

对该数组调用reduceRight()时还用上面的函数，返回值还是15，看一下输入的日志

x=0,y=5x=5,y=4x=9,y=3x=12,y=2x=14,y=1

日志说明了遍历数组来计算的顺序是逆序的。

indexOf()和lastIndexOf()方法

indexOf()和lastIndexOf()方法在数组中搜索具有给定值得索引，indexOf()方法是从头到尾搜索，lastIndexOf()方法从尾至头搜索，如果没有搜索到，则都返回-1。indexOf()和lastIndexOf()方法还可以接收第二个参数，它指定了开始搜索的索引，如果该参数为负数，则表示与末尾元素的偏移量。

a = [1, 2, 3, 2, 1]a.indexOf(2)            //返回1a.lastIndexOf(2)        //返回3

关于数组的常见用法就写到这里