Array

  • Revision slug: JavaScript/Reference/Global_Objects/Array
  • Revision title: Array
  • Revision id: 412283
  • Created:
  • Creator: BedyNN
  • Is current revision? Нет
  • комментировать Перевод дополнен.

Revision Content

Summary

JavaScript Array глобальный объект конструктор для массивов, который на высоком уровне представляет списко объектов.

Syntax

[element0, element1, ..., elementN]
new Array(element0, element1, ..., elementN)
new Array(arrayLength)
element0, element1, ..., elementN
JavaScript массив инициализируется с помощью элементов, за исключением случая когда один аргумент передается в конструктор Array  и аргумент является числом. (Смотри ниже) Стоит обратить внимание это особый случай применимый только в JavaScript массивах созданных с помощью Array конструктора, без использования скобочного синтаксиса.
arrayLength
Если только аргумент переданный Array конструктору число между 0 и 232-1 (включительно) , новый пустой JavaScript массив и длина устанавливается этим числом. Если аргумент любое другое число то возникает исключение RangeError .

Description

Массив как список объектов, что можно достичь с помощью разных встроенных методов и выполнять различные операции по его изменению. Ни размер массива JavaScript ни типы элементов не являются фиксированными. С того момента как массиву установлен размер он может возрастать или сокращаться в любой момент времени, нет гарантии что JavaScript массивы плотные (имеется в виду что при работе и создании массива есть шанс что элемент к которому вы обратитесь будет пустым и вернет undefined). В общем это удобная характеристика; но если эта особенность является не желательна для вашего специфического случая , вы можете применить WebGL тип массивов.

Стоит обратить внимание что использовать массив как ассоциативный массив не желательно. Вы можете использовать простой объект вместо этого, но там есть и свои особенности. Смотрите пост "Lightweight JavaScript dictionaries with arbitrary key" как пример.

Accessing array elements

JS массивы с нулевым индексом; первый элемент массива фактически имеет индекс равный 0, а последний элемент его индекс эквивалентен значению свойства массива length минус 1.

var arr = ["this is the first element", "this is the second element"];
console.log(arr[0]);              // prints "this is the first element"
console.log(arr[1]);              // prints "this is the second element"
console.log(arr[arr.length - 1]); // prints "this is the second element"

Элементы массива это свойства объекта например как toString. Однако попытка доступа к первому элементу массива вызовет синтаксическую ошибку:

console.log(arr.0);

Стоит обратить внимание, что ничего уникального в массивах JavaScript нет и их свойствах, которые начинаются с цифры и на них нельзя сослаться через точечный синтаксис. Например, если у вас есть объект со свойством "3d", то сослаться на него можно будет только через синтаксис "квадратных" скобок. Это заметно в следующем примере:

var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
try {
  console.log(years.0);
}
catch (ex) {
  console.log("Using bracket notation");
  console.log(years[0]);
}
try {
  renderer.3d.setTexture(model, "character.png");
}
catch (ex) {
  console.log("Using bracket notation");
  renderer["3d"].setTexture(model, "character.png");
}

Обратим внимание что в примере 3d заключено в кавычки "3d". Можно взглянуть на обращение к элементу массива years["2"] и years[2], то тут необходимости в кавычках нет т.к. движок JS сам приведет значение к строке, во всяком случае через неявное преобразование toString. Именно по этой причине "2" и "02" будут относится к двум различным слотам объекта years и в следующем пример получаем true:

console.log(years["2"] != years["02"]);

Relationship between length and numerical properties

Свойство JS массивовlength и числовое свойство взаимосвязаны. Различные методы встроенные в массив (e.g., join, slice, indexOf, etc.) take into account the value of an array's length property when they're called. Результатом действий остальных методов также является обновление свойства length.

var fruits = [];
fruits.push("banana", "apple", "peach");

console.log(fruits.length); // 3

При установке свойства JS массива когда свойство доступно через индекс массива и индекс выходит за текущие границы массива, массив будет расти до размера достаточно большого чтобы разместить элемент с этим индексом, а движок будет обновлять свойство массива length соответственно:

fruits[3] = "mango";
console.log(fruits[3]);
console.log(fruits.length); // 4

Установка свойства length , напрямую также привод к к расширению массива до указанной длинны.

fruits.length = 10;
console.log(fruits);        // The array gets padded with undefined
console.log(fruits.length); // 10

Все особенности поведения объясняются на странице посвященной length.

Creating an array using the result of a match

Результат совпадения между регулярным выражением и строкой может создать JavaScript массив. Этот массив имеет свойства и элементы что дает избыточную информацию о совпадении. Массив здесь это возвращенное значение 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
// Ignore case

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

Свойства и элементы возвращаемые из данного совпадения описаны ниже:

 

Свойство/Элемент Описание Пример
input

Свойство только для чтения отражает оригинальную строку к которой подбиралось регулярной выражение.

cdbBdbsbz
index

Свойство только для чтения, в нулевом индексе расположено совпадения со строкой.

1
[0] A read-only element that specifies the last matched characters. dbBd
[1], ...[n]

Элемент только для чтения в них доступны совпавшие подстроки которые совпали с регулярным выражением. Число доступных подстрок не ограничено.

[1]: bB
[2]: d

Properties

{{ Js_see_prototype("Array", "Properties") }}

prototype
Allows the addition of properties to all objects.
{{ jsOverrides("Function", "Properties", "prototype") }}

Methods

{{ Js_see_prototype("Array", "Methods") }}
isArray {{ js_minversion_inline("1.8.5") }}

Возвращает true если переменная это массив, если нет то false

Array instances

Array instances inherit from Array.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all JavaScript Array instances.

Properties

{{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties') }}

Methods

Mutator methods

{{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods') }}

Accessor methods

{{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods') }}

Iteration methods

{{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods') }}

Array generic methods

Время от времени вы захотите применить методы массива к строке или массив-подобному объекту (такому как аргумент функции). Делая это вы обрабатываете строку как массив символов (иначе относитесь к не массиву как массиву). Для примера, в порядке проверки что каждый символ в переменной str это буква, вы пишите:

function isLetter(character) {
  return (character >= "a" && character <= "z");
}

if (Array.prototype.every.call(str, isLetter))
  alert("The string '" + str + "' contains only letters!");

Эта запись довольно расточительна и в JavaScript 1.6 введен общий сокращенный вид:

if (Array.every(str, isLetter))
  alert("The string '" + str + "' contains only letters!");

Generics are also available on String.

These are currently not part of ECMAScript standards (though the ES6 Array.from() can be used to achieve this). The following is a shim to allow its use in all browsers:

/*globals define*/
// Assumes Array extras already present (one may use shims for these as well)
(function () {
    'use strict';

    var i,
        // We could also build the array of methods with the following, but the
        //   getOwnPropertyNames() method is non-shimable:
        // Object.getOwnPropertyNames(Array).filter(function (methodName) {return typeof Array[methodName] === 'function'});
        methods = [
            'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
            'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
            'forEach', 'map', 'reduce', 'reduceRight', 'filter',
            'some', 'every', 'isArray'
        ],
        methodCount = methods.length,
        assignArrayGeneric = function (methodName) {
            var method = Array.prototype[methodName];
            Array[methodName] = function (arg1) {
                return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
            };
        };

    for (i = 0; i < methodCount; i++) {
        assignArrayGeneric(methods[i]);
    }
}());

Examples

Example: Creating an array

Следующий пример создает массив msgArray с длиной равно 0, затем присваивается значение msgArray[0] и msgArray[99] , что изменяет длинну массива до 100.

The following example creates an array, msgArray, with a length of 0, then assigns values to msgArray[0] and msgArray[99], changing the length of the array to 100.

var msgArray = new Array();
msgArray[0] = "Hello";
msgArray[99] = "world";

if (msgArray.length == 100)
   print("The length is 100.");

Example: Creating a two-dimensional array

Следует создание шахматной доски из двумерного массива строк. Первый ход сделан и копирует 'p' в 4,4 из 6,4. Старая позиция 6,4 будет пустой.

var board = 
[ ['R','N','B','Q','K','B','N','R'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['r','n','b','q','k','b','n','r']];
print(board.join('\n') + '\n\n');

// Move King's Pawn forward 2
board[4][4] = board[6][4];
board[6][4] = ' ';
print(board.join('\n'));

Ниже показан вывод:

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , ,p, , , 
 , , , , , , , 
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r

Browser compatibility

{{ CompatibilityTable }}

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari (WebKit)
Basic support {{ CompatVersionUnknown }} {{ CompatVersionUnknown }} {{ CompatVersionUnknown }} {{ CompatVersionUnknown }} {{ CompatVersionUnknown }}
Feature Android Firefox Mobile (Gecko) IE Phone Opera Mobile Safari Mobile
Basic support {{ CompatVersionUnknown }} {{ CompatVersionUnknown }} {{ CompatVersionUnknown }} {{ CompatVersionUnknown }} {{ CompatVersionUnknown }}

See also

Revision Source

<h2 id="Summary">Summary</h2>
<p>JavaScript <code>Array</code> глобальный объект конструктор для массивов, который на высоком уровне представляет списко объектов.</p>
<h2 id="Syntax">Syntax</h2>
<pre class="syntaxbox">
[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
new Array(<em>element0</em>, <em>element1</em>, ..., <em>elementN</em>)
new Array(<em>arrayLength</em>)
</pre>
<dl>
  <dt>
    <code><var>element0</var>, <var>element1</var>, ..., <var>elementN</var> </code></dt>
  <dd>
    JavaScript массив инициализируется с помощью элементов, за исключением случая когда один аргумент передается в конструктор <code>Array&nbsp;</code> и аргумент является числом. (Смотри ниже) Стоит обратить внимание это особый случай применимый только в JavaScript массивах созданных с помощью <code>Array</code> конструктора, без использования скобочного синтаксиса.</dd>
  <dt>
    <code><var>arrayLength</var></code></dt>
  <dd>
    Если только аргумент переданный <code>Array </code>конструктору число между 0 и 2<sup>32</sup>-1 (включительно) , новый пустой JavaScript массив и длина устанавливается этим числом. Если аргумент любое другое число то возникает исключение <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/RangeError" title="JavaScript/Reference/Global_Objects/RangeError">RangeError</a></code> .</dd>
</dl>
<h2 id="Description">Description</h2>
<p style="margin-bottom: 0cm">Массив как список объектов, что можно достичь с помощью разных встроенных методов и выполнять различные операции по его изменению. Ни размер массива JavaScript ни типы элементов не являются фиксированными. С того момента как массиву установлен размер он может возрастать или сокращаться в любой момент времени, нет гарантии что JavaScript массивы плотные (имеется в виду что при работе и создании массива есть шанс что элемент к которому вы обратитесь будет пустым и вернет undefined). В общем это удобная характеристика; но если эта особенность является не желательна для вашего специфического случая , вы можете применить WebGL тип массивов.</p>
<p style="margin-bottom: 0cm">Стоит обратить внимание что <a href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/" title="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/">использовать массив как ассоциативный массив не желательно</a>. Вы можете использовать простой <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object">объект</a> вместо этого, но там есть и свои особенности. Смотрите пост "<a href="http://monogatari.doukut.su/2010/12/lightweight-javascript-dictionaries.html" title="http://monogatari.doukut.su/2010/12/lightweight-javascript-dictionaries.html">Lightweight JavaScript dictionaries with arbitrary key</a>" как пример.</p>
<h3 id="Accessing_array_elements">Accessing array elements</h3>
<p style="margin-bottom: 0cm">JS массивы с нулевым индексом; первый элемент массива фактически имеет индекс равный 0, а последний элемент его индекс эквивалентен значению свойства массива <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length">length</a> минус 1.</p>
<pre class="brush: js">
var arr = ["this is the first element", "this is the second element"];
console.log(arr[0]);              // prints "this is the first element"
console.log(arr[1]);              // prints "this is the second element"
console.log(arr[arr.length - 1]); // prints "this is the second element"
</pre>
<p style="margin-bottom: 0cm">Элементы массива это свойства объекта например как <a href="/en-US/docs/toString" title="/en-US/docs/toString">toString</a>. Однако попытка доступа к первому элементу массива вызовет синтаксическую ошибку:</p>
<pre class="brush: js">
console.log(arr.0);
</pre>
<p style="margin-bottom: 0cm">Стоит обратить внимание, что ничего уникального в массивах JavaScript нет и их свойствах, которые начинаются с цифры и на них нельзя сослаться через точечный синтаксис. Например, если у вас есть объект со свойством "3d", то сослаться на него можно будет только через синтаксис "квадратных" <span lang="ru-RU">скоб</span><span lang="en-US">о</span><span lang="ru-RU">к</span>. Это заметно в следующем примере:</p>
<pre class="brush: js">
var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
try {
  console.log(years.0);
}
catch (ex) {
  console.log("Using bracket notation");
  console.log(years[0]);
}
</pre>
<pre class="brush: js">
try {
  renderer.3d.setTexture(model, "character.png");
}
catch (ex) {
  console.log("Using bracket notation");
  renderer["3d"].setTexture(model, "character.png");
}
</pre>
<p style="margin-bottom: 0cm">Обратим внимание что в примере <code>3d</code> заключено в кавычки "<code>3d</code>". Можно взглянуть на обращение к элементу массива <code>years["2"]</code> и <code>years[2]</code>, то тут необходимости в кавычках нет т.к. движок JS сам приведет значение к строке, во всяком случае через неявное преобразование <code>toString</code>. Именно по этой причине "2" и "02" будут относится к двум различным слотам объекта <code>years</code> и в следующем пример получаем <code>true</code>:</p>
<pre class="brush: js">
console.log(years["2"] != years["02"]);
</pre>
<h3 id="Relationship_between_length_and_numerical_properties">Relationship between <code>length</code> and numerical properties</h3>
<p style="margin-bottom: 0cm">Свойство JS массивов<code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length" title="JavaScript/Reference/Global_Objects/Array/length">length</a></code> и числовое свойство взаимосвязаны. Различные методы встроенные в массив (e.g., <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/join" title="JavaScript/Reference/Global_Objects/Array/join">join</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice" title="JavaScript/Reference/Global_Objects/Array/slice">slice</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf" title="JavaScript/Reference/Global_Objects/Array/indexOf">indexOf</a></code>, etc.) take into account the value of an array's <code>length</code> property when they're called. Результатом действий остальных методов также является обновление свойства length.</p>
<pre class="brush: js">
var fruits = [];
fruits.push("banana", "apple", "peach");

console.log(fruits.length); // 3</pre>
<p style="margin-bottom: 0cm">При установке свойства JS массива когда свойство доступно через индекс массива и индекс выходит за текущие границы массива, массив будет расти до размера достаточно большого чтобы разместить элемент с этим индексом, а движок будет обновлять свойство массива <code>length</code> соответственно:</p>
<pre class="brush: js">
fruits[3] = "mango";
console.log(fruits[3]);
console.log(fruits.length); // 4</pre>
<p style="margin-bottom: 0cm">Установка свойства <code>length</code> , напрямую также привод к к расширению массива до указанной длинны.</p>
<pre class="brush: js">
fruits.length = 10;
console.log(fruits);        // The array gets padded with undefined
console.log(fruits.length); // 10
</pre>
<p style="margin-bottom: 0cm">Все особенности поведения объясняются на странице посвященной <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length" title="JavaScript/Reference/Global_Objects/Array/length"><code>length</code></a>.</p>
<h3 id="Creating_an_array_using_the_result_of_a_match">Creating an array using the result of a match</h3>
<p style="margin-bottom: 0cm">Результат совпадения между регулярным выражением и строкой может создать JavaScript массив. Этот массив имеет свойства и элементы что дает избыточную информацию о совпадении. Массив здесь это возвращенное значение RegExp.exec, String.match и String.replace. Чтобы проще было понять откуда какие появились&nbsp; свойства и элементы посмотрите следующий пример и обратитесь к таблице ниже:</p>
<pre class="brush: js">
// Match one d followed by one or more b's followed by one d
// Remember matched b's and the following d
// Ignore case

var myRe = /d(b+)(d)/i;
var myArray = myRe.exec("cdbBdbsbz");
</pre>
<p style="margin-bottom: 0cm">Свойства и элементы возвращаемые из данного совпадения описаны ниже:</p>
<p style="margin-bottom: 0cm">&nbsp;</p>
<table class="fullwidth-table">
  <tbody>
    <tr>
      <td class="header">Свойство/Элемент</td>
      <td class="header">Описание</td>
      <td class="header">Пример</td>
    </tr>
    <tr>
      <td><code>input</code></td>
      <td>
        <p style="margin-bottom: 0cm">Свойство только для чтения отражает оригинальную строку к которой подбиралось регулярной выражение.</p>
      </td>
      <td>cdbBdbsbz</td>
    </tr>
    <tr>
      <td><code>index</code></td>
      <td>
        <p style="margin-bottom: 0cm">Свойство только для чтения, в нулевом индексе расположено совпадения со строкой.</p>
      </td>
      <td>1</td>
    </tr>
    <tr>
      <td><code>[0]</code></td>
      <td>A read-only element that specifies the last matched characters.</td>
      <td>dbBd</td>
    </tr>
    <tr>
      <td><code>[1], ...[n]</code></td>
      <td>
        <p style="margin-bottom: 0cm">Элемент только для чтения в них доступны совпавшие подстроки которые совпали с регулярным выражением. Число доступных подстрок не ограничено.</p>
      </td>
      <td>[1]: bB<br />
        [2]: d</td>
    </tr>
  </tbody>
</table>
<h2 id="Properties">Properties</h2>
<p>{{ Js_see_prototype("Array", "Properties") }}</p>
<dl>
  <dt>
    <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/prototype" title="JavaScript/Reference/Global_Objects/Array/prototype">prototype</a></dt>
  <dd>
    Allows the addition of properties to all objects.</dd>
</dl>
<div>
  {{ jsOverrides("Function", "Properties", "prototype") }}</div>
<h2 id="Methods">Methods</h2>
<div>
  {{ Js_see_prototype("Array", "Methods") }}</div>
<dl>
  <dt>
    <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray" title="JavaScript/Reference/Global Objects/Array/isArray">isArray</a> {{ js_minversion_inline("1.8.5") }}</dt>
  <dd>
    <p style="margin-bottom: 0cm">Возвращает true если переменная это массив, если нет то false</p>
  </dd>
</dl>
<h2 id="Array_instances"><code>Array</code> instances</h2>
<p><code>Array</code> instances inherit from<span style="font-family: monospace;"> <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/prototype" title="Core_JavaScript_1.5_Reference/Global_Objects/Array/prototype">Array.prototype</a></code></span>. As with all constructors, you can change the constructor's prototype object to make changes to all JavaScript <code>Array</code> instances.</p>
<h3 id="Properties_of_Array_instances" name="Properties_of_Array_instances">Properties</h3>
<div>
  {{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties') }}</div>
<h3 id="Methods_of_Array_instances" name="Methods_of_Array_instances">Methods</h3>
<h4 id="Mutator_methods">Mutator methods</h4>
<div>
  {{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods') }}</div>
<h4 id="Accessor_methods"><span>Accessor methods</span></h4>
<div>
  {{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods') }}</div>
<h4 id="Iteration_methods"><span>Iteration methods</span></h4>
<div>
  {{ page('ru/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods') }}</div>
<h2 id="Array_generic_methods"><code>Array</code> generic methods</h2>
<p style="margin-bottom: 0cm">Время от времени вы захотите применить методы массива к строке или массив-подобному объекту (такому как <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">аргумент</a> функции). Делая это вы обрабатываете строку как массив символов (иначе относитесь к не массиву как массиву). Для примера, в порядке проверки что каждый символ в переменной <var>str </var>это буква, вы пишите:</p>
<pre class="brush: js">
function isLetter(character) {
  return (character &gt;= "a" &amp;&amp; character &lt;= "z");
}

if (Array.prototype.every.call(str, isLetter))
  alert("The string '" + str + "' contains only letters!");
</pre>
<p style="margin-bottom: 0cm">Эта запись довольно расточительна и в JavaScript 1.6 введен общий сокращенный вид:</p>
<pre class="brush: js">
if (Array.every(str, isLetter))
  alert("The string '" + str + "' contains only letters!");
</pre>
<p><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String#String_generic_methods" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String#String_generic_methods">Generics</a> are also available on <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String"><code>String</code></a>.</p>
<p>These are currently not part of ECMAScript standards (though the ES6 <a href="https://github.com/monolithed/ECMAScript-6" title="https://github.com/monolithed/ECMAScript-5"><code>Array.from()</code></a> can be used to achieve this). The following is a shim to allow its use in all browsers:</p>
<pre class="brush: js">
/*globals define*/
// Assumes Array extras already present (one may use shims for these as well)
(function () {
&nbsp;&nbsp;&nbsp; 'use strict';

&nbsp;&nbsp;&nbsp; var i,
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // We could also build the array of methods with the following, but the
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; //&nbsp;&nbsp; getOwnPropertyNames() method is non-shimable:
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // Object.getOwnPropertyNames(Array).filter(function (methodName) {return typeof Array[methodName] === 'function'});
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; methods = [
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 'forEach', 'map', 'reduce', 'reduceRight', 'filter',
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 'some', 'every', 'isArray'
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ],
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; methodCount = methods.length,
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; assignArrayGeneric = function (methodName) {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; var method = Array.prototype[methodName];
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Array[methodName] = function (arg1) {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; };
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; };

&nbsp;&nbsp;&nbsp; for (i = 0; i &lt; methodCount; i++) {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; assignArrayGeneric(methods[i]);
&nbsp;&nbsp;&nbsp; }
}());</pre>
<h2 id="Examples">Examples</h2>
<h3 id="Example.3A_Creating_an_array">Example: Creating an array</h3>
<p style="margin-bottom: 0cm">Следующий пример создает массив <code>msgArray</code> с длиной равно 0, затем присваивается значение <code>msgArray[0]</code> и <code>msgArray[99]</code> , что изменяет длинну массива до 100.</p>
<p>The following example creates an array, <code>msgArray</code>, with a length of 0, then assigns values to <code>msgArray[0]</code> and <code>msgArray[99]</code>, changing the length of the array to 100.</p>
<pre class="brush: js">
var msgArray = new Array();
msgArray[0] = "Hello";
msgArray[99] = "world";

if (msgArray.length == 100)
   print("The length is 100.");
</pre>
<h3 id="Example.3A_Creating_a_two-dimensional_array">Example: Creating a two-dimensional array</h3>
<p style="margin-bottom: 0cm">Следует создание шахматной доски из двумерного массива строк. Первый ход сделан и копирует 'p' в 4,4 из 6,4. Старая позиция 6,4 будет пустой.</p>
<pre class="brush: js">
var board = 
[ ['R','N','B','Q','K','B','N','R'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['r','n','b','q','k','b','n','r']];
print(board.join('\n') + '\n\n');

// Move King's Pawn forward 2
board[4][4] = board[6][4];
board[6][4] = ' ';
print(board.join('\n'));
</pre>
<p style="margin-bottom: 0cm">Ниже показан вывод:</p>
<pre class="eval">
R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , ,p, , , 
 , , , , , , , 
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r
</pre>
<h2 id="Browser_compatibility" name="Browser_compatibility">Browser compatibility</h2>
<p>{{ CompatibilityTable }}</p>
<div id="compat-desktop">
  <table class="compat-table">
    <tbody>
      <tr>
        <th>Feature</th>
        <th>Chrome</th>
        <th>Firefox (Gecko)</th>
        <th>Internet Explorer</th>
        <th>Opera</th>
        <th>Safari (WebKit)</th>
      </tr>
      <tr>
        <td>Basic support</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
      </tr>
    </tbody>
  </table>
</div>
<div id="compat-mobile">
  <table class="compat-table">
    <tbody>
      <tr>
        <th>Feature</th>
        <th>Android</th>
        <th>Firefox Mobile (Gecko)</th>
        <th>IE Phone</th>
        <th>Opera Mobile</th>
        <th>Safari Mobile</th>
      </tr>
      <tr>
        <td>Basic support</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
        <td>{{ CompatVersionUnknown }}</td>
      </tr>
    </tbody>
  </table>
</div>
<h2 id="See_also" name="See_also">See also</h2>
<ul>
  <li><a href="/en-US/docs/JavaScript/Guide/Working_with_Objects#Indexing_object_properties" title="JavaScript/Guide/Working_with_objects#Indexing_object_properties">"Indexing object properties" in JavaScript Guide: "Working with objects"</a></li>
  <li><a href="/en-US/docs/JavaScript/New_in_JavaScript/1.7#Array_comprehensions" title="New_in_JavaScript_1.7#Array_comprehensions">New in JavaScript 1.7: Array comprehensions</a></li>
  <li><a href="/en-US/docs/JavaScript/New_in_JavaScript/1.6#Array_extras" title="New_in_JavaScript_1.6#Array_extras">New in JavaScript 1.6: Array extras</a></li>
  <li><a href="/en-US/docs/JavaScript_typed_arrays" title="JavaScript_typed_arrays">Draft: Typed Arrays</a></li>
</ul>
<!-- languages({
  "fr": "fr/JavaScript/R%C3%A9f%C3%A9rence_JavaScript/Objets_globaux/Array",
})-->
Revert to this revision