Многомерные массивы

JavaScript не поддерживает «настоящие» многомерные массивы, но позволяет неплохо имитировать их при помощи массивов из массивов. Для доступа к элементу данных в массиве массивов достаточно использовать оператор [] дважды.

Например, предположим, что переменная matrix – это массив массивов чисел.

Любой элемент matrix[x] – это массив чисел. Для доступа к определенному числу в массиве надо написать matrix[x][y]. Вот конкретный пример, в котором двухмерный массив используется в качестве таблицы умножения:

//Создать многомерный массив

var table = new Array(10);// В таблице 10 строк

for(var i = 0; i < table.length; i++)

table[i] = new Array(10);// В каждой строке 10 столбцов

for(var row = 0; row < table.length; row++) {

for(col = 0; col < table[row].length; col++) {

table[row][col] = row*col; // Инициализация массива

}

}// Расчет произведения 5*7 с помощью многомерного массива

var product = table[5][7];// 35

Типичным примером двухмерного массива является массив опций меню. У такого меню есть горизонтальная панель с опциями, называемая главным меню. Некоторым опциям главного меню соответствуют раскрывающиеся вертикальные подменю со своими опциями. Мы создаем массив, длина которого равна количеству опций главного меню. Элементы этого массива определяем как массивы названий опций соответствующих подменю.

Чтобы была ясна структура нашей конструкции, выберем названия опций надлежащим образом. Например, "Меню 2.1" — название 1-й опции подменю, соответствующего 2-й опции главного меню.

menu = new Array()

menu[0] = new Array ("Меню 1.1", "Меню 1.2", ", "Меню 1.3")

menu[l] = new Array("Меню 2.1", "Меню 2 . 2 " )

menu[2] = new Array ("Меню 3.1", "Меню 3 . 2 " , "Меню 3 . 3 " , "Меню 3.4")

Чтобы обратиться ко 2-й опции 3-го подменю, следует написать:

menu[2][l] // значение равно "Меню 3 . 2 "

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

menu = new Array()

/* Массив опций главного меню: */

menu[0] = new Array("Меню1", "Меню2", "МенюЗ")

menu[l] = new Array()

menu[l][0] = new Array("Меню 1.1". "Меню 1.2", "Меню 1.3")

menu[l][l] = new Array("Меню 2.1", "Меню 2 . 2 " )

menu[l][2] = new Array("Меню 3.1", "Меню 3 . 2 " , "МенюЗ.3", "Меню 3.4")

menu[0][l] // значение равно "Меню 2"

menu[0][2]// значение равно "Меню 3"

menu[l][1][0]// значение равно "Меню 2.1"

menu[1][2][3] //значение равно "Меню 3 . 2 "

Методы массивов

Помимо оператора [] с массивами можно работать посредством различных методов, предоставляемых классом Array.

à Метод join()

Метод Array.join() преобразует все элементы массива в строки и объединяет их.

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

var a = [1, 2, 3]; //Создает новый массив с указанными тремя элементами

var s = a.join(); //s == "1,2,3"

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

s = a.join(", "); // s == "1, 2, 3"

Обратите внимание на пробел после запятой.

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

à Метод reverse()

Метод Array.reverse() меняет порядок следования элементов в массиве на противоположный и возвращает массив с переставленными элементами. Он делает это на месте, другими словами, этот метод не создает новый массив с переупорядоченными элементами, а переупорядочивает их в уже существующем массиве.

Например, следующий фрагмент, где используются методы reverse() и join(), дает в результате строку "3,2,1":

var a = new Array(1,2,3);// a[0] = 1, a[1] = 2, a[2] = 3

a.reverse();// теперь a[0] = 3, a[1] = 2, a[2] = 1

var s = a.join();// s == "3,2,1"

à Метод sort()

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

var a = new Array("banana", "cherry", "apple");

A.sort();

var s = a.join(", "); // s == "apple, banana, cherry"

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

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

var a = [33, 4, 1111, 222];

a.sort();// Алфавитный порядок: 1111, 222, 33, 4

a.sort(function(a,b) { //Числовой порядок: 4, 33, 222, 1111

return a-b; //Возвращает значение < 0, 0, или > 0

});// в зависимости от порядка сортировки a и b

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

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

à Метод concat()

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

var a = [1,2,3];

a.concat(4, 5) // Возвращает [1,2,3,4,5]

a.concat([4,5]); // Возвращает [1,2,3,4,5]

a.concat([4,5],[6,7]) // Возвращает [1,2,3,4,5,6,7]

a.concat(4, [5,[6,7]]) // Возвращает [1,2,3,4,5,[6,7]]

à Метод slice()

Метод Array.slice() возвращает фрагмент, или подмассив, указанного массива.

Два аргумента метода определяют начало и конец возвращаемого фрагмента.

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

var a = [1,2,3,4,5];

a.slice(0,3); // Возвращает [1,2,3]

a.slice(3); // Возвращает [4,5]

a.slice(1,-1); // Возвращает [2,3,4]

a.slice(-3,-2); // Возвращает [3]

à Метод splice()

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

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

var a = [1,2,3,4,5,6,7,8];

a.splice(4); //Возвращает [5,6,7,8]; a равно [1,2,3,4]

a.splice(1,2); //Возвращает [2,3]; a равно [1,4]

a.splice(1,1); //Возвращает [4]; a равно [1]

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

var a = [1,2,3,4,5];

a.splice(2,0,'a','b'); //Возвращает []; a равно [1,2,'a','b',3,4,5]

a.splice(2,2,[1,2],3); //Возвращает ['a','b']; a равно [1,2,[1,2],3,3,4,5]

Обратите внимание, что, в отличие от concat(), метод splice() не разбивает на отдельные элементы вставляемые аргументы-массивы. То есть если методу передается массив для вставки, он вставляет сам массив, а не элементы этого массива.

à Методы push() и pop()

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

var stack = [];// стек: []

stack.push(1,2); //стек: [1,2] Возвращает 2

stack.pop(); //стек: [1] Возвращает 2

stack.push(3); //стек: [1,3] Возвращает 2

stack.pop();// стек: [1] Возвращает 3

stack.push([4,5]); //стек: [1,[4,5]] Возвращает 2

stack.pop()// стек: [1] Возвращает [4,5]

stack.pop();// стек: [] Возвращает 1

à Методы unshift() и shift()

Методы unshift() и shift() ведут себя во многом так же, как push() и pop(), за исключением того, что они вставляют и удаляют элементы в начале массива, а не в его конце.

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

var a = []; // a:[]

a.unshift(1); // a:[1] Возвращает: 1

a.unshift(22); // a:[22,1] Возвращает: 2

a.shift(); // a:[1] Возвращает: 22

a.unshift(3,[4,5]); // a:[3,[4,5],1] Возвращает: 3

a.shift(); // a:[[4,5],1] Возвращает: 3

a.shift(); // a:[1] Возвращает: [4,5]

a.shift(); // a:[] Возвращает: 1

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

à Методы toString() и toLocaleString()

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

[1,2,3].toString() // Получается '1,2,3'

["a", "b", "c"].toString() // Получается 'a,b,c'

[1, [2,'c']].toString() // Получается '1,2,c'

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

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