JavaScript内核系列第5章数组

abruzzi

浏览: 449307 次
性别:
来自: 西安

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

计算机科学与技术

JavaScript 正则表达式 Apple REST Cisco

在这个例子里，还可以看到不同类型的数据是如何存储在同一个数组中的，这么做有一定的好处，但是在某些场合则可能形成不便，比如我们在函数一章中讨论过的sum函数，sum接受非显式的参数列表，使用这个函数，需要调用者必须为sum提供数字型的列表(当然，字符串无法做sum操作)。如果是强类型语言，则对sum传入字符串数组会被编译程序认为是非法的，而在JavaScript中，程序需要在运行时才能侦测到这一错误。

5.2使用数组

5.2.1 数组的基本方法使用

数组有这样几种方式来创建：

var array = new Array();
var array = new Array(10);//长度
var array = new Array("apple", "borland", "cisco");

不过，运用最多的为字面量方式来创建，如果第三章中的JSON那样，我们完全可以这样创建数组：

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.1415926);

前面提到过，JavaScript的数组有列表的性质，因此可以向其中push不同类型的元素，接上例：

var len = array.length;
for(var i = 0; i < len; i++){
    print(typeof array[i]);
}

结果为：

number
number
number
string
string
number

弹出数组中的元素：

for(var i = 0; i < len; i++){
    print(array.pop());
}
print(array.length);

运行结果如下，注意最后一个0是指array的长度为0，因为这时数组的内容已经全部弹出：

3.1415926
five
four
3
2
1
0

join，连接数组元素为一个字符串：

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", "another", "array"];
var another2 = ["yet", "another", "array"];
 
var bigArray = array.concat(another, another2);

结果为：

one,two,three,four,five,this,is,another,array,yet,another,array

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

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

结果为：

this,is,another,array

slice方法的第一个参数为起始位置，第二个参数为终止位置，操作不影响数组本身。下面我们来看splice方法，虽然这两个方法的拼写非常相似，但是功用则完全不同，事实上，splice是一个相当难用的方法：

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

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

one,two,three,four,five,very,new,item,here,another,array,yet,another,array

我们再来讨论下数组的排序，JavaScript的数组的排序函数sort将数组按字母顺序排序，排序过程会影响源数组，比如：

var array = ["Cisio", "Borland", "Apple", "Dell"];
print(array);
array.sort();
print(array);

执行结果为：

Cisio,Borland,Apple,Dell
Apple,Borland,Cisio,Dell

这种字母序的排序方式会造成一些非你所预期的小bug，比如：

var array = [10, 23, 44, 58, 106, 235];
array.sort();
print(array);

得到的结果为：

10,106,23,235,44,58

可以看到，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根据这个返回值来进行最终的排序：

10,23,44,58,106,235

当然，也可以简写成这样：

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

5.2.2 删除数组元素

虽然令人费解，但是JavaScript的数组对象上确实没有一个叫做delete或者remove的方法，这就使得我们需要自己扩展其数组对象。一般来说，我们可以扩展JavaScript解释器环境中内置的对象，这种方式的好处在于，扩展之后的对象可以适用于其后的任意场景，而不用每次都显式的声明。而这种做法的坏处在于，修改了内置对象，则可能产生一些难以预料的错误，比如遍历数组实例的时候，可能会产生令人费解的异常。

数组中的每个元素都是一个对象，那么，我们可以使用delete来删除元素吗？来看看下边这个小例子：

var array = ["one", "two","three","four"];
//数组中现在的内容为：
//one,two,three,four
//array.length == 4
delete array[2];

然后，我们再来看看这个数组的内容：

one, two, undefined, four
//array.length == 4

可以看到，delete只是将数组array的第三个位置上的元素删掉了，可是数组的长度没有改变，显然这个不是我们想要的结果，不过我们可以借助数组对象自身的slice方法来做到。一个比较好的实现，是来自于jQuery的设计者John Resig：

//Array Remove - By John Resig (MIT Licensed)
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);
};

这个函数扩展了JavaScript的内置对象Array，这样，我们以后的所有声明的数组都会自动的拥有remove能力，我们来看看这个方法的用法：

var array = ["one", "two", "three", "four", "five", "six"];
print(array);
array.remove(0);//删除第一个元素
print(array);
array.remove(-1);//删除倒数第一个元素
print(array);
array.remove(0,2);//删除数组中下标为0-2的元素(3个)
print(array);

会得到这样的结果：

one,two,three,four,five,six
two,three,four,five,six
two,three,four,five
five

也就是说，remove接受两个参数，第一个参数为起始下标，第二个参数为结束下标，其中第二个参数可以忽略，这种情况下会删除指定下标的元素。当然，不是每个人都希望影响整个原型链(原因在下一个小节里讨论)，因此可以考虑另一种方式：

//Array Remove - By John Resig (MIT Licensed)
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", "five", "six"];
Array.remove(array, 0, 2);//删除0, 1, 2三个元素
print(array);

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

5.2.3遍历数组

在对象与JSON这一章中，我们讨论了for…in这种遍历对象的方式，这种方式同样适用于数组，比如：

var array = [1, 2, 3, 4];
for(var item in array){
    print(array[item]);
}

将会打印：

1
2
3
4

但是这种方式并不总是有效，比如我们扩展了内置对象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循环如其他很多语言中的写法一致，重要的是，它不会访问哪些下标不是数字的元素，如上例中的function,这个function的下标为useless,是一个字符串。从这个例子我们可以看出，除非必要，尽量不要对全局对象进行扩展，因为对全局对象的扩展会造成所有继承链上都带上“烙印”，而有时候这些烙印会成为滋生bug的温床。

附：由于作者本身水平有限，文中难免有纰漏错误等，或者语言本身有不妥当之处，欢迎及时指正，提出建议，参与讨论，谢谢大家！

分享到：

JavaScript内核系列第6章正则表达式 | Swing小应用(Todo-List)之三

2010-04-24 15:17
浏览 4449
评论(48)
论坛回复 / 浏览 (47 / 20088)
分类:Web前端
查看更多

28 楼 jwtiger 2010-04-26

楼主不要操之过急慢工出细活出一章就要精一章保质保量才是王道

27 楼 abruzzi 2010-04-26

accphc 写道

发现数组是数组、链表、栈、HashMap的结合体

对，它就是这么一结合体。所以要单独开一章出来讨论。如果像传统的语言中，数组作为一个内嵌的数据结构存在的话，就简单多了，只需要说“JavaScript数组跟其他语言中的数组类似”即可，呵呵。

26 楼 accphc 2010-04-26

发现数组是数组、链表、栈、HashMap的结合体

25 楼 mengqingyu 2010-04-26

<div class="quote_title">abruzzi 写道</div>
<div class="quote_div">
<h2>
<a name="_Toc259883914">第五章 </a>数组 </h2>
JavaScript的数组也是一个比较有意思的主题，虽然名为数组(Array)，但是根据数组对象上的方法来看，更像是将很多东西混在在一起的结果。而传统的程序设计语言如C/Java中，数组内的元素需要具有相同的数据类型，而作为弱类型的JavaScript，则没有这个限制，事实上，JavaScript的同一个数组中，可以有各种完全不同类型的元素。
 
<table class="MsoNormalTable" style="border-collapse: collapse; border: none;" border="1" cellspacing="0" cellpadding="0"><tbody>
<tr>
<td style="width: 213.05pt; border-left: none; border-right: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
方法
</td>
<td style="width: 213.05pt; border-left: none; border-right: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
描述
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
concat() 
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
连接两个或更多的数组，并返回结果。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
join()
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
pop()
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
删除并返回数组的最后一个元素。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
push()
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
向数组的末尾添加一个或更多元素，并返回新的长度。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
reverse() 
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
颠倒数组中元素的顺序。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
shift()
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
删除并返回数组的第一个元素。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
slice()
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
从某个已有的数组返回选定的元素。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
sort()
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
对数组的元素进行排序。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
splice()
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
删除元素，并向数组添加新元素。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
unshift() 
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
向数组的开头添加一个或更多元素，并返回新的长度。
</td>
</tr>
<tr>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
valueOf() 
</td>
<td style="width: 213.05pt; border: none; padding: 0cm 5.4pt 0cm 5.4pt;" width="284" valign="top">
返回数组对象的原始值。
</td>
</tr>
</tbody></table>
 
可以看出，JavaScript的数组对象比较复杂，包含有pop,push等类似与栈的操作，又有slice， reverse，sort这样类似与列表的操作。或许正因为如此，JavaScript中的数组的功能非常强大。
<h3>
<a name="_Toc259883915">5.1</a>数组的特性 </h3>
数组包括一些属性和方法，其最常用的属性则为length，length表示数组的当前长度，与其他语言不同的是，这个变量并非只读属性，比如：
 













var array = new Array(1, 2, 3, 4, 5); print(array.length); array.length = 3; print(array.length); 
<pre></pre>

 
 
运行结果为：
 
 
<div class="quote_div">5 3 1,2,3</div>
 
注意到最后的print语句的结果是”1,2,3”，原因是对length属性的修改会使得数组后边的元素变得不可用(如果修改后的length比数组实际的长度小的话)，所以可以通过设置length属性来将数组元素裁减。
另一个与其他语言的数组不同的是，字符串也可以作为数组的下标(事实上，在JavaScript的数组中，数字下标最终会被解释器转化为字符串，也就是说，所谓的数字下标只不过是看着像数字而实际上是字符的属性名)，比如：
 













var stack = new Array(); stack['first'] = 3.1415926; stack['second'] = "okay then."; stack['third'] = new Date(); for(var item in stack){ print(typeof stack[item]); }
<pre></pre>

 
 
运行结果为：
 
 
<div class="quote_div">number string object</div>
 
在这个例子里，还可以看到不同类型的数据是如何存储在同一个数组中的，这么做有一定的好处，但是在某些场合则可能形成不便，比如我们在函数一章中讨论过的sum函数，sum接受非显式的参数列表，使用这个函数，需要调用者必须为sum提供数字型的列表(当然，字符串无法做sum操作)。如果是强类型语言，则对sum传入字符串数组会被编译程序认为是非法的，而在JavaScript中，程序需要在运行时才能侦测到这一错误。
<h3>
<a name="_Toc259883916">5.2</a>使用数组 </h3>
<h4>
<a name="_Toc259883917">5.2.1 </a>数组的基本方法使用 </h4>
数组有这样几种方式来创建：













var array = new Array(); var array = new Array(10);//长度 var array = new Array("apple", "borland", "cisco");
<pre></pre>

 
 
不过，运用最多的为字面量方式来创建，如果第三章中的JSON那样，我们完全可以这样创建数组：
 













var array = []; var array = ["one", "two", "three", "four"];
<pre></pre>

 
 
下面我们通过一些实际的小例子来说明数组的使用(主要方法的使用)：
向数组中添加元素：
 













var array = []; array.push(1); array.push(2); array.push(3); array.push("four"); array.push("five"); array.push(3.1415926);
<pre></pre>

 
 
 前面提到过，JavaScript的数组有列表的性质，因此可以向其中push不同类型的元素，接上例：
 













var len = array.length; for(var i = 0; i < len; i++){ print(typeof array[i]); }
<pre></pre>

 
 
结果为：
 
 
<div class="quote_div">number number number string string number</div>
 
弹出数组中的元素：
 













for(var i = 0; i < len; i++){ print(array.pop()); } print(array.length);
<pre></pre>

 
 
运行结果如下，注意最后一个0是指array的长度为0，因为这时数组的内容已经全部弹出：
 
 
<div class="quote_div">3.1415926 five four 3 2 1 0</div>
 
join，连接数组元素为一个字符串：
 
 
array = ["one", "two", "three", "four", "five"]; var str1 = array.join(","); var str2 = array.join("|"); print(str1); print(str2);
<pre></pre>
 
运行结果如下：
 
 
<div class="quote_div">one,two,three,four,five one|two|three|four|five</div>
 
连接多个数组为一个数组：
 













var another = ["this", "is", "another", "array"]; var another2 = ["yet", "another", "array"]; var bigArray = array.concat(another, another2);
<pre></pre>

 
 
结果为：
 
 
<div class="quote_div">one,two,three,four,five,this,is,another,array,yet,another,array</div>
 
从数组中取出一定数量的元素，不影响数组本身：
 
 
print(bigArray.slice(5,9));
<pre></pre>
 
结果为：
 














<div class="quote_div">this,is,another,array</div>

 
 
slice方法的第一个参数为起始位置，第二个参数为终止位置，操作不影响数组本身。下面我们来看splice方法，虽然这两个方法的拼写非常相似，但是功用则完全不同，事实上，splice是一个相当难用的方法：
 
 
bigArray.splice(5, 2); bigArray.splice(5, 0, "very", "new", "item", "here");
<pre></pre>
 
第一行代码表示，从bigArray数组中，从第5个元素起，删除2个元素；而第二行代码表示，从第5个元素起，删除0个元素，并把随后的所有参数插入到从第5个开始的位置，则操作结果为：
<div class="quote_div">one,two,three,four,five,very,new,item,here,another,array,yet,another,array</div>
 
我们再来讨论下数组的排序，JavaScript的数组的排序函数sort将数组按字母顺序排序，排序过程会影响源数组，比如：
 





var array = ["Cisio", "Borland", "Apple", "Dell"]; print(array); array.sort(); print(array);
<pre></pre>

 
 
执行结果为：
 
 
<div class="quote_div">Cisio,Borland,Apple,Dell Apple,Borland,Cisio,Dell</div>
 
这种字母序的排序方式会造成一些非你所预期的小bug，比如：
 





var array = [10, 23, 44, 58, 106, 235]; array.sort(); print(array);
<pre></pre>

 
 
得到的结果为：
 
 
<div class="quote_div">10,106,23,235,44,58</div>
 
可以看到，sort不关注数组中的内容是数字还是字母，它仅仅是按照字母的字典序来进行排序，对于这种情况，JavaScript提供了另一种途径，通过给sort函数传递一个函数对象，按照这个函数提供的规则对数组进行排序。
 





function sorter(a, b){ return a - b; } var array = [10, 23, 44, 58, 106, 235]; array.sort(sorter); print(array);
<pre></pre>

 
 
函数sorter接受两个参数，返回一个数值，如果这个值大于0，则说明第一个参数大于第二个参数，如果返回值为0，说明两个参数相等，返回值小于0，则第一个参数小于第二个参数，sort根据这个返回值来进行最终的排序：
 
 
<div class="quote_div">10,23,44,58,106,235</div>
 
当然，也可以简写成这样：
 
 
array.sort(function(a, b){return a - b;});//正序 array.sort(function(a, b){return b - a;});//逆序
<pre></pre>
 
<h4>
<a name="_Toc259883918">5.2.2 </a>删除数组元素 </h4>
虽然令人费解，但是JavaScript的数组对象上确实没有一个叫做delete或者remove的方法，这就使得我们需要自己扩展其数组对象。一般来说，我们可以扩展JavaScript解释器环境中内置的对象，这种方式的好处在于，扩展之后的对象可以适用于其后的任意场景，而不用每次都显式的声明。而这种做法的坏处在于，修改了内置对象，则可能产生一些难以预料的错误，比如遍历数组实例的时候，可能会产生令人费解的异常。
数组中的每个元素都是一个对象，那么，我们可以使用delete来删除元素吗？来看看下边这个小例子：
 












var array = ["one", "two","three","four"]; //数组中现在的内容为： //one,two,three,four //array.length == 4 delete array[2];
<pre></pre>

 
 
然后，我们再来看看这个数组的内容：
 
<div class="quote_div">one, two, undefined, four //array.length == 4</div>

可以看到，delete只是将数组array的第三个位置上的元素删掉了，可是数组的长度没有改变，显然这个不是我们想要的结果，不过我们可以借助数组对象自身的slice方法来做到。一个比较好的实现，是来自于jQuery的设计者John Resig：
 

//Array Remove - By John Resig (MIT Licensed) 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); };
<pre></pre>
 
这个函数扩展了JavaScript的内置对象Array，这样，我们以后的所有声明的数组都会自动的拥有remove能力，我们来看看这个方法的用法：
 











var array = ["one", "two", "three", "four", "five", "six"]; print(array); array.remove(0);//删除第一个元素 print(array); array.remove(-1);//删除倒数第一个元素 print(array); array.remove(0,2);//删除数组中下标为0-2的元素(3个) print(array);
<pre></pre>

 
 
会得到这样的结果：
 

<div class="quote_div">one,two,three,four,five,six two,three,four,five,six two,three,four,five five</div>
 
也就是说，remove接受两个参数，第一个参数为起始下标，第二个参数为结束下标，其中第二个参数可以忽略，这种情况下会删除指定下标的元素。当然，不是每个人都希望影响整个原型链(原因在下一个小节里讨论)，因此可以考虑另一种方式：
 

//Array Remove - By John Resig (MIT Licensed) 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); };
<pre></pre>
 
其操作方式与前者并无二致，但是不影响全局对象，代价是你需要显式的传递需要操作的数组作为第一个参数：
 











var array = ["one", "two", "three", "four", "five", "six"]; Array.remove(array, 0, 2);//删除0, 1, 2三个元素 print(array);
<pre></pre>

 
 
这种方式，相当于给JavaScript内置的Array添加了一个静态方法。
<h4>
<a name="_Toc259883919">5.2.3</a>遍历数组 </h4>
在对象与JSON这一章中，我们讨论了for…in这种遍历对象的方式，这种方式同样适用于数组，比如：
 











var array = [1, 2, 3, 4]; for(var item in array){ print(array[item]); }
<pre></pre>

 
 
将会打印：
 

<div class="quote_div">1 2 3 4</div>
 
但是这种方式并不总是有效，比如我们扩展了内置对象Array，如下：
 

Array.prototype.useless = function(){}
<pre></pre>
 
然后重复执行上边的代码，会得到这样的输出：
 

<div class="quote_div">1 2 3 4 function(){}</div>
 
设想这样一种情况，如果你对数组的遍历做sum操作，那么会得到一个莫名其妙的错误，毕竟函数对象不能做求和操作。幸运的是，我们可以用另一种遍历方式来取得正确的结果：
 











for(var i = 0, len = array.length; i < len;i++){ print(array[i]); }
<pre></pre>

 
 
这种for循环如其他很多语言中的写法一致，重要的是，它不会访问哪些下标不是数字的元素，如上例中的function,这个function的下标为useless,是一个字符串。从这个例子我们可以看出，除非必要，尽量不要对全局对象进行扩展，因为对全局对象的扩展会造成所有继承链上都带上“烙印”，而有时候这些烙印会成为滋生bug的温床。
 
附：由于作者本身水平有限，文中难免有纰漏错误等，或者语言本身有不妥当之处，欢迎及时指正，提出建议，参与讨论，谢谢大家！
</div>

24 楼 mengqingyu 2010-04-26

楼主讲的很不错支持一下

23 楼 zhangjf108 2010-04-26

不错，很好的东西！

22 楼 ccyingfu 2010-04-26

写的好极了。

21 楼 s79 2010-04-25

引用

另一个与其他语言的数组不同的是，字符串也可以作为数组的下标(事实上

Array也是Object类型，如果本文要介绍Array，就不应该把与Object相关的内容在这里介绍。
如果说给一个Object添加的property能被称为“下标”，如var a=[1,2];a.new="NEW";那么无法解释a.new不能参与到length的计算，不能被a.sort()操作等。

另外不要用for...in遍历数组对象，如果把它当作数组来用，一定要使用for(var i=0;i<a.length;i++)这样的方式，确保得到的每个“元素”都是这个数组的下标。

实际应用中，很少会把数组设计的离散。如果过于离散，就失去了数组的意义，莫不如使用Object容易理解。

20 楼 abruzzi 2010-04-25

hyj1254 写道

介绍下sort()函数的用法吧（这个问的有点弱了

）

关于数组的排序部分已经更新，可以看看，谢谢你的提醒！

19 楼 abruzzi 2010-04-25

cryolite 写道

length修改后会影响数组的实际大小，这个得提一下

本来准备在5.1小节上讲的，结果举的例子少些了些东西：

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

运行结果为：

引用

5
3
1,2,3

不知道大家有没有注意到这个1,2,3,其实这个就是修改了length属性之后执行print(array)语句的运行结果，可能排版的时候给删掉了，不好意思。我再修改下。

18 楼 abruzzi 2010-04-25

hyj1254 写道

介绍下sort()函数的用法吧（这个问的有点弱了

）

好的，我在最后加一小节，先整理下，随后再贴上来。

17 楼 cryolite 2010-04-25

length修改后会影响数组的实际大小，这个得提一下

16 楼 hyj1254 2010-04-25

介绍下sort()函数的用法吧（这个问的有点弱了

）

15 楼 abruzzi 2010-04-25

zhouyrt 写道

呵，数组的数字索引看起来像其它语言的索引，但实际上它会隐式的转换成字符串。亦可参考
http://snandy.iteye.com/blog/284805
http://snandy.iteye.com/blog/407351

嗯，不错，用一个for..in就可以看到了。JavaScript的数组本质上还是键-值这样的形式，而不是一个连续的内存块(C/Java中都是连续的)，而是一个散列表。

14 楼 zhouyrt 2010-04-25

abruzzi 写道

yuyue618 写道

s79 写道

引用

另一个与其他语言的数组不同的是，字符串也可以作为数组的下标……

这句话容易误导初学者。建议更正。

是呀,这时候已经不是下标了吧. 而是对象的属性?

事实上，在JavaScript里，不存在数字下标这个传统上的东西，数字下标和字符串下标都是“JavaScript数组”这种特殊对象的属性，比如：

var array = ["first", "second", "third"];
print(array["0"]);//以字符串0为下标
print(array[0]);//以数字0为下标

会得到相同的结果：

引用

first
first

JavaScript数组其实是将数字转化成字符串，然后将这个字符串作为“数组”对象的属性来进行存取的。说白了，在存取属性上，它跟其他的对象并无二致。

呵，数组的数字索引看起来像其它语言的索引，但实际上它会隐式的转换成字符串。亦可参考
http://snandy.iteye.com/blog/284805
http://snandy.iteye.com/blog/407351

13 楼 abruzzi 2010-04-25

yuyue618 写道

s79 写道

引用

另一个与其他语言的数组不同的是，字符串也可以作为数组的下标……

这句话容易误导初学者。建议更正。

是呀,这时候已经不是下标了吧. 而是对象的属性?

事实上，在JavaScript里，不存在数字下标这个传统上的东西，数字下标和字符串下标都是“JavaScript数组”这种特殊对象的属性，比如：

var array = ["first", "second", "third"];
print(array["0"]);//以字符串0为下标
print(array[0]);//以数字0为下标

会得到相同的结果：

引用

first
first

12 楼 zhouyrt 2010-04-25

yuyue618 写道

s79 写道

引用

另一个与其他语言的数组不同的是，字符串也可以作为数组的下标……

这句话容易误导初学者。建议更正。

是呀,这时候已经不是下标了吧. 而是对象的属性?

看怎么理解了，用字符串作为下标可称为关联数组。

数组分类：

1、从数组的下标分为索引数组、关联数组

2、从对数据的存储分为静态数组、动态数组

js的数组同时属于索引数组和动态数组，本质上它就是一个对象，js的索引数组并非“连续分配”内存的，因此索引方式并不会带来很高的效率。而c,c++,java中的数组则是连续分配内存的，如果按照c,c++,java中数组的理解，那么js中的关联数组不能称为数组，即使是js中的Array也不能称为数组，因为Array只是具有索引数字，但并非“连续分配”内存的。

11 楼 whaosoft 2010-04-25

不错不错全部复制走

10 楼 yuyue618 2010-04-25

s79 写道

引用

另一个与其他语言的数组不同的是，字符串也可以作为数组的下标……

这句话容易误导初学者。建议更正。

是呀,这时候已经不是下标了吧. 而是对象的属性?

9 楼 s79 2010-04-25

引用

另一个与其他语言的数组不同的是，字符串也可以作为数组的下标……

这句话容易误导初学者。建议更正。

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论