Array

  • 版本网址缩略名: Core_JavaScript_1.5_Reference/Global_Objects/Array
  • 版本标题: Array
  • 版本 id: 78259
  • 创建于:
  • 创建者: Mickeyboy
  • 是否是当前版本?
  • 评论 /* 例子 */

修订内容

概要

核心对象

让你可以使用数组。

如何创建

Array 对象构造器:

new Array(数组最大下标长度)
new Array(元素0, 元素1, ..., 元素N)

数组下标:

[元素0, 元素1, ..., 元素N]

参数

arrayLength 
数组的初始化容量大小,您可以通过length属性访问这个值。如果设定的数值不是一个数字,就会创建一个一单元长度的数组,第一个元素会被赋值成这个设定值。最大下标容量是4,294,967,295。
elementN 
一个数组元素值的列表。当使用这种形式来创建数组,数组的单元会按照列表指定的内容进行赋值,数组的length属性会被设置成列表的元素数量值。

描述

一个数组是使用数字作为索引、一个名字为其名称的数值集合。注意当如下情况,shouldn't use it as an associative array,请使用对象

下面的例子描述了如何使用值列表方式创建一个数组(Array)对象,其中tea数组包含了三个元素,并且其长度为3:

tea = ["绿茶", "红茶", "乌龙茶"];

You can construct a dense array of two or more elements starting with index 0 if you define initial values for all elements. A dense array is one in which each element has a value. The following code creates a dense array with three elements:

myArray = new Array("你好", myVar, 3.14159);

索引一个数组

你索引一个数组使用它自有的顺序。 例如, 假设你定义一个如下数组:

myArray = new Array("风", "雨", "火");

你可以用如下的方式来引用数组:

  • myArray{{mediawiki.external(0)}} 是第一个元素
  • myArray{{mediawiki.external(1)}} 是第二个元素
  • myArray{{mediawiki.external(2)}} 是第三个元素

指定参数

Array 构造器中如果仅仅指定了一个数字作为参数, 那么这个参数将作为数组的初始长度。下面的这个例子创建了一个包含有五个元素的数组:

billingMethod = new Array(5);

参数是否是一个简单的数字决定了Array 构造器的行为。

  • 如果参数就是一个数字,构造器会将数字转换成32bit无符号的整数,然后构造一个长度为该整数的数组,这时候数组的length属性值即为该整数,尽管数组还没有被赋值。
  • 如果这个参数不是一个数字,那么构造器会创建一个长度为一的数组,数组的第一个元素的值就是该参数值。

下面的例子构造了一个长度为25的数组,并且给前三个元素赋值:

musicTypes = new Array(25);
musicTypes[0] = "R&B";
musicTypes[1] = "Blues";
musicTypes[2] = "Jazz";

间接指定数组长度

如果给数组赋值时指定的数组索数值引大于数组的当前长度,那么数组的长度就会自动的增加。在下面的例子中创建了一个长度为零的数组,然后对数组的99号元素赋值。这样的话数组的元素就增长到了100。

colors = new Array();
colors[99] = "midnightblue";

使用正则匹配的结果来创建数组

正则表达式与字符串之间的匹配结果可以创建一个数组。这个数组包含了正则匹配的属性与匹配结果。RegExp.exec, String.match, 与 String.replace的返回值就是这样的数组。下面的例子可以帮助理解这些属性。

// Match one d followed by one or more b's followed by one d
// Remember matched b's and the following d
// 忽略大小写

myRe = /d(b+)(d)/i;
myArray = myRe.exec("cdbBdbsbz");

改正则匹配返回的属性/元素列表:

Property/Element 说明 例子
input 原始的输入字符串,只读属性。 cdbBdbsbz
index 匹配的子字符串的第一个字符在原始字符串中的位置(从0开始的索引,只读)。 1
{{mediawiki.external(0)}} 最后一次匹配的元素,只读。 dbBd
{{mediawiki.external(1)}}, ...{{mediawiki.external('n')}} 出现在正则匹配中的子匹配(如果有)。 {{mediawiki.external(1)}}: bB
{{mediawiki.external(2)}}: d

先前的版本中的行为

JavaScript 1.2

在JavaScript 1.2解析器中,如果将单一整型数字传递给数组的构造器,那么构造器仅仅会创建一个以该数字为第一个元素的、长度为1的数组。例如:

new Array(5) //创建了第一个元素是5的,仅包含一个元素的数组。

JavaScript 1.0

Indexing an array by its ordinal number was required; for example:

myArray[0].

属性

constructor
Specifies the function that creates an object's prototype.
index
For an array created by a regular expression match, the zero-based index of the match in the string.
input
如果数组是通过正则表达式匹配创建的,返回原始的字符串。
length长度
返回数组中元素个数.
prototype
Allows the addition of properties to all objects.

方法

Mutator 方法

这些方法可以改变数组自身:

pop
移除数组的最后一个元素,返回值是被删除的元素。
push
在数组的末尾添加一个或者多个元素,返回值是新的数组的长度。
reverse
反转数组中元素的顺序,原先第一个元素现在变成最后一个,同样原先的最后一个元素变成了现在的第一个,也就是数组的索引发生了变化。
shift
删除数组的第一个元素,返回值是删除的元素。
sort
对数组中的元素进行排序。
splice
添加或删除数组中的一个或多个元素。
unshift
添加一个或者多个元素在数组的开头,返回值是新的数组的长度。

Accessor 过程

need a better name...

这些过程不改变数组自身These methods do not modify the array and return some representation of the array.

concat
Returns a new array comprised of this array joined with other array(s) and/or value(s).
indexOf
返回第一个与给定参数相等的数组元素的索引,没有找到则返回-1。
join
将所有的数组元素连接成一个字符串。
lastIndexOf
返回在数组中搜索到的与给定参数相等的元素的最后(最大)索引。
slice
Extracts a section of an array and returns a new array.
toSource
Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the Object.toSource method.
toString
返回代表该数组及其元素的字符,重写Object.toString 过程.
valueOf
Returns the primitive value of the array. Overrides the Object.valueOf method.

Iteration methods重复过程

Several methods take as arguments functions to be called back while processing the array. When these methods are called, the length of the array is sampled, and any element added beyond this length from within the callback is not visited. Other changes to the array (setting the value of or deleting an element) may affect the results of the operation if the method visits the changed element afterwards. The specific behaviour of these methods in such cases is not always well-defined, and should not be relied upon.

filter
Creates a new array with all of the elements of this array for which the provided filtering function returns true.
forEach
对数组的每一个元素依次调用参数中指定的函数。
every
如果数组中每一个元素都满足参数中提供的测试函数,则返回真。
map
Creates a new array with the results of calling a provided function on every element in this array.
some
Returns true if at least one element in this array satisfies the provided testing function.

Generic 过程

Many methods on the JavaScript Array object are designed to be generally applied to all objects which "look like" Arrays. That is, they can be used on any object which has a length property, and which can usefully be accessed using numeric property names (as with array{{mediawiki.external(5)}} indexing).

TODO: give examples with Array.prototype.forEach.call, and adding the method to an object like JavaArray or String.

Some methods, such as join, only read the length and numeric properties of the object they are called on. Others, like reverse, require that the object's numeric properties and length be mutable; these methods can therefore not be called on objects like String, which does not permit its length property or synthesized numeric properties to be set.

The methods that work on any Array-like object and do not need to alter length or numeric properties are:

The methods that alter the length or numeric properties of the object they are called on are:

This example shows how to use map on a string object to get an array of bytes in the ASCII encoding representing the character values:

var a = Array.prototype.map.call("Hello World", 
                                 function(x) { return x.charCodeAt(0); })
// a now equals [72,101,108,108,111,32,87,111,114,108,100]

例子

例子:创建数组

这个例子,创建了一个空数组,长度为0,接着对msgArray{{mediawiki.external(0)}}赋值,让后对msgArray{{mediawiki.external(99)}}赋值,数组长度变成了100。

var msgArray = new Array();
msgArray[0] = "你好";
msgArray[99] = "宝贝";
// 因为数组元素msgArray[99]已经定义,
// 所以下面的条件成立。
if (msgArray.length == 100)
   myVar = "数组的长度是100。";

例子:二维数组

这个例子创建了一个二维数组myVar,然后赋值。

var myVar = "二维数组实例;\n";
a = new Array(4);
for (var i = 0; i < 4; i++) {
   a[i] = new Array(4);
   for (var j = 0; j < 4; j++) {
      a[i][j] = "[" + i + "," + j + "]";
   }
}
for (var i = 0; i < 4; i++) {
   str = "Row " + i + ":";
   for (var j = 0; j < 4; j++) {
      str += a[i][j];
   }
   myVar += str + ";\n";
}

下面是myVar的值:

二维数组实例;
Row 0: [0,0][0,1][0,2][0,3];
Row 1: [1,0][1,1][1,2][1,3];
Row 2: [2,0][2,1][2,2][2,3];
Row 3: [3,0][3,1][3,2][3,3];
{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Array" } ) }}

修订版来源

<p>
</p>
<h3 name=".E6.A6.82.E8.A6.81"> 概要 </h3>
<p><b>核心对象</b>
</p><p>让你可以使用数组。
</p>
<h3 name=".E5.A6.82.E4.BD.95.E5.88.9B.E5.BB.BA"> 如何创建 </h3>
<p><code>Array</code> 对象构造器:
</p>
<pre class="eval">new Array(<i>数组最大下标长度</i>)
new Array(<i>元素0</i>, <i>元素1</i>, ..., <i>元素N</i>)
</pre>
<p>数组下标:
</p>
<pre class="eval">[<i>元素0</i>, <i>元素1</i>, ..., <i>元素N</i>]
</pre>
<h3 name=".E5.8F.82.E6.95.B0"> 参数 </h3>
<dl><dt> <code>arrayLength</code> </dt><dd> 数组的初始化容量大小,您可以通过length属性访问这个值。如果设定的数值不是一个数字,就会创建一个一单元长度的数组,第一个元素会被赋值成这个设定值。最大下标容量是4,294,967,295。
</dd></dl>
<dl><dt> <code>element<i>N</i></code> </dt><dd> 一个数组元素值的列表。当使用这种形式来创建数组,数组的单元会按照列表指定的内容进行赋值,数组的length属性会被设置成列表的元素数量值。
</dd></dl>
<h3 name=".E6.8F.8F.E8.BF.B0"> 描述 </h3>
<p>一个数组是使用数字作为索引、一个名字为其名称的数值集合。注意当如下情况,<a class="external" href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/">shouldn't use it as an associative array</a>,请使用<a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Object">对象</a>。
</p><p>下面的例子描述了如何使用值列表方式创建一个数组(Array)对象,其中tea数组包含了三个元素,并且其长度为3:
</p>
<pre class="eval">tea = ["绿茶", "红茶", "乌龙茶"];
</pre>
<p>You can construct a dense array of two or more elements starting with index 0 if you define initial values for all elements. A dense array is one in which each element has a value. The following code creates a dense array with three elements:
</p>
<pre class="eval">myArray = new Array("你好", myVar, 3.14159);
</pre>
<h4 name=".E7.B4.A2.E5.BC.95.E4.B8.80.E4.B8.AA.E6.95.B0.E7.BB.84"> 索引一个数组 </h4>
<p>你索引一个数组使用它自有的顺序。 例如, 假设你定义一个如下数组:
</p>
<pre class="eval">myArray = new Array("风", "雨", "火");
</pre>
<p>你可以用如下的方式来引用数组:
</p>
<ul><li> <code>myArray{{mediawiki.external(0)}}</code> 是第一个元素
</li><li> <code>myArray{{mediawiki.external(1)}}</code> 是第二个元素
</li><li> <code>myArray{{mediawiki.external(2)}}</code> 是第三个元素
</li></ul>
<h4 name=".E6.8C.87.E5.AE.9A.E5.8F.82.E6.95.B0"> 指定参数 </h4>
<p>在<code>Array</code> 构造器中如果仅仅指定了一个数字作为参数, 那么这个参数将作为数组的初始长度。下面的这个例子创建了一个包含有五个元素的数组:
</p>
<pre class="eval">billingMethod = new Array(5);
</pre>
<p>参数是否是一个简单的数字决定了<code>Array</code> 构造器的行为。
</p>
<ul><li> 如果参数就是一个数字,构造器会将数字转换成32bit无符号的整数,然后构造一个长度为该整数的数组,这时候数组的length属性值即为该整数,尽管数组还没有被赋值。
</li></ul>
<ul><li> 如果这个参数不是一个数字,那么构造器会创建一个长度为一的数组,数组的第一个元素的值就是该参数值。
</li></ul>
<p>下面的例子构造了一个长度为25的数组,并且给前三个元素赋值:
</p>
<pre class="eval">musicTypes = new Array(25);
musicTypes[0] = "R&amp;B";
musicTypes[1] = "Blues";
musicTypes[2] = "Jazz";
</pre>
<h4 name=".E9.97.B4.E6.8E.A5.E6.8C.87.E5.AE.9A.E6.95.B0.E7.BB.84.E9.95.BF.E5.BA.A6"> 间接指定数组长度 </h4>
<p>如果给数组赋值时指定的数组索数值引大于数组的当前长度,那么数组的长度就会自动的增加。在下面的例子中创建了一个长度为零的数组,然后对数组的99号元素赋值。这样的话数组的元素就增长到了100。
</p>
<pre class="eval">colors = new Array();
colors[99] = "midnightblue";
</pre>
<h4 name=".E4.BD.BF.E7.94.A8.E6.AD.A3.E5.88.99.E5.8C.B9.E9.85.8D.E7.9A.84.E7.BB.93.E6.9E.9C.E6.9D.A5.E5.88.9B.E5.BB.BA.E6.95.B0.E7.BB.84"> 使用正则匹配的结果来创建数组 </h4>
<p>正则表达式与字符串之间的匹配结果可以创建一个数组。这个数组包含了正则匹配的属性与匹配结果。RegExp.exec, String.match, 与 String.replace的返回值就是这样的数组。下面的例子可以帮助理解这些属性。
</p>
<pre class="eval">// Match one d followed by one or more b's followed by one d
// Remember matched b's and the following d
// 忽略大小写

myRe = /d(b+)(d)/i;
myArray = myRe.exec("cdbBdbsbz");
</pre>
<p>改正则匹配返回的属性/元素列表:
</p>
<table class="fullwidth-table">

<tbody><tr>
<td class="header">Property/Element
</td><td class="header">说明
</td><td class="header">例子
</td></tr>

<tr>
<td><code>input</code>
</td><td>原始的输入字符串,只读属性。
</td><td>cdbBdbsbz
</td></tr>

<tr>
<td><code>index</code>
</td><td>匹配的子字符串的第一个字符在原始字符串中的位置(从0开始的索引,只读)。
</td><td>1
</td></tr>

<tr>
<td><code>{{mediawiki.external(0)}}</code>
</td><td>最后一次匹配的元素,只读。
</td><td>dbBd
</td></tr>

<tr>
<td><code>{{mediawiki.external(1)}}, ...{{mediawiki.external('n')}}</code>
</td><td>出现在正则匹配中的子匹配(如果有)。
</td><td>{{mediawiki.external(1)}}: bB<br>{{mediawiki.external(2)}}: d
</td></tr>
</tbody></table>
<h3 name=".E5.85.88.E5.89.8D.E7.9A.84.E7.89.88.E6.9C.AC.E4.B8.AD.E7.9A.84.E8.A1.8C.E4.B8.BA"> 先前的版本中的行为 </h3>
<h4 name="JavaScript_1.2"> JavaScript 1.2 </h4>
<p>在JavaScript 1.2解析器中,如果将单一整型数字传递给数组的构造器,那么构造器仅仅会创建一个以该数字为第一个元素的、长度为1的数组。例如:
<code>
</code></p>
<pre class="eval">new Array(5) //创建了第一个元素是5的,仅包含一个元素的数组。
</pre>
<p>
</p>
<h4 name="JavaScript_1.0"> JavaScript 1.0 </h4>
<p>Indexing an array by its ordinal number was required; for example:
</p>
<pre class="eval"><code>myArray[0]</code>.
</pre>
<h3 name=".E5.B1.9E.E6.80.A7"> 属性 </h3>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/constructor">constructor</a></dt><dd> Specifies the function that creates an object's prototype.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/index">index</a></dt><dd> For an array created by a regular expression match, the zero-based index of the match in the string.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/input">input</a></dt><dd>  如果数组是通过正则表达式匹配创建的,返回原始的字符串。
</dd><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/length">length长度</a></dt><dd> 返回数组中元素个数.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/prototype">prototype</a></dt><dd> Allows the addition of properties to all objects.
</dd></dl>
</dd></dl>
<h3 name=".E6.96.B9.E6.B3.95"> 方法 </h3>
<h4 name="Mutator_.E6.96.B9.E6.B3.95"> Mutator 方法 </h4>
<p>这些方法可以改变数组自身:
</p>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/pop">pop</a></dt><dd> 移除数组的最后一个元素,返回值是被删除的元素。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/push">push</a></dt><dd> 在数组的末尾添加一个或者多个元素,返回值是新的数组的长度。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/reverse">reverse</a></dt><dd> 反转数组中元素的顺序,原先第一个元素现在变成最后一个,同样原先的最后一个元素变成了现在的第一个,也就是数组的索引发生了变化。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/shift">shift</a></dt><dd> 删除数组的第一个元素,返回值是删除的元素。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/sort">sort</a></dt><dd> 对数组中的元素进行排序。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/splice">splice</a></dt><dd> 添加或删除数组中的一个或多个元素。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/unshift">unshift</a></dt><dd> 添加一个或者多个元素在数组的开头,返回值是新的数组的长度。
</dd></dl>
</dd></dl>
<h4 name="Accessor_.E8.BF.87.E7.A8.8B"> Accessor 过程 </h4>
<p><span class="comment">need a better name...</span>
</p><p>这些过程不改变数组自身These methods do not modify the array and return some representation of the array.
</p>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/concat">concat</a></dt><dd> Returns a new array comprised of this array joined with other array(s) and/or value(s).
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/indexOf">indexOf</a></dt><dd> 返回第一个与给定参数相等的数组元素的索引,没有找到则返回-1。
</dd><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/join">join</a></dt><dd> 将所有的数组元素连接成一个字符串。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/lastIndexOf">lastIndexOf</a></dt><dd> 返回在数组中搜索到的与给定参数相等的元素的最后(最大)索引。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/slice">slice</a></dt><dd> Extracts a section of an array and returns a new array.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/toSource">toSource</a></dt><dd> Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the Object.toSource method.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/toString">toString</a></dt><dd> 返回代表该数组及其元素的字符,重写<a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Object/toString">Object.toString</a> 过程.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/valueOf">valueOf</a></dt><dd> Returns the primitive value of the array.  Overrides the <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Object/valueOf">Object.valueOf</a> method.
</dd></dl>
</dd></dl>
<h4 name="Iteration_methods.E9.87.8D.E5.A4.8D.E8.BF.87.E7.A8.8B"> Iteration methods重复过程 </h4>
<p>Several methods take as arguments functions to be called back while processing the array. When these methods are called, the <code>length</code> of the array is sampled, and any element added beyond this length from within the callback is not visited. Other changes to the array (setting the value of or deleting an element) may affect the results of the operation if the method visits the changed element afterwards. The specific behaviour of these methods in such cases is not always well-defined, and should not be relied upon.
</p>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/filter">filter</a></dt><dd> Creates a new array with all of the elements of this array for which the provided filtering function returns true.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/forEach">forEach</a></dt><dd> 对数组的每一个元素依次调用参数中指定的函数。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/every">every</a></dt><dd> 如果数组中每一个元素都满足参数中提供的测试函数,则返回真。
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/map">map</a></dt><dd> Creates a new array with the results of calling a provided function on every element in this array.
</dd></dl>
</dd></dl>
<dl><dd><dl><dt> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/some">some</a></dt><dd> Returns true if at least one element in this array satisfies the provided testing function.
</dd></dl>
</dd></dl>
<h4 name="Generic_.E8.BF.87.E7.A8.8B"> Generic 过程 </h4>
<p>Many methods on the JavaScript Array object are designed to be generally applied to all objects which "look like" Arrays.  That is, they can be used on any object which has a <code>length</code> property, and which can usefully be accessed using numeric property names (as with <code>array{{mediawiki.external(5)}}</code> indexing).
</p><p>TODO: give examples with Array.prototype.forEach.call, and adding the method to an object like <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/JavaArray">JavaArray</a> or <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/String">String</a>.
</p><p>Some methods, such as <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/join">join</a>, only read the <code>length</code> and numeric properties of the object they are called on.  Others, like <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/reverse">reverse</a>, require that the object's numeric properties and <code>length</code> be mutable; these methods can therefore not be called on objects like <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/String">String</a>, which does not permit its <code>length</code> property or synthesized numeric properties to be set.
</p><p>The methods that work on any Array-like object and do <b>not</b> need to alter <code>length</code> or numeric properties are:
</p>
<ul><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/concat">concat</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/every">every</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/filter">filter</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/forEach">forEach</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/indexOf">indexOf</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/join">join</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/lastIndexOf">lastIndexOf</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/map">map</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/slice">slice</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/some">some</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/toSource">toSource</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/toString">toString</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/valueOf">valueOf</a>
</li></ul>
<p>The methods that alter the <code>length</code> or numeric properties of the object they are called on are:
</p>
<ul><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/pop">pop</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/push">push</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/reverse">reverse</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/shift">shift</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/sort">sort</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/splice">splice</a>
</li><li> <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/unshift">unshift</a>
</li></ul>
<p>This example shows how to use <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/Array/map">map</a> on a <a href="cn/Core_JavaScript_1.5_Reference/Global_Objects/String">string</a> object to get an array of bytes in the ASCII encoding representing the character values:
</p>
<pre>var a = Array.prototype.map.call("Hello World", 
                                 function(x) { return x.charCodeAt(0); })
// a now equals [72,101,108,108,111,32,87,111,114,108,100]
</pre>
<h3 name=".E4.BE.8B.E5.AD.90"> 例子 </h3>
<h4 name=".E4.BE.8B.E5.AD.90.EF.BC.9A.E5.88.9B.E5.BB.BA.E6.95.B0.E7.BB.84"> 例子:创建数组 </h4>
<p>这个例子,创建了一个空数组,长度为0,接着对<code>msgArray{{mediawiki.external(0)}}</code>赋值,让后对<code>msgArray{{mediawiki.external(99)}}</code>赋值,数组长度变成了100。
</p>
<pre class="eval">var msgArray = new Array();
msgArray[0] = "你好";
msgArray[99] = "宝贝";
// 因为数组元素msgArray[99]已经定义,
// 所以下面的条件成立。
if (msgArray.length == 100)
   myVar = "数组的长度是100。";
</pre>
<h4 name=".E4.BE.8B.E5.AD.90.EF.BC.9A.E4.BA.8C.E7.BB.B4.E6.95.B0.E7.BB.84"> 例子:二维数组 </h4>
<p>这个例子创建了一个二维数组<code>myVar</code>,然后赋值。
</p>
<pre class="eval">var myVar = "二维数组实例;\n";
a = new Array(4);
for (var i = 0; i &lt; 4; i++) {
   a[i] = new Array(4);
   for (var j = 0; j &lt; 4; j++) {
      a[i][j] = "[" + i + "," + j + "]";
   }
}
for (var i = 0; i &lt; 4; i++) {
   str = "Row " + i + ":";
   for (var j = 0; j &lt; 4; j++) {
      str += a[i][j];
   }
   myVar += str + ";\n";
}
</pre>
<p>下面是<code>myVar</code>的值:
</p>
<pre class="eval">二维数组实例;
Row 0: [0,0][0,1][0,2][0,3];
Row 1: [1,0][1,1][1,2][1,3];
Row 2: [2,0][2,1][2,2][2,3];
Row 3: [3,0][3,1][3,2][3,3];
</pre>{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Array" } ) }}
恢复到这个版本