JavaScript内核系列 第5章 数组

第五章 数组

JavaScript的数组也是一个比较有意思的主题，虽然名为数组(Array)，但是根据数组对象上的方法来看，更像是将很多东西混在在一起的结果。而传统的程序设计语言如C/Java中，数组内的元素需要具有相同的数据类型，而作为弱类型的JavaScript，则没有这个限制，事实上，JavaScript的同一个数组中，可以有各种完全不同类型的元素。

 

方法	描述
concat()	连接两个或更多的数组，并返回结果。
join()	把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
pop()	删除并返回数组的最后一个元素。
push()	向数组的末尾添加一个或更多元素，并返回新的长度。
reverse()	颠倒数组中元素的顺序。
shift()	删除并返回数组的第一个元素。
slice()	从某个已有的数组返回选定的元素。
sort()	对数组的元素进行排序。
splice()	删除元素，并向数组添加新元素。
unshift()	向数组的开头添加一个或更多元素，并返回新的长度。
valueOf()	返回数组对象的原始值。

 

可以看出，JavaScript的数组对象比较复杂，包含有pop,push等类似与栈的操作，又有slice， reverse，sort这样类似与列表的操作。或许正因为如此，JavaScript中的数组的功能非常强大。

5.1数组的特性

数组包括一些属性和方法，其最常用的属性则为length，length表示数组的当前长度，与其他语言不同的是，这个变量并非只读属性，比如：

 

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

 

 

运行结果为：

 

5
3
1,2,3

 

注意到最后的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]);
}

 

 

运行结果为：

number
string
object

 

在这个例子里，还可以看到不同类型的数据是如何存储在同一个数组中的，这么做有一定的好处，但是在某些场合则可能形成不便，比如我们在函数一章中讨论过的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的温床。

 

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

评论

48 楼 zhangyou1010 2010-04-28  

好几天没关注楼主的文章了，今天跟上。

47 楼 abruzzi 2010-04-27  

第六章：正则表达式已经贴出来，地址为：
http://www.iteye.com/topic/654429

希望有更多的像weiqingfei这样热心的朋友来支持，使得这个系列文章的质量更好。

46 楼 abruzzi 2010-04-27  

weiqingfei 写道

weiqingfei 写道

abruzzi 写道

weiqingfei 写道

引用

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

这个是Object最基本的特性，Array源于Object，自然有这个特性，这个不能说是javascript数组特殊的地方。

你的意思我理解，我想表达的是，这个特性是JavaScript数组区别于其他语言的数组的，并不是JavaScrpt数组区别于JavaScript对象的。

Array作为Object，接受key-value序列赋值时，只有当key可转为正整数，才有可能对length进行修改。
比如

var a＝[];
a[0] = 0;
a["1"] = 1;
a[new Number(2)] = 2;
a[new String(3)] = 3;
a[new Object(4)] = 4;

var MyObj = function(value){
	this.value = value;
	this.toString = function(){
		return this.value;
	}
}
a[new MyObj(5)] = 5;

不知道你用的是什么解释器？我使用的解释器器是Rhino，可以设置的，我试了下你的例子。
不知为什么，javascript的“数组”让我觉得一阵阵恶心。

嗯，例子就是演示使用这样形式的下标，是可以给数组赋值并重新计算length的，
由此也可以大概猜想一下Array对象的内部实现。

大概的看了一下rhino关于Array部分的实现，和我猜想的差不多。
源文件org/mozilla/javascript/ScriptRuntime.java中1517行方法

    public static Object setObjectElem(Scriptable obj, Object elem,
                                       Object value, Context cx)
    {
        if (obj instanceof XMLObject) {
            XMLObject xmlObject = (XMLObject)obj;
            xmlObject.ecmaPut(cx, elem, value);
            return value;
        }

       [b] [color=red]String s = toStringIdOrIndex(cx, elem);[/color][/b]
        if (s == null) {
            int index = lastIndexResult(cx);
            ScriptableObject.putProperty(obj, index, value);                //属性elem可以作为index
        } else {
            ScriptableObject.putProperty(obj, s, value);                      //属性elem为其它
        }

        return value;
    }

再看看toStringIdOrIndex方法

    static String toStringIdOrIndex(Context cx, Object id)
    {
        if (id instanceof Number) {                           //如果属性为数字
            double d = ((Number)id).doubleValue();
            int index = (int)d;
            if (index == d) {
                storeIndexResult(cx, index);
                return null;
            }
            return toString(id);
        } else {
            String s;
            if (id instanceof String) {                          //如果属性为字符串
                s = (String)id;
            } else {
                s = toString(id);                                 //如果属性为其他，用toString方法得到其字符串值
            }
            long indexTest = indexFromString(s);       //这个方法判断这个字符串是否可以做index
            if (indexTest >= 0) {
                storeIndexResult(cx, (int)indexTest);
                return null;
            }
            return s;
        }
    }

再看一下toString方法

    public static String toString(Object val) {
        for (;;) {
            if (val == null) {
                return "null";
            }
            if (val == Undefined.instance) {
                return "undefined";
            }
            if (val instanceof String) {
                return (String)val;
            }
            if (val instanceof Number) {
                // XXX should we just teach NativeNumber.stringValue()
                // about Numbers?
                return numberToString(((Number)val).doubleValue(), 10);
            }
            if (val instanceof Scriptable) {
                val = ((Scriptable) val).getDefaultValue(StringClass);
                if (val instanceof Scriptable) {
                    throw errorWithClassName("msg.primitive.expected", val);
                }
                continue;
            }
            return val.toString();         //如果只是一般的object，就是用其toString方法的返回值，
        }                                          //这个也就是我例子里所举的那个自定义对象的情况
    }

调用ScriptableObject.putProperty(obj, index, value); 实质上调用的是NativeArray.put(int index, Scriptable start, Object value)方法

    public void put(int index, Scriptable start, Object value)
    {
        if (start == this && !isSealed() && dense != null && 0 <= index &&
            (denseOnly || !isGetterOrSetter(null, index, true)))
        {
            if (index < dense.length) {
                dense[index] = value;
                if (this.length <= index)
                    this.length = (long)index + 1;
                return;
            } else if (denseOnly && index < dense.length * GROW_FACTOR &&
                       ensureCapacity(index+1))
            {
                dense[index] = value;
                this.length = (long)index + 1;
                return;
            } else {
                denseOnly = false;
            }
        }
        super.put(index, start, value);             //这儿调用了super的方法，实际上上面的例子是没有走到这儿的。
        if (start == this) {
            // only set the array length if given an array index (ECMA 15.4.0)
            if (this.length <= index) {
                // avoid overflowing index!
                this.length = (long)index + 1;
            }
        }
    }

看来在rhino的实现中，可作为数组属性，和其他属性是分开管理的。

嗯，分析的很好，很认真，呵呵。

String s = toStringIdOrIndex(cx, elem);
        if (s == null) {
            int index = lastIndexResult(cx);
            ScriptableObject.putProperty(obj, index, value);                //属性elem可以作为index
        } else {
            ScriptableObject.putProperty(obj, s, value);                      //属性elem为其它
        }

以及这块：

        if (start == this) {
            // only set the array length if given an array index (ECMA 15.4.0)
            if (this.length <= index) {
                // avoid overflowing index!
                this.length = (long)index + 1;
            }
        }

就可以说明大部分问题了， 。

45 楼 weiqingfei 2010-04-27  

weiqingfei 写道

abruzzi 写道

weiqingfei 写道

引用

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

这个是Object最基本的特性，Array源于Object，自然有这个特性，这个不能说是javascript数组特殊的地方。

你的意思我理解，我想表达的是，这个特性是JavaScript数组区别于其他语言的数组的，并不是JavaScrpt数组区别于JavaScript对象的。

Array作为Object，接受key-value序列赋值时，只有当key可转为正整数，才有可能对length进行修改。
比如

var a＝[];
a[0] = 0;
a["1"] = 1;
a[new Number(2)] = 2;
a[new String(3)] = 3;
a[new Object(4)] = 4;

var MyObj = function(value){
	this.value = value;
	this.toString = function(){
		return this.value;
	}
}
a[new MyObj(5)] = 5;

不知道你用的是什么解释器？我使用的解释器器是Rhino，可以设置的，我试了下你的例子。
不知为什么，javascript的“数组”让我觉得一阵阵恶心。

嗯，例子就是演示使用这样形式的下标，是可以给数组赋值并重新计算length的，
由此也可以大概猜想一下Array对象的内部实现。

大概的看了一下rhino关于Array部分的实现，和我猜想的差不多。
源文件org/mozilla/javascript/ScriptRuntime.java中1517行方法

    public static Object setObjectElem(Scriptable obj, Object elem,
                                       Object value, Context cx)
    {
        if (obj instanceof XMLObject) {
            XMLObject xmlObject = (XMLObject)obj;
            xmlObject.ecmaPut(cx, elem, value);
            return value;
        }

       [b] [color=red]String s = toStringIdOrIndex(cx, elem);[/color][/b]
        if (s == null) {
            int index = lastIndexResult(cx);
            ScriptableObject.putProperty(obj, index, value);                //属性elem可以作为index
        } else {
            ScriptableObject.putProperty(obj, s, value);                      //属性elem为其它
        }

        return value;
    }

再看看toStringIdOrIndex方法

    static String toStringIdOrIndex(Context cx, Object id)
    {
        if (id instanceof Number) {                           //如果属性为数字
            double d = ((Number)id).doubleValue();
            int index = (int)d;
            if (index == d) {
                storeIndexResult(cx, index);
                return null;
            }
            return toString(id);
        } else {
            String s;
            if (id instanceof String) {                          //如果属性为字符串
                s = (String)id;
            } else {
                s = toString(id);                                 //如果属性为其他，用toString方法得到其字符串值
            }
            long indexTest = indexFromString(s);       //这个方法判断这个字符串是否可以做index
            if (indexTest >= 0) {
                storeIndexResult(cx, (int)indexTest);
                return null;
            }
            return s;
        }
    }

再看一下toString方法

    public static String toString(Object val) {
        for (;;) {
            if (val == null) {
                return "null";
            }
            if (val == Undefined.instance) {
                return "undefined";
            }
            if (val instanceof String) {
                return (String)val;
            }
            if (val instanceof Number) {
                // XXX should we just teach NativeNumber.stringValue()
                // about Numbers?
                return numberToString(((Number)val).doubleValue(), 10);
            }
            if (val instanceof Scriptable) {
                val = ((Scriptable) val).getDefaultValue(StringClass);
                if (val instanceof Scriptable) {
                    throw errorWithClassName("msg.primitive.expected", val);
                }
                continue;
            }
            return val.toString();         //如果只是一般的object，就是用其toString方法的返回值，
        }                                          //这个也就是我例子里所举的那个自定义对象的情况
    }

调用ScriptableObject.putProperty(obj, index, value); 实质上调用的是NativeArray.put(int index, Scriptable start, Object value)方法

引用

    public void put(int index, Scriptable start, Object value)
    {
        if (start == this && !isSealed() && dense != null && 0 <= index &&
            (denseOnly || !isGetterOrSetter(null, index, true)))
        {
            if (index < dense.length) {
                dense[index] = value;
                if (this.length <= index)
                    this.length = (long)index + 1;
                return;
            } else if (denseOnly && index < dense.length * GROW_FACTOR &&
                       ensureCapacity(index+1))
            {
                dense[index] = value;
                this.length = (long)index + 1;
                return;
            } else {
                denseOnly = false;
            }
        }
        super.put(index, start, value);             //这儿调用了super的方法，实际上上面的例子是没有走到这儿的。
        if (start == this) {
            // only set the array length if given an array index (ECMA 15.4.0)
            if (this.length <= index) {
                // avoid overflowing index!
                this.length = (long)index + 1;
            }
        }
    }

看来在rhino的实现中，可作为数组属性，和其他属性是分开管理的。

44 楼 jqyp324 2010-04-27  

正在学习，谢谢了

43 楼 yongdi2 2010-04-27  

php的精华在数组，js也有点像

42 楼 abruzzi 2010-04-26  

Lunatica 写道

abruzzi 写道

zhouyrt 写道

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

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

其实正好相反。在array['1']=''时，javascript会把它当翻译成array[1],所以用array[1],和array['1']都能访问到，而且array.length会变成2。
但是如果用array['1a']='',那么你只能用array['1a']来访问，因为1a被当做数组对象的一个属性而非数组的内容，所以array的length是0，同时在array的tostring和jion等方法时1a是不会参与的。
至于 for in 语句中只是对于array来说会在array中的内容迭代完会把对象中的属性也迭代出来而已，并不是说1a就是数组的内容

嗯，我觉得你的理解更有道理一些，我再做一些测试，谢谢！

41 楼 Lunatica 2010-04-26  

abruzzi 写道

zhouyrt 写道

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

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

其实正好相反。在array['1']=''时，javascript会把它当翻译成array[1],所以用array[1],和array['1']都能访问到，而且array.length会变成2。
但是如果用array['1a']='',那么你只能用array['1a']来访问，因为1a被当做数组对象的一个属性而非数组的内容，所以array的length是0，同时在array的tostring和jion等方法时1a是不会参与的。
至于 for in 语句中只是对于array来说会在array中的内容迭代完会把对象中的属性也迭代出来而已，并不是说1a就是数组的内容

40 楼 weiqingfei 2010-04-26  

abruzzi 写道

另外谢谢weiqingfei这位朋友的支持，希望你再接再厉，这样这个系列的质量才可以更好。

我觉得能静下心来，认认真真的做，并且做完一件事是值得尊敬的。佩服你，希望能坚持到底。

39 楼 weiqingfei 2010-04-26  

abruzzi 写道

weiqingfei 写道

引用

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

这个是Object最基本的特性，Array源于Object，自然有这个特性，这个不能说是javascript数组特殊的地方。

你的意思我理解，我想表达的是，这个特性是JavaScript数组区别于其他语言的数组的，并不是JavaScrpt数组区别于JavaScript对象的。

Array作为Object，接受key-value序列赋值时，只有当key可转为正整数，才有可能对length进行修改。
比如

var a＝[];
a[0] = 0;
a["1"] = 1;
a[new Number(2)] = 2;
a[new String(3)] = 3;
a[new Object(4)] = 4;

var MyObj = function(value){
	this.value = value;
	this.toString = function(){
		return this.value;
	}
}
a[new MyObj(5)] = 5;

不知道你用的是什么解释器？我使用的解释器器是Rhino，可以设置的，我试了下你的例子。
不知为什么，javascript的“数组”让我觉得一阵阵恶心。

嗯，例子就是演示使用这样形式的下标，是可以给数组赋值并重新计算length的，
由此也可以大概猜想一下Array对象的内部实现。

38 楼 abruzzi 2010-04-26  

另外谢谢weiqingfei这位朋友的支持，希望你再接再厉，这样这个系列的质量才可以更好。

37 楼 abruzzi 2010-04-26  

yudylaw 写道

最期待的是函数式编程，LZ把这块讲好啊。

呵呵，谢谢你的关注，快到了，我尽量做到最好。

36 楼 abruzzi 2010-04-26  

woainichenxueming 写道

不错期待下一章节：对了Array.prototype.remove和Array.remove的区别是什么啊？期待回复！谢谢

Array.prototype.remove是对原型链做修改，这样的话，以后所有声明的Array对象就会带上remove方法(隐式的)，而Array.remove相当于Array的一个静态方法，这种形式不修改原型链。

35 楼 abruzzi 2010-04-26  

weiqingfei 写道

引用

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

这个是Object最基本的特性，Array源于Object，自然有这个特性，这个不能说是javascript数组特殊的地方。

你的意思我理解，我想表达的是，这个特性是JavaScript数组区别于其他语言的数组的，并不是JavaScrpt数组区别于JavaScript对象的。

Array作为Object，接受key-value序列赋值时，只有当key可转为正整数，才有可能对length进行修改。
比如

var a＝[];
a[0] = 0;
a["1"] = 1;
a[new Number(2)] = 2;
a[new String(3)] = 3;
a[new Object(4)] = 4;

var MyObj = function(value){
	this.value = value;
	this.toString = function(){
		return this.value;
	}
}
a[new MyObj(5)] = 5;

不知道你用的是什么解释器？我使用的解释器器是Rhino，可以设置的，我试了下你的例子。
不知为什么，javascript的“数组”让我觉得一阵阵恶心。

34 楼 yudylaw 2010-04-26  

最期待的是函数式编程，LZ把这块讲好啊。

33 楼 woainichenxueming 2010-04-26  

不错期待下一章节：对了Array.prototype.remove和Array.remove的区别是什么啊？期待回复！谢谢

32 楼 weiqingfei 2010-04-26  

引用

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

这个是Object最基本的特性，Array源于Object，自然有这个特性，这个不能说是javascript数组特殊的地方。

Array作为Object，接受key-value序列赋值时，只有当key可转为正整数，才有可能对length进行修改。
比如

var a＝[];
a[0] = 0;
a["1"] = 1;
a[new Number(2)] = 2;
a[new String(3)] = 3;
a[new Object(4)] = 4;

var MyObj = function(value){
	this.value = value;
	this.toString = function(){
		return this.value;
	}
}
a[new MyObj(5)] = 5;

不知为什么，javascript的“数组”让我觉得一阵阵恶心。

31 楼 abruzzi 2010-04-26  

寻找出路的苍蝇 写道

我觉得还是有必要更详细地解释下数组对象的下标属性与普通属性的区别，就像s79同志提到的，否则这个东西很容易让新手困惑。
还有，最好也提下JS中的各式“伪数组”，如arguments、与dom有关的childNodes等，这些对象虽然也有length属性，也可以通过数字下标索引元素，但它们不是Array对象。我觉得这点还是有必要提及的。

首先，谢谢你的建议！
JavaScript的数组只不过是一个内建的比较特殊的Object而已，其中包含了一些特殊的方法，从而使得它看起来像是数组，也就是说，它本身就是你所说的“伪数组”，这一点从多维数组上表现的就更清晰了。另外，关于arguments,最好在函数那一章里讨论比较适合，而DOM部分，则暂时不涉及，因为这个系列主要关注的是核心概念。如果可能，可以在后边专门讨论客户端的JavaScript。

30 楼 寻找出路的苍蝇 2010-04-26  

我觉得还是有必要更详细地解释下数组对象的下标属性与普通属性的区别，就像s79同志提到的，否则这个东西很容易让新手困惑。
还有，最好也提下JS中的各式“伪数组”，如arguments、与dom有关的childNodes等，这些对象虽然也有length属性，也可以通过数字下标索引元素，但它们不是Array对象。我觉得这点还是有必要提及的。

29 楼 abruzzi 2010-04-26  

jwtiger 写道

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

嗯，谢谢你的提醒。这个系列最初是在09年十二月左右开始的，有些章节一气呵成，有的则需要更深入的研究，消化才慢慢加进来，正是基于“尽量的保证质量”这个想法才发的很慢，呵呵。