javascript之数组

       说到javascript的数组，也许很多人都会说，和C/C++、java等主流语言不一样吗，其实不然，C/C++、java等主流语言的数组是指一段连续的内存里存放了同一种数据类型这种数据结构，但是javascript却没有这样的数据结构。不过java提供了一种类似数组的数据结构，由于不是连续内存，所以读取的速度肯定没有真正的数组快，不过它使用起来也很方便，下面简单介绍一下数组。

定义

数组的定义很简单，不需要初始化，直接定义一个数组，并且可以随时添加：

> var arrayObject = [1, 2, 3, 4]
undefined
> arrayObject
[ 1, 2, 3, 4 ]

javascript数组可以很灵活的添加元素

> arrayObject[4]=5
5
> arrayObject
[ 1, 2, 3, 4, 5 ]
> arrayObject.p
arrayObject.propertyIsEnumerable  

arrayObject.pop                   arrayObject.push                  

> arrayObject.push(6)
6
> arrayObject
[ 1, 2, 3, 4, 5, 6 ]

可以直接通过下标添加元素，不过这里会有一个问题，如果这个下标值大于元素个数时，没有赋值的下标对应的值会是undefined：

> arrayObject
[ 1, 2, 3, 4, 5, 6 ]
> arrayObject
[ 1, 2, 3, 4, 5, 6 ]
> arrayObject[10] = 11
11
> arrayObject
[ 1, 2, 3, 4, 5, 6, , , , , 11 ]
> arrayObject[9]
undefined

不过javascript数组有个很神奇的东西，那就是它的元素可以不是一个类型：

> var arrayObject = [1, 2, 3, "aaa", 4]
undefined
> arrayObject
[ 1, 2, 3, 'aaa', 4 ]

这个特性会让数组很好用，但是好用的背后也有一定的风险，就是每个元素都要检查它的类型，否则可能会出现问题。

长度

直接调用数组的Length属性即可：

> var arrayObject = [1, 2, 3, "aaa", 4]
undefined
> arrayObject
[ 1, 2, 3, 'aaa', 4 ]
> arrayObject.length
5

删除元素

用delete来删除对应下标下的元素：

> delete arrayObject[2]
true
> arrayObject
[ 1, 2, , 4, 5, 6, , , , , 11 ]

可以看出来，delete之后，下标对应的元素值就变为undefined了，所以一般删除元素都用splice:

> arrayObject
[ 1, 2, , 4, 5, 6, , , , , 11 ]
> arrayObject.splice(2,2)
[ , 4 ]
> arrayObject
[ 1, 2, 5, 6, , , , , 11 ]

类型

数组在javascript里到底是个什么对象呢？

> arrayObject
[ 1, 2, 5, 6, , , , , 11 ]
> typeof arrayObject
'object'

为什么不是Array对象呢？那么我们通过什么来判断一个object是一个数组呢，肯定有办法的：

> typeof arrayObject === 'object' && arrayObject.constructor === Array
true

总的来说javascript中的数组是很好用的，不过有些特性要小心些。

javascript数组的一些方法介绍：

arrayObject.concat(item...)

这个方法的用途是复制和arrayObject一样的数组出来，如果方法里有参数，就会把这个参数附加到新的数组后面，如果这个参数是个数组，会把这个参数数组的元素附加到新的数组后面，举个例子：

> var arrayObject = [1, 2, 3, 4]
undefined
> var tmp = arrayObject.concat()
undefined
> tmp
[ 1, 2, 3, 4 ]
> var tmp = arrayObject.concat(1)
undefined
> tmp
[ 1, 2, 3, 4, 1 ]
> var tmp = arrayObject.concat([5,6,7])
undefined
> tmp
[ 1, 2, 3, 4, 5, 6, 7 ]

要注意一个地方，那就是这个复制是浅复制，为什么这样说呢？我们举个例子：

> var arrayObject = [1, 2, value, 4]
undefined
> var tmp = arrayObject.concat()
undefined
> tmp
[ 1, 2, { key: 1 }, 4 ]
> value.key = 2
2
> tmp
[ 1, 2, { key: 2 }, 4 ]

原数组如果存放的是对象，非数字和字符串，在对象的改变之后，复制之后的数组也会改变，这是值得注意的地方。

arrayObject.join(separator)

有过编程经验的人都知道，join就是把数组的元素逐个以separator连接起来：

> var arrayObject = [1, 2, 3, 4]
undefined
> arrayObject.join(',')
'1,2,3,4'

arrayObject.pop和 arrayObject.push(item...)

看看命名就知道这两个方法可以让数组像栈一样使用，这里就不举例子。

arrayObject.reverse()

reverse方法会对数组的元素进行反转，调用之后返回反转之后的数组，并且数组本身也会被反转：

> arrayObject
[ 1, 2, 3, 4 ]
> arrayObject.reverse()
[ 4, 3, 2, 1 ]
> arrayObject
[ 4, 3, 2, 1 ]

arrayObject.shift()

shift这个方法会移除数组的第一个元素，并且返回这个元素值：

> arrayObject
[ 4, 3, 2, 1 ]
> arrayObject.shift()
4
> arrayObject
[ 3, 2, 1 ]

arrayObject.slice(start, end)

> var arrayObject = [1, 2, 3, 4]
undefined
> arrayObject.slice(1,3)
[ 2, 3 ]
> arrayObject.slice(-1,3)
[]

通过例子可以看出，slice方法会返回以start为下标到end下标的数组，如果start和end有一个为负值，就会返回空数组。如果end大于了数组的长度，返回的数据只会到数组最后一个元素，不会自动添加为undefined。

arrayObject.sort(compareBlock)

sort方法会对数组进行排序，如果没有跟参数，默认会进行<的对比：

> var arrayObject = [3, 1, 2, 4]
undefined
> arrayObject.sort()
[ 1, 2, 3, 4 ]
> arrayObject
[ 1, 2, 3, 4 ]

如果数组里的元素是一些对象呢，没法<对比呢？那这个会得到不可预料的结果，所以不能直接用，但是sort方法支持传一个对比的代码块：

> arrayObject = [1, 2, 3, 4, 5, 6, 7, 8]
[ 1, 2, 3, 4, 5, 6, 7, 8 ]
> arrayObject.sort(function(a, b){return a+b - 4;})
[ 8, 7, 6, 5, 4, 1, 3, 2 ]

上面的排序很奇怪吧，实际上它是返回大于4的排在最前面，等于4的在中间，小于4的两个元素相加等于4排在最前面，最后才是4/2=2。

arrayObject.splice(start, deleteCount, items...)

看看参数名也知道，这个方法名会将以start为开始的deleteCount个元素移除并且以item做替换，如果items有多个值，就会逐个替换掉移除的元素。

> arrayObject = ['1', '3', '4', '5', '6', '7', '8', '9']
[ '1', '3', '4', '5', '6', '7', '8', '9' ]
> arrayObject.splice(2, 4, 'a', 'b', 'c')
[ '4', '5', '6', '7' ]
> arrayObject
[ '1', '3', 'a', 'b', 'c', '8', '9' ]

arrayObject.unshift(items...)

unshift很明显和shift是一对，它也和push类似，只是从数组的开始部分插入Items这些元素，并且返回新的数组的lenght:

> var arrayObject = ['1', '3', '4', '5', '6', '7', '8', '9']
undefined
> arrayObject.unshift('a', 'b')
10
> arrayObject
[ 'a', 'b', '1', '3', '4', '5', '6', '7', '8', '9' ]
> 

以上是数组比较常用的方法，就先介绍这么多吧。