`
abruzzi
  • 浏览: 449294 次
  • 性别: Icon_minigender_1
  • 来自: 西安
社区版块
存档分类
最新评论

JavaScript内核系列 第5章 数组

JavaScript正则表达式AppleRESTCisco 
阅读更多

第五章 数组

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的温床。

 

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

分享到：
| Swing小应用(Todo-List)之三
评论
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年十二月左右开始的，有些章节一气呵成，有的则需要更深入的研究，消化才慢慢加进来，正是基于“尽量的保证质量”这个想法才发的很慢，呵呵。
发表评论

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

相关推荐

    javascript入门笔记

    Javascript Basic 1、Javascript 概述(了解) Javascript，简称为 JS，是一款能够运行在 JS解释器/引擎 中的脚本语言 JS解释器/引擎 是JS的运行环境： 1、独立安装的JS解释器 - NodeJS 2、嵌入在浏览器中的JS...

    12_JavaScript笔记.pdf

    不同的浏览器可能采用不同的内核来解析和执行JavaScript，例如IE系列使用Trident内核，Safari和早期的Chrome使用WebKit，Chrome后期版本和现在的大多数浏览器则使用Blink内核，Firefox使用Gecko内核。这导致了...

    High Performance JavaScript(高性能JavaScript)读书笔记分析

    第五章：字符串和正则表达式 字符串操作和正则表达式是JavaScript中常见的操作，但也是潜在的性能瓶颈所在。回溯是正则表达式匹配中一个常见但可能导致效率低下的问题。 第六章：快速响应的用户界面 在Web应用中，...

    python入门到高级全栈工程师培训 第3期 附课件代码

    第5章 01 上节课复习 02 文件合并与文件归档 03 文件归档与两种压缩方式 04 vim编辑器 05 系统启动流程 06 grub加密 07 bios加密 08 top命令 09 free命令 10 进程管理 第6章 01 上节课复习 02 磁盘分区 03 文件...

    javascript讲义(1).pptx

    #### 五、JavaScript特性 - **解释性语言**：无需编译成文件，直接由浏览器解释执行。 - **跨平台**：能在多种操作系统和设备上运行。 - **单线程**：JavaScript的主要执行模型是单线程的。 - **ECMA标准**：为了...

    JS数独 v1.0.2

    《JS数独 v1.0.2》是一款基于JavaScript实现的数独小游戏，适用于现代浏览器，尤其是基于WebKit内核的浏览器如Chrome或Safari。在IE浏览器中，部分验证功能可能无法正常工作，但不影响基本的游戏体验。这个项目展示...

    fsdfsdfdsf

    5. **XML验证器设计** (第 5 章): 讨论了如何设计XML验证器，从最初的简单实现到逐步优化，包括复杂度分析和性能提升。 6. **集成测试框架** (第 6 章): 关注于构建灵活、易用的自动化测试框架，以及在设计时考虑的...

    代码之美(中文完整版).pdf

    第5章 正确、优美、迅速(按重要性排序)：从设计XML验证器中学到的经验 5.1 XML验证器的作用 5.2 问题所在 5.3 版本1：简单的实现 5.4 版本2：模拟BNF语法——复杂度O(N) 5.5 版本3：第一个复杂度O(log N)的优化 5.6 ...

    JsInWinform（在winform中调用JS代码）

    - **`InvokeScript`方法**：调用`webBrowser1.Document.InvokeScript`方法，传入JavaScript函数名和参数数组，即可执行JavaScript函数。 4. **从JavaScript调用.NET**： - **设置`ObjectForScripting`**：为`...

    最新史上最全前端面试题(含答案).docx

    20. **数组方法**：pop()删除并返回数组最后一个元素，push()在数组末尾添加元素，unshift()在数组开头添加元素，shift()删除并返回数组第一个元素。 以上内容涵盖了前端开发中的基础理论、HTML结构、CSS样式、...

    ActionScript开发技术大全

    第5章ActionScript3.0中的String对象 104 5.1创建String对象 104 5.2字符串处理 105 5.2.1字符处理 105 5.2.2字符串比较 107 5.2.3裁割与连接 108 5.2.4查找、匹配与替换 110 5.2.5提取子串 112 5.2.6大小写转换 113...

    2016前端面试题及答案.docx

    19. **数组方法**：pop()移除并返回数组最后一个元素，push()在末尾添加元素，unshift()在开头添加元素，shift()移除并返回数组第一个元素。 以上是2016年前端面试中的部分关键知识点，这些内容至今仍对前端开发者...

    【web前端开发面试题及答案】前端开发面试题及答案.docx

    18. **数组方法**：pop()移除并返回数组最后一个元素，push()在末尾添加元素，unshift()在开头添加元素，shift()移除并返回数组第一个元素。 19. **事件绑定**：包括传统的事件处理程序（如onclick）和DOM2级事件...

    前端面试题

    - `shift()`：从数组开头移除第一个元素。 #### 十六、事件绑定与事件流的区别 - **事件绑定**：将事件处理程序与特定的DOM元素关联起来。 - **事件流**：描述事件在DOM树中的传播过程。 - **IE与DOM事件流的区别...

    ES6最简单的构建环境没有之一

    在现代前端开发中，ES6（ECMAScript 2015）已经成为主流的JavaScript语法，它引入了一系列新的特性，极大地提升了代码的可读性和可维护性。要搭建一个ES6的学习环境，我们可以遵循以下几个简单步骤。 1. **浏览器...

    malevich:使用粒子系统复制马列维奇至上主义，第18个建筑构图

    《使用粒子系统复制马列维奇至上主义：JavaScript实现解析》 ...通过JavaScript编程，我们不仅能理解至上主义的精神内核，还能感受到数字艺术的魅力，这正是现代技术赋予我们重新解读和创作经典的可能性。

    jquery学习笔记

    7. **扩展JavaScript内核**：jQuery还提供了对JavaScript语言本身的增强，包括数组操作等功能，这使得开发者可以更加高效地处理数据。 #### 三、jQuery项目组成 - **jQuery Core (核心库)**：这是jQuery的基础，...

    java web面试题目

    #### 五、JavaScript消除数组中的重复元素 消除数组中重复元素的一种简单方法是使用ES6的`Set`数据结构。 **示例代码：** ```javascript const arr = [1, 2, 3, 4, 5, 5, 6, 6, 7, 8, 9, 9]; const uniqueArr = ...

Magicbox
Global site tag (gtag.js) - Google Analytics