JavaScript数组

 JavaScript的数组更像是将很多东西混合在一起的结果。传统的程序设计语言中，数组内的元素需要具有相同的数据类型，而作为弱类型的JavaScript,则没有这个限制，JavaScript的同一个数组中，可以有各种完全不同类型的元素。

方法：

concat()              连接两个或更多的数组，并返回结果

join()                  把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔

pop()                   删除并返回数组的最后一个元素。

push()                向数组的末尾添加一个或更多元素，并返回新的长度

reverse()            颠倒数组中元素的顺序

shift()                  删除并返回数组的第一个元素

slice()                 从某个已有的数组返回选定的元素

sort()                 对数组的元素进行排序

splice()             删除元素，并向数组添加新元素

unshift()             向数组的开头添加一个或更多元素，并返回新的长度。

valueOf()            返回数组对象的原始值

JavaScript的数组对象比较复杂，包含有pop,push等类似与栈的操作，又有slice,reverse,sort这样类似与列表的操作。

或许正如此，JavaScript中的数组的功能非常强大

1.数组的特性

   最常用的属性为length,length表示当前数组的长度

var array =new Array(1,2,3,4,5);

print(array.length);

array.length=3;

print(array.length);

5

3

对lenght属性的修改会使得数组后边的元素变得不可用(如果修改后的length比数组实际的长度小的话)，所以可以通过设置length属性来将数组元素裁剪。

另一个与其他语言的数组不同的是，字符串也可以作为数组的下标(实际上，在JavaScript的数组中，数字下标最终会被解释器转化为字符串，也就是说，所谓的数字下标只不过是看着像数字而实际上是字符的属性名)，比如：

var stack = new Array();

stack['first']=3.14;

stack["second"]="okay then";

stack['third'] = new Date();

for(var item in stack){

  print(typeof stack[item]);

}

运行结果为：

number

string

object

2.使用数组

数组的创建方式:

var array =new Array();

var array= new Array(10);   //长度

var  array=new Array("apple","borland","cisco");

不过运用最多的为字面量方式来创建，

var array =[];

var array=["one","two","three","four"];

向数组中添加元素：

var array=[];

array.push(1);

array.push(2);

array.push(3);

array.push("four");

array.push("five");

array.push(3.1415);

joind,连接数组元素为一个字符串：

array = ["one","two","three","four","five"];

var str1 = array.join(",");

var str2 =array.join("|");

print(str1);

print(str2);

运行结果如下：

one,two,three,four,five

one|two|three|four|five

连接多个数组为一个数组：

 

var another=["this","is","anther","array"];

var another2 = ["yet","another","array"];

var bigArray =array.concat(another,another2);

从数组中取出一定数量的元素，不影响数组本身:

print(bigArray,slice(5,9));

slice方法的第一个参数为其实位置，第二个参数为终止位置，操作不影响数组本身。

bigArray.splice(5,2);

bigArray.splice(5,0,"very","new","item","here");

第一行代码表示，从bigArray数组中，从第5个元素起，删除2个元素；而第二行代码表示，从第5哥元素起，删除0个元素，并把随后的所有参数插入到从第5个开始的位置。

sort()将数组按字母顺序排序，排序过程会影响源数组。

sort不关注数组中的内容是数字还是字母，他仅仅是按照字母的字典序来进行排序，对于这种情况，JavaScript提供了另一种途径，通过给sort函数传递一个函数对象，按照这个函数提供的规则对数组进行排序。

function sorter(a,b) {

      return a-b;

      }

var array= [10,23,44,58,106,235];

array.sort(sorter);

print(array);

函数sorter接受两个参数，返回一个数值，如果这个值大于0，则说明第一个参数大于第二个参数，如果返回值为0，说明两个参数相等，返回值小于0，则第一个参数小于第二个参数，sort根据这个返回值来进行最终的排序：

array,sort(function(a,b){  return a-b;});  //正序

array.sort(function(a,b){ return b-a;});  //逆序

删除数组元素

来自于jQuery的设计：

Array.prototype.remove=function(from,to){

       var rest = this.slice((to||from)+1||this.length);

       this.length=from<0?this.length + from :from;

        return this.push.apply(this,rest);

     }

     remove接受两个参数，第一个参数为其实下标，第二个参数为结束下标，其中第二个参数可以忽略，这种情况下会删除指定下表的元素。当然，不是每个人都希望影响整个原形链，

    Array.remove = function(array,from,to) {

       var rest  =array.slice((to||from)+1||array.length);

       array.length = from <0? array.length + from :from;

       return array.push.apply(array,rest);

       };

其操作方式与前者并无二致，但是不影响全局对象，代价是你需要显式的传递需要操作的数组作为第一个参数：

var array= ["one","two,"three","four"];

Array.remove(array,0,2);    //删除0,1,2三个元素

print(array);

这种方式相当于JavaScript内置的Array添加了一个静态方法。

3.  遍历数组

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

for(var item in array) {

     print(array[item]);

     }

但是这种方式并不总是有效，比如我们扩展了内置对象Array,如下：

Array.prototype.useless =function(){ }

执行上边的代码，会得到这样的输出：

1

2

3

4

function() {  }

如果你对数组的遍历做sum操作，那么会得到一个莫名其妙的错误，毕竟函数对象不能做求和操作。

因此，我们可以采用另一种遍历方式

for(var i =0,len = array,length; i<len; i++)

     {

       print(array[I]);

       }

    这种for循环如其他很多语言中的写法一致，重要的是，他不会访问那些下标不是数字的元素，如上例中的unction

  。从此也可以看出，除非必要，尽量不要对全局对象进行扩展，因为对全局对象的扩展会造成所有继承链上都带上“烙印”，

   从未导致未知的bug