7. Массивы

Массив – это упорядоченная коллекция значений. Значения в массиве называются элементами, и каждый элемент характеризуется числовой позицией в массиве, которая называется индексом. Массивы в языке JavaScript являются нетипизированными: элементы массива могут иметь любой тип, причем разные элементы одного и того же массива могут иметь разные типы. Элементы массива могут даже быть объектами или другими массивами, что позволяет создавать сложные структуры данных, такие как массивы объектов и массивы массивов. Отсчет индексов массивов в языке JavaScript начинается с нуля, и для них используются 32-битные целые числа: первый элемент массива имеет индекс 0, а наибольший возможный индекс имеет значение (232), т. е. максимально возможный размер массива составляет 4294967295 элементов. Массивы в JavaScript являются динамическими: они могут увеличиваться и уменьшаться в размерах по мере необходимости; нет необходимости объявлять фиксированные размеры массивов при их создании или повторно распределять память при изменении их размеров. Массивы в JavaScript могут быть разреженными: не требуется, чтобы массив содержал элементы с непрерывной последовательностью индексов – в массивах могут отсутствовать элементы с некоторыми индексами. Все массивы в JavaScript имеют свойство length. Для неразреженных массивов это свойство определяет количество элементов в массиве. Для разреженных массивов значение length больше числа всех элементов в массиве.

Массивы в языке JavaScript – это специализированная форма объектов, а индексы массивов означают чуть больше, чем просто имена свойств, которые по совпадению являются целыми числами. Мы еще не раз будем говорить о специфических особенностях массивов повсюду в этой главе. Реализации обычно оптимизируют операции с массивами, благодаря чему доступ к элементам массивов по их числовым индексам выполняется значительно быстрее, чем доступ к обычным свойствам объектов.

Массивы наследуют свои свойства от прототипа Array.prototype, который определяет богатый набор методов манипулирования массивами, о которых рассказывается в разделах 7.8 и 7.9. Большинство из этих методов являются универсальными, т. е. они могут применяться не только к истинным массивам, но и к любым объектам, «похожим на массивы». Объекты, похожие на массивы, будут рассматриваться в разделе 7.11. В ECMAScript 5 строки ведут себя как массивы символов, и мы обсудим такое их поведение в разделе 7.12.

содержание 7.1. Создание массивов содержание

Легче всего создать массив с помощью литерала, который представляет собой простой список разделенных запятыми элементов массива в квадратных скобках. Например:

Значения в литерале массива не обязательно должны быть константами – это могут быть любые выражения:

var base = 1024;
var table = [base, base+1, base+2, base+3];

Литералы массивов могут содержать литералы объектов или литералы других массивов:

var b = [[1,{x:1, y:2}], [2, {x:3, y:4}]];

Если литерал массива содержит несколько идущих подряд запятых без значений между ними, создается разреженный массив (подробнее об этом рассказывается в разделе 7.3). Элементы, соответствующие таким пропущенным значениям, отсутствуют в массиве, но при обращении к ним возвращается значение undefined:

Синтаксис литералов массивов позволяет вставлять необязательную завершающую запятую, т. е. литерал [,,] соответствует массиву с двумя элементами, а не с тремя.

Другой способ создания массива состоит в вызове конструктора Array(). Вызвать конструктор можно тремя разными способами:

• Вызвать конструктор без аргументов:

var a = new Array();

В этом случае будет создан пустой массив, эквивалентный литералу [].

• Вызвать конструктор с единственным числовым аргументом, определяющим длину массива:

var a = new Array(10);

В этом случае будет создан пустой массив указанной длины. Такая форма вызова конструктора Array() может использоваться для предварительного распределения памяти под массив, если заранее известно количество его элементов. Обратите внимание, что при этом в массиве не сохраняется никаких значений и даже свойства-индексы массива с именами «0», «1» и т. д. в массиве не определены.

• Явно указать в вызове конструктора значения первых двух или более элементов массива или один нечисловой элемент (или более одного):

var a = new Array(5,4,3,2,1,"testing,testing");

В этом случае аргументы конструктора становятся значениями элементов нового массива. Использование литералов массивов практически всегда проще, чем подобное применение конструктора Array().

содержание 7.2. Чтение и запись элементов массива содержание

Доступ к элементам массива осуществляется с помощью оператора [ ]. Слева от скобок должна присутствовать ссылка на массив. Внутри скобок должно находиться произвольное выражение, возвращающее неотрицательное целое значение. Этот синтаксис пригоден как для чтения, так и для записи значения элемента массива. Следовательно, допустимы все приведенные далее JavaScript-инструкции:

Напомню, что массивы являются специализированной разновидностью объектов. Квадратные скобки, используемые для доступа к элементам массива, действуют точно так же, как квадратные скобки, используемые для доступа к свойствам объекта. Интерпретатор JavaScript преобразует указанные в скобках числовые индексы в строки – индекс 1 превращается в строку "1", – а затем использует строки как имена свойств. В преобразовании числовых индексов в строки нет ничего особенного: то же самое можно проделывать с обычными объектами:

Особенность массивов состоит в том, что при использовании имен свойств, которые являются неотрицательными целыми числами, не превышающими 232-2, массивы автоматически определяют значение свойства length. Например, выше был создан массив a с единственным элементом. Затем были присвоены значения его элементам с индексами 1, 2 и 3. В результате этих операций значение свойства length массива изменилось:

Следует четко отличать индексы в массиве от имен свойств объектов. Все индексы являются именами свойств, но только свойства с именами, представленными целыми числами в диапазоне от 0 до 232-2 являются индексами. Все массивы являются объектами, и вы можете добавлять к ним свойства с любыми именами. Однако если вы затрагиваете свойства, которые являются индексами массива, массивы реагируют на это, при необходимости обновляя значение свойства length.

Обратите внимание, что в качестве индексов массивов допускается использовать отрицательные и нецелые числа. В этом случае числа преобразуются в строки, которые используются как имена свойств. Когда имя свойства не является неотрицательным целым числом, оно интерпретируется как имя обычного свойства объекта, а не как индекс массива. Кроме того, при индексировании массива строками, которые являются представлениями неотрицательных целых чисел, они интерпретируются как индексы массива, а не как свойства объекта. То же относится и к вещественным числам, не имеющим дробной части:

То обстоятельство, что индексы массива являются всего лишь особой разновидностью имен свойств объекта, означает, что для массивов JavaScript отсутствует понятие ошибки «выхода за границы». Попытка получить значение любого несуществующего свойства любого объекта не рассматривается как ошибка, в этом случае просто возвращается значение undefined. To же относится и к массивам:

Поскольку массивы фактически являются объектами, они могут наследовать элементы от своих прототипов. В ECMAScript 5 массивы могут даже иметь элементы, определяющие методы чтения и записи (раздел 6.6). Если массив наследует элементы или элементы в нем имеют методы доступа, доступ к такому массиву не оптимизируется интерпретатором: время доступа к элементам такого массива будет сопоставимо с временем поиска обычных свойств объекта.

содержание 7.3. Разреженные массивы содержание

Разреженным называется массив, индексы элементов которого не образуют непрерывную последовательность чисел, начиная с 0. Обычно свойство length массива определяет количество элементов в массиве. В разреженном массиве значение свойства length больше количества элементов. Разреженный массив можно создать с помощью конструктора Array() или путем присваивания значения элементу с индексом, большим, чем текущая длина массива.

Далее будет показано, что разреженный массив можно также создать с помощью оператора delete.

Существенно разреженные массивы обычно более медленны и потребляют больше памяти, чем плотные массивы, а поиск элементов в таких массивах занимает примерно столько же времени, что и поиск обычных свойств объектов.

Обратите внимание, что литералы с пропущенными значениями (когда в определении подряд следуют запятые, например [1, ,3]) создают разреженные массивы, в которых пропущенные элементы просто не существуют:

=========================

Некоторые старые реализации (такие как Firefox 3) некорректно вставляли элементы со значением undefined на место пропущенных элементов. В этих реализациях литерал [1,,3] был эквивалентен литералу [[1,undefined,3].

содержание 7.4. Длина массива содержание

Любой массив имеет свойство length, и это свойство отличает массивы от обычных объектов JavaScript. Для плотных (т. е. неразреженных) массивов свойство length определяет количество элементов в массиве. Его значение на единицу больше самого большого индекса в массиве:

Для разреженных массивов значение свойства length больше числа элементов, и все, что можно сказать в этом случае, – это то, что значение свойства length гарантированно будет превышать индекс любого элемента в массиве. Или, говоря иначе, массивы (разреженные или нет) никогда не будут содержать элемент, индекс которого будет больше или равен значению свойства length массива. Для поддержки этого свойства массивы проявляют две особенности поведения. Первая была описана выше: если присвоить значение элементу массива, индекс i которого больше или равен текущему значению свойства length, в свойство length записывается значение i + 1.

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

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

В ECMAScript 5 свойство length массива можно сделать доступным только для чтения, с помощью Object.defineProperty() (раздел 6.7):

Аналогично, если сделать элемент массива ненастраиваемым, его нельзя будет удалить. Если элемент нельзя будет удалить, то и свойство length не может быть установлено в значение, меньшее или равное индексу ненастраиваемого элемента. (Смотрите раздел 6.7, а также описание методов Object.seal() и Object.freeze() в разделе 6.8.3.)

содержание 7.5. Добавление и удаление элементов массива содержание

Мы уже видели, что самый простой способ добавить элементы в массив заключается в том, чтобы присвоить значения новым индексам:

Для добавления одного или более элементов в конец массива можно также использовать метод push():

Добавить элемент в конец массива можно также, присвоив значение элементу a[a.length].

Для вставки элемента в начало массива можно использовать метод unshift()) (описывается в разделе 7.8), при этом существующие элементы в массиве смещаются в позиции с более высокими индексами.

Удалять элементы массива можно с помощью оператора delete, как обычные свойства объектов:

Удаление элемента напоминает (но несколько отличается) присваивание значения undefined этому элементу. Обратите внимание, что применение оператора delete к элементу массива не изменяет значение свойства length и не сдвигает вниз элементы с более высокими индексами, чтобы заполнить пустоту, оставшуюся после удаления элемента. После удаления элемента массив превращается в разреженный массив.

Кроме того, как уже было показано выше, имеется возможность удалять элементы в конце массива простым присваиванием нового значения свойству length. Массивы имеют метод pop() (противоположный методу push()), который уменьшает длину массива на 1 и возвращает значение удаленного элемента. Также имеется метод shift() (противоположный методу unshift()), который удаляет элемент в начале массива. В отличие от оператора delete, метод shift() сдвигает все элементы вниз на позицию ниже их текущих индексов. Методы pop() и shift() описываются в разделе 7.8 и в справочном разделе.

Наконец существует многоцелевой метод splice(), позволяющий вставлять, удалять и замещать элементы массивов. Он изменяет значение свойства length и сдвигает элементы массива с более низкими или высокими индексами по мере необходимости. Подробности приводятся в разделе 7.8

содержание 7.6. Обход элементов массива содержание

Наиболее часто для обхода элементов массива используется цикл for (раздел 5.5.3):

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

В этих примерах предполагается, что выполняется обход плотного массива и все элементы содержат допустимые значения. В противном случае необходимо организовать проверку значений элементов массива перед их использованием. Если желательно исключить из обработки значения null, undefined и несуществующие элементы, проверку можно записать так:

Если необходимо пропустить только значение undefined и несуществующие лементы, проверку можно записать так:

Наконец, если необходимо пропустить только несуществующие элементы, а элементы со значением undefined обрабатывать как обычные элементы, проверку можно записать так:

Для обхода разреженных массивов можно также использовать цикл for/in (раздел 5.5.4). Этот цикл присваивает имена перечислимых свойств (включая индексы массива) переменной цикла. Отсутствующие индексы в итерациях не участвуют:

Как отмечалось в разделе 6.5, цикл for/in может возвращать имена унаследованных свойств, такие как имена методов, добавленных в Array.prototype. По этой причине не следует использовать цикл for/in для обхода массивов, не предусмотрев дополнительной проверки для фильтрации нежелательных свойств. Для этого можно было бы использовать, например, такие проверки:

Спецификация ЕСМ AScript допускает возможность обхода свойств объекта в цикле for/in в любом порядке. Обычно реализации обеспечивают обход индексов массивов в порядке возрастания, но это не гарантируется. В частности, если массив имеет и свойства объекта, и элементы массива, имена свойств могут возвращаться в порядке их создания, а не в порядке возрастания числовых значений. Разные реализации по-разному обрабатывают эту ситуацию, поэтому, если для вашего алгоритма порядок выполнения итераций имеет значение, вместо цикла for/in лучше использовать обычный цикл for.

Стандарт ECMAScript 5 определяет множество новых методов, позволяющих выполнять итерации по элементам массивов в порядке возрастания индексов и передавать их функции, определяемой пользователем. Наиболее типичным представителем этих методов является метод forEach():

forEach() и другие родственные методы, предназначенные для выполнения итераций, позволяют использовать при работе с массивами простой и мощный стиль функционального программирования. Они описываются в разделе 7.9, и еще раз мы вернемся к ним в разделе 8.8, когда будем рассматривать приемы функционального программирования.

содержание 7.7. Многомерные массивы содержание

JavaScript не поддерживает «настоящие» многомерные массивы, но позволяет неплохо имитировать их при помощи массивов из массивов. Для доступа к элементу данных в массиве массивов достаточно дважды использовать оператор []. Например, предположим, что переменная matrix – это массив массивов чисел. Каждый элемент matrix[x] – это массив чисел. Для доступа к определенному числу в массиве можно использовать выражение matrix[x][y] . Ниже приводится конкретный пример, где двумерный массив используется в качестве таблицы умножения:

содержание 7.8. Методы класса Array содержание

Стандарт ECMAScript 3 определяет в составе Array.prototype множество удобных функций для работы с массивами, которые доступны как методы любого массива. Эти методы будут представлены в следующих подразделах. Более полную информацию можно найти в разделе Array в справочной части по базовому языку JavaScript. Стандарт ECMAScript 5 определяет дополнительные методы для выполнения итераций по массивам – эти методы рассматриваются в разделе 7.9.

содержание 7.8.1. Метод join()

Метод Array.join() преобразует все элементы массива в строки, объединяет их и возвращает получившуюся строку. В необязательном аргументе методу можно передать строку, которая будет использоваться для отделения элементов в строке результата. Если строка-разделитель не указана, используется запятая. Например, следующий фрагмент дает в результате строку «1,2,3»:

Метод Array.join() является обратным по отношению к методу String.split(), создающему массив путем разбиения строки на фрагменты.

содержание 7.8.2. Метод reverse()

Метод Array.reverse() меняет порядок следования элементов в массиве на обратный и возвращает переупорядоченный массив. Перестановка выполняется непосредственно в исходном массиве, т. е. этот метод не создает новый массив с переупорядоченными элементами, а переупорядочивает их в уже существующем массиве. Например, следующий фрагмент, где используются методы reverse() и join(), дает в результате строку "3,2,1":

содержание 7.8.3. Метод sort()

Метод Array.sort() сортирует элементы в исходном массиве и возвращает отсортированный массив. Если метод sort() вызывается без аргументов, сортировка выполняется в алфавитном порядке (для сравнения элементы временно преобразуются в строки, если это необходимо):

Неопределенные элементы переносятся в конец массива.

Для сортировки в каком-либо ином порядке, отличном от алфавитного, методу sort() можно передать функцию сравнения в качестве аргумента. Эта функция устанавливает, какой из двух ее аргументов должен следовать раньше в отсортированном списке. Если первый аргумент должен предшествовать второму, функция сравнения должна возвращать отрицательное число. Если первый аргумент должен следовать за вторым в отсортированном массиве, то функция должна возвращать число больше нуля. А если два значения эквивалентны (т. е. порядок их следования не важен), функция сравнения должна возвращать 0. Поэтому, например, для сортировки элементов массива в числовом порядке можно сделать следующее:

Обратите внимание, насколько удобно использовать в этом фрагменте неименованную функцию. Функция сравнения используется только здесь, поэтому нет необходимости давать ей имя.

В качестве еще одного примера сортировки элементов массива можно реализовать сортировку массива строк без учета регистра символов, передав функцию сравнения, преобразующую свои аргументы в нижний регистр (с помощью метода toLowerCase()) перед сравнением.

содержание 7.8.4. Метод concat()

Метод Array.concat() создает и возвращает новый массив, содержащий элементы исходного массива, для которого был вызван метод concat(), и значения всех аргументов, переданных методу concat(). Если какой-либо из этих аргументов сам является массивом, его элементы добавляются в возвращаемый массив. Следует, однако, отметить, что рекурсивного превращения массива из массивов в одномерный массив не происходит. Метод concat() не изменяет исходный массив. Ниже приводится несколько примеров:

содержание 7.8.5. Метод slice()

Метод Array.slice() возвращает фрагмент, или подмассив, указанного массива. Два аргумента метода определяют начало и конец возвращаемого фрагмента. Возвращаемый массив содержит элемент, номер которого указан в первом аргументе, плюс все последующие элементы, вплоть до (но не включая) элемента, номер которого указан во втором аргументе. Если указан только один аргумент, возвращаемый массив содержит все элементы от начальной позиции до конца массива. Если какой-либо из аргументов имеет отрицательное значение, он определяет номер элемента относительно конца массива. Так, аргументу -1 соответствует последний элемент массива, а аргументу -3 – третий элемент массива с конца. Вот несколько примеров:

содержание 7.8.6. Метод splice()

Метод Array.splice() – это универсальный метод, выполняющий вставку или удаление элементов массива. В отличие от методов slice() и concat(), метод splice() изменяет исходный массив, относительно которого он был вызван. Обратите внимание, что методы splice() и slice() имеют очень похожие имена, но выполняют совершенно разные операции.

Метод splice() может удалять элементы из массива, вставлять новые элементы или выполнять обе операции одновременно. Элементы массива при необходимости смещаются, чтобы после вставки или удаления образовывалась непрерывная последовательность. Первый аргумент метода splice() определяет позицию в массиве, начиная с которой будет выполняться вставка и/или удаление. Второй аргумент определяет количество элементов, которые должны быть удалены (вырезаны) из массива. Если второй аргумент опущен, удаляются все элементы массива от указанного до конца массива. Метод splice() возвращает массив удаленных элементов или (если ни один из элементов не был удален) пустой массив. Например:

Первые два аргумента метода splice() определяют элементы массива, подлежащие вырезанию. За этими аргументами может следовать любое количество дополнительных аргументов, определяющих элементы, которые будут вставлены в массив, начиная с позиции, указанной в первом аргументе. Например:

Обратите внимание, что одномерные массивы метод splice(), в отличие от метода concat(), вставляет целиком, а не их элементы.

содержание 7.8.7. Методы push() и pop()

Методы push() и pop() позволяют работать с массивами как со стеками. Метод push() добавляет один или несколько новых элементов в конец массива и возвращает его новую длину. Метод pop() выполняет обратную операцию – удаляет последний элемент массива, уменьшает длину массива и возвращает удаленное им значение. Обратите внимание, что оба эти метода изменяют исходный массив, а не создают его модифицированную копию. Комбинация push() и pop() позволяет на основе массива реализовать стек с дисциплиной обслуживания «первым вошел – последним вышел». Например:

содержание 7.8.8. Методы unshift() и shift()

Методы unshift() и shift() ведут себя почти так же, как push() и pop(), за исключением того, что они вставляют и удаляют элементы в начале массива, а не в конце. Метод unshift() смещает существующие элементы в сторону больших индексов для освобождения места, добавляет элемент или элементы в начало массива и возвращает новую длину массива. Метод shift() удаляет и возвращает первый элемент массива, смещая все последующие элементы на одну позицию вниз, чтобы занять место, освободившееся в начале массива. Например:

Обратите внимание на поведение метода unshift() при вызове с несколькими аргументами. Аргументы вставляются не по одному, а все сразу (как в случае с методом splice()). Это значит, что в результирующем массиве они будут следовать в том же порядке, в котором были указаны в списке аргументов. Будучи вставленными по одному, они бы расположились в обратном порядке.

содержание 7.8.9. Методы toString() и toLocaleString()

Массивы, как и любые другие объекты в JavaScript, имеют метод toString(). Для массива этот метод преобразует каждый его элемент в строку (вызывая в случае необходимости методы toString() элементов массива) и выводит список этих строк через запятую. Примечательно, что результат не включает квадратные скобки или какие-либо другие разделители вокруг значений массива. Например:

Обратите внимание, что toString() возвращает ту же строку, что и метод join() при вызове его без аргументов.

Метод toLocaleString() – это локализованная версия toString(). Каждый элемент массива преобразуется в строку вызовом метода toLocaleString() элемента, а затем полученные строки объединяются с использованием специфического для региона (и определяемого реализацией) разделителя.

содержание 7.9. Методы класса Array, определяемые стандартом ECMAScript 5 содержание

Стандарт ECMAScript 5 определяет девять новых методов массивов, позволяющих выполнять итерации, отображение, фильтрацию, проверку, свертку и поиск. Все эти методы описываются в следующих далее подразделах.

Однако, прежде чем перейти к изучению особенностей, следует сделать некоторые обобщения, касающиеся методов массивов в ECMAScript 5. Во-первых, большинство описываемых ниже методов принимают функцию в первом аргументе и вызывают ее для каждого элемента (или нескольких элементов) массива. В случае разреженных массивов указанная функция не будет вызываться для несуществующих элементов. В большинстве случаев указанной функции передаются три аргумента: значение элемента массива, индекс элемента и сам массив. Чаще всего вам необходим будет только первый аргумент, а второй и третий аргументы можно просто игнорировать. Большинство методов массивов, введенных стандартом ECMAScript 5, которые в первом аргументе принимают функцию, также принимают второй необязательный аргумент. Если он указан, функция будет вызываться, как если бы она была методом этого второго аргумента. То есть второй аргумент будет доступен функции, как значение ключевого слова this. Значение, возвращаемое функцией, играет важную роль, но разные методы обрабатывают его по-разному. Ни один из методов массивов, введенных стандартом ECMAScript 5, не изменяет исходный массив. Разумеется, функция, передаваемая этим методам, может модифицировать исходный массив.

содержание 7.9.1. Метод forEach()

Метод forEach() выполняет обход элементов массива и для каждого из них вызывает указанную функцию. Как уже говорилось выше, функция передается методу forEach() в первом аргументе. При вызове этой функции метод forEach() будет передавать ей три аргумента: значение элемента массива, индекс элемента и сам массив. Если вас интересует только значение элемента, можно написать функцию с одним параметром – дополнительные аргументы будут игнорироваться:

============================

Обратите внимание, что метод forEach() не позволяет прервать итерации, пока все элементы не будут переданы функции. То есть отсутствует эквивалент инструкции break, которую можно использовать с обычным циклом for. Если потребуется прервать итерации раньше, внутри функции можно возбуждать исключение, а вызов forEach() помещать в блок try. Ниже демонстрируется функция forEach(), вызывающая метод forEach() внутри такого блока try. Если функция, которая передается функции forEach(), возбудит исключение forEach.break, цикл будет прерван преждевременно:

содержание 7.9.2. Метод map()

Метод map() передает указанной функции каждый элемент массива, относительно которого он вызван, и возвращает массив значений, возвращаемых этой функцией. Например:

Метод map() вызывает функцию точно так же, как и метод forEach(). Однако функция, передаваемая методу map(), должна возвращать значение. Обратите внимание, что map() возвращает новый массив: он не изменяет исходный массив. Если исходный массив является разреженным, возвращаемый массив также будет разреженным: он будет иметь ту же самую длину и те же самые отсутствующие элементы.

содержание 7.9.3. Метод filter()

Метод filter() возвращает массив, содержащий подмножество элементов исходного массива. Передаваемая ему функция должна быть функцией-предикатом, т. е. должна возвращать значение true или false. filter() вызывает функцию точно так же, как методы forEach() и map(). Если возвращается true или значение, которое может быть преобразовано в true, переданный функции элемент считается членом подмножества и добавляется в массив, возвращаемый методом. Например:

Обратите внимание, что метод filter() пропускает отсутствующие элементы в разреженных массивах и всегда возвращает плотные массивы. Чтобы уплотнить разреженный массив, можно выполнить следующие действия:

var dense = sparse.filter(function() { return true; });

А чтобы уплотнить массив и удалить из него все элементы со значениями undefined и null, можно использовать метод filter(), как показано ниже:

a = a.filter(function(x) { return x !== undefined && x != null; });

содержание 7.9.4. Методы every() и some()

Методы every() и some() являются предикатами массива: они применяют указанную функцию-предикат к элементам массива и возвращают true или false. Метод every() напоминает математический квантор всеобщности ∀: он возвращает true, только если переданная вами функция-предикат вернула true для всех элементов массива:

Метод some() напоминает математический квантор существования ∃: он возвращает true, если в массиве имеется хотя бы один элемент, для которого функция-предикат вернет true, а значение false возвращается методом, только если функция-предикат вернет false для всех элементов массива:

Обратите внимание, что оба метода, every() и some(), прекращают обход элементов массива, как только результат становится известен. Метод some() возвращает true, как только функция-предикат вернет true, и выполняет обход всех элементов массива, только если функция-предикат всегда возвращает false. Метод every() является полной противоположностью: он возвращает false, как только функция-предикат вернет false, и выполняет обход всех элементов массива, только если функция-предикат всегда возвращает true. Кроме того, отметьте, что в соответствии с правилами математики для пустого массива метод every() возвращает true, а метод some() возвращает false.

содержание 7.9.5. Методы reduce() и reduceRight()

Методы reduce() и reduceRight() объединяют элементы массива, используя указанную вами функцию, и возвращают единственное значение. Это типичная операция в функциональном программировании, где она известна также под названием «свертка». Приведенные ниже примеры помогут понять суть этой операции:

Метод reduce() принимает два аргумента. В первом передается функция, которая выполняет операцию свертки. Задача этой функции – объединить некоторым способом или свернуть два значения в одно и вернуть свернутое значение. В примерах выше функции выполняют объединение двух значений, складывая их, умножая и выбирая наибольшее. Во втором (необязательном) аргументе передается начальное значение для функции.

Функции, передаваемые методу reduce(), отличаются от функций, передаваемых методам forEach() и map(). Привычные значение, индекс и массив передаются во втором, третьем и четвертом аргументах. А в первом аргументе передается накопленный результат свертки. При первом вызове в первом аргументе функции передается начальное значение, переданное методу reduce() во втором аргументе. Во всех последующих вызовах передается значение, полученное в результате предыдущего вызова функции. В первом примере, из приведенных выше, функция свертки сначала будет вызвана с аргументами 0 и 1. Она сложит эти числа и вернет 1. Затем она будет вызвана с аргументами 1 и 2 и вернет 3. Затем она вычислит 3 + 3 = 6, затем 6 + 4 = 10 и, наконец, 10 + 5 = 15. Это последнее значение 15 будет возвращено методом reduce().

Возможно, вы обратили внимание, что в третьем вызове, в приведенном примере, методу reduce() передается единственный аргумент: здесь не указано начальное значение. Когда метод reduce() вызывается без начального значения, как в данном случае, в качестве начального значения используется первый элемент массива. Это означает, что при первом вызове функции свертки будут переданы первый и второй элементы массива. В примерах вычисления суммы и произведения точно так же можно было бы опустить аргумент с начальным значением. Вызов метода reduce() с пустым массивом без начального значения вызывает исключение TypeError. Если вызвать метод с единственным значением – с массивом, содержащим единственный элемент, и без начального значения или с пустым массивом и начальным значением – он просто вернет это единственное значение, не вызывая функцию свертки.

Метод reduceRight() действует точно так же, как и метод reduce(), за исключением того, что массив обрабатывается в обратном порядке, от больших индексов к меньшим (справа налево). Это может потребоваться, если операция свертки имеет ассоциативность справа налево, например:

Обратите внимание, что ни reduce(), ни reduceRight() не принимают необязательный аргумент, определяющий значение this внутри функции свертки. Его место занял необязательный аргумент с начальным значением. Если потребуется вызывать функцию свертки как метод конкретного объекта, можно воспользоваться методом Function.bind(). Следует отметить, что методы every() и some(), описанные выше, являются своеобразной разновидностью операции свертки массива. Однако они отличаются от reduce() тем, что стремятся завершить обход массива как можно раньше и не всегда проверяют значения всех его элементов.

В примерах, представленных до сих пор, для простоты использовались числовые массивы, но методы reduce() и reduceRight() могут использоваться не только для математических вычислений. Взгляните на функцию union() в примере 6.2. Она вычисляет «объединение» двух объектов и возвращает новый объект, имеющий свойства обоих. Эта функция принимает два объекта и возвращает другой объект, т. е. она действует как функция свертки, поэтому ее можно использовать с методом reduce() и обобщить операцию создания объединения произвольного числа объектов:

Напомню, что, когда два объекта имеют свойства с одинаковыми именами, функция union() использует значение свойства второго аргумента, т. е. reduce() и reduceRight() могут давать разные результаты при использовании с функцией union():

содержание 7.9.6. Методы indexOf() и lastIndexOf()

Методы indexOf() и lastIndexOf() отыскивают в массиве элемент с указанным значением и возвращают индекс первого найденного элемента или -1, если элемент с таким значением отсутствует. Метод indexOf() выполняет поиск от начала массива к концу, а метод lastIndexOf() – от конца к началу.

В отличие от других методов, описанных в этом разделе, методы indexOf() и lastIndexOf() не принимают функцию в виде аргумента. В первом аргументе им передается искомое значение. Второй аргумент является необязательным: он определяет индекс массива, с которого следует начинать поиск. Если опустить этот аргумент, метод indexOf() начнет поиск с начала массива, а метод lastIndexOf() – с конца. Во втором аргументе допускается передавать отрицательные значения, которые интерпретируются как смещение относительно конца массива, как в методе splice(): значение -1, например, соответствует последнему элементу массива.

Следующая функция отыскивает заданное значение в массиве и возвращает массив всех индексов, где было найдено совпадение. Здесь демонстрируется, как можно использовать второй аргумент метода indexOf() для поиска совпадений после первого.

Обратите внимание, что строки также имеют методы indexOf() и lastlndexOf (), которые действуют подобно методам массивов.

содержание 7.10. Тип Array содержание

На протяжении этой главы мы не раз имели возможность убедиться, что массивы являются объектами, обладающими особыми чертами поведения. Получая неизвестный объект, иногда бывает полезно проверить, является он массивом или нет. Сделать это в реализации ECMAScript 5 можно с помощью функции Array.isArray():

Однако до выхода стандарта ECMAScript 5 отличить массивы от других объектов было удивительно сложно. Оператор typeof никак не помогает в этом: для массивов он возвращает строку «object» (и для всех других объектов, кроме функций). В простых случаях можно использовать оператор instanceof:

Проблема применения оператора instanceof состоит в том, что в веб-браузерах может быть открыто несколько окон или фреймов. Каждое окно или фрейм имеет собственное окружение JavaScript, с собственным глобальным объектом. А каждый глобальный объект имеет собственное множество функций-конструкторов. Поэтому объект из одного фрейма никогда не будет определяться как экземпляр конструктора в другом фрейме. Даже при том, что путаница между фреймами возникает довольно редко, тем не менее этого вполне достаточно, чтобы считать оператор instanceof ненадежным средством определения принадлежности к массивам.

Решение заключается в том, чтобы выполнить проверку атрибута class (раздел 6.8.2) объекта. Для массивов этот атрибут всегда будет иметь значение «Array», благодаря чему в реализации ECMAScript 3 функцию isArray() можно определить так:

var isArray = Function.isArray || function(o) {
  return typeof о === "object" &&
    Object.prototype.toString.call(o) === "'[object Array]";
};

Фактически именно такая проверка атрибута class выполняется в функции Array.isArray(), определяемой стандартом ECMAScript 5. Прием определения класса объекта с помощью Object. prototype.toString() был описан в разделе 6.8.2 и продемонстрирован в примере 6.4.

содержание 7.11. Объекты, подобные массивам содержание

Как мы уже видели, массивы в языке JavaScript обладают некоторыми особенностями, отсутствующими в других объектах:

• Добавление нового элемента вызывает автоматическое обновление свойства length.

• Уменьшение значения свойства length вызывает усечение массива.

• Массивы наследуют множество удобных методов от Array.prototype.

• Атрибут class массивов имеет значение «Array».

Все эти характеристики отличают массивы в языке JavaScript от других объектов. Но они не главное, что определяет массив. Часто бывает удобно организовать работу с произвольным объектом, как со своего рода массивом – через свойство length и соответствующие неотрицательные целочисленные свойства.

Такие объекты, «подобные массивам», иногда используются для решения практических задач, и хотя с ними нельзя работать через методы массивов или ожидать специфического поведения свойства length, все же можно организовать перебор свойств объекта теми же программными конструкциями, которые используются при работе с настоящими массивами. Оказывается, что значительное число алгоритмов для работы с массивами вполне пригодно для работы с объектами, подобными массивам. Это особенно верно, если используемые алгоритмы не изменяют массивы или хотя бы не затрагивают его свойство length.

В следующем фрагменте создается обычный объект и к нему добавляются дополнительные свойства, которые превращают его в объект, подобный массиву, после чего производится перебор «элементов» получившегося псевдомассива:

Объект Arguments, который описывается в разделе 8.3.2, является объектом, подобным массиву. В клиентском языке JavaScript такие объекты возвращаются многими методами объектной модели документа (DOM), такими как метод document.getElementsByTagName(). Следующая функция проверяет, является ли объект подобным массиву:

В разделе 7.12 будет показано, что строки в ECMAScript 5 ведут себя подобно массивам (и некоторые браузеры обеспечивали возможность обращения к символам в строке по индексам еще до выхода ECMAScript 5). Однако проверки на подобие массивам, такие как приведенная выше, для строк обычно возвращают false – с ними лучше работать как со строками, чем как с массивами.

Методы массивов в языке JavaScript преднамеренно были сделаны достаточно универсальными, чтобы их можно было использовать не только с настоящими массивами, но и с объектами, подобными массивам. В ECMAScript 5 все методы массивов являются универсальными. В ECMAScript 3 универсальными также являются все методы, за исключением toString() и toLocaleString(). (К исключениям также относится метод concat(): несмотря на то что его можно применять к объектам, подобным массивам, он некорректно разворачивает объекты в возвращаемый массив.) Поскольку объекты, подобные массивам, не наследуют свойства от Array.prototype, к ним нельзя напрямую применить методы массивов. Однако их можно вызывать косвенно с помощью метода Function.call():

Мы уже встречались с таким использованием метода call() в разделе 7.10, где описывался метод isArray(). Метод call() объектов класса Function детально рассматривается в разделе 8.7.3. Методы массивов, определяемые в ECMAScript 5, были введены в Firefox 1.5. Поскольку они имели универсальную реализацию, в Firefox также были введены версии этих методов в виде функций, объявленных непосредственно в конструкторе Array. Если использовать эти версии методов, приведенные выше примеры можно переписать так (в Google Chrome не работает: Uncaught TypeError: Array.join is not a function):

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

Array.join = Array.join || function(a.sep) {
return Array.prototype.join.call(a,sep);
};
Array.slice = Array.slice || function(a,from,to) {
return Array.prototype.slice.call(a,from,to);
};
Array.map = Array.map || function(a, f, thisArg) {
return Array.prototype.map.call(a, f, thisArg);
}

содержание 7.12. Строки как массивы содержание

В ECMAScript 5 (и во многих последних версиях браузеров, включая IE8, появившихся до выхода стандарта ECMAScript 5) строки своим поведением напоминают массивы, доступные только для чтения. Вместо метода charAt() для обращения к отдельным символам можно использовать квадратные скобки:

Оператор typeof для строк все так же возвращает «string», а если строку передать методу Array.isArray(), он вернет false.

Основное преимущество, которое дает поддержка индексирования строк, – это возможность заменить вызов метода charAt() квадратными скобками и получить более краткий, удобочитаемый и, возможно, более эффективный программный код. Однако тот факт, что строки своим поведением напоминают массивы, означает также, что к ним могут применяться универсальные методы массивов. Например:

Имейте в виду, что строки являются неизменяемыми значениями, поэтому при работе с ними как с массивами их следует интерпретировать как массивы, доступные только для чтения. Такие методы массивов, как push(), sort, reverse() и splice(), изменяют исходный массив и не будут работать со строками. Однако попытка изменить строку с помощью метода массива не вызовет ошибку - строка просто не изменится.