Массивы

Массив - это упорядоченная коллекция значений. Значения в массиве называются элементами, и каждый элемент характеризуется числовой позицией в массиве, которая называется индексом. Массивы в языке JavaScript являются нетипизированными: элементы массива могут иметь любой тип, причем разные элементы одного и того же массива могут иметь разные типы. Элементы массива могут даже быть объектами или другими массивами, что позволяет создавать сложные структуры данных, такие как массивы объектов и массивы массивов.

Отсчет индексов массивов в языке JavaScript начинается с нуля и для них используются 32-битные целые числа - первый элемент массива имеет индекс 0. Массивы в JavaScript являются динамическими: они могут увеличиваться и уменьшаться в размерах по мере необходимости; нет необходимости объявлять фиксированные размеры массивов при их создании или повторно распределять память при изменении их размеров.

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

Создание массивов

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

Var empty = ; // Пустой массив var numbers = ; // Массив с пятью числовыми элементами var misc = [ 1.1, true, "a", ]; // 3 элемента разных типов + завершающая запятая var base = 1024; var table = ; // Массив с переменными var arrObj = [, ]; // 2 массива внутри, содержащие объекты

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

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

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

Var arr = new Array();

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

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

Var arr = new Array(10);

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

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

Var arr = new Array(5, 4, 3, 2, 1, "тест");

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

Чтение и запись элементов массива

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

// Создать массив с одним элементом var arr = ["world"]; // Прочитать элемент 0 var value = arr; // Записать значение в элемент 1 arr = 3.14; // Записать значение в элемент 2 i = 2; arr[i] = 3; // Записать значение в элемент 3 arr = "привет"; // Прочитать элементы 0 и 2, записать значение в элемент 3 arr] = arr;

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

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

Var obj = {}; // Создать простой объект obj = "one"; // Индексировать его целыми числами

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

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

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

Добавление и удаление элементов массива

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

Var arr = ; // Создать пустой массив arr.push("zero"); // Добавить значение в конец arr.push("one",2); // Добавить еще два значения

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

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

Var arr = ; delete arr; 2 in arr; // false, индекс 2 в массиве не определен arr.length; // 3: оператор delete не изменяет свойство length массива

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

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

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

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

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

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

// Создать многомерный массив var table = new Array(10); // В таблице 10 строк for(var i = 0; i

Методы класса Array

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

Метод join()

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

Var arr = ; arr.join(); // "1,2,3" arr.join("-"); // "1-2-3"

Метод reverse()

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

Var arr = ; arr.reverse().join(); // "3,2,1"

Метод sort()

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

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

Var arr = ; arr.sort(); // Алфавитный порядок: 1111, 222, 33, 4 arr.sort(function(a,b) { // Числовой порядок: 4, 33, 222, 1111 return a-b; // Возвращает значение 0 // в зависимости от порядка сортировки a и b }); // Сортируем в обратном направлении, от большего к меньшему arr.sort(function(a,b) {return b-a});

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

Метод concat()

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

Var arr = ; arr.concat(4, 5); // Вернет arr.concat(); // Вернет arr.concat(,) // Вернет arr.concat(4, ]) // Вернет ]

Метод slice()

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

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

Var arr = ; arr.slice(0,3); // Вернет arr.slice(3); // Вернет arr.slice(1,-1); // Вернет arr.slice(-3,-2); // Вернет

Метод splice()

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

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

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

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

Var arr = ; arr.splice(4); // Вернет , arr = arr.splice(1,2); // Вернет , arr = arr.splice(1,1); // Вернет ; arr = arr = ; arr.splice(2,0,"a","b"); // Вернет ; arr =

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

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

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

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

Всем доброго времени суток. На связи Алексей Гулынин. В прошлой статье мы разобрали конструкцию switch case в javascript . В данной статье я бы хотел рассказать, что такое массивы в Javascript . Понятие массива играет важную роль не только в Javascript, но и во всем программировании. Переменная, типа массив, содержит в себе не один элемент, а несколько. Синтаксис создания массива следующий:

Var mas = new Array(значение1, значение2,..., значениеN);

В данном случае создаётся переменная mas типа массив со значениями, указанными в скобках. Обращаю ваше внимание, что массив создаётся с помощью ключевого слова new. Обращаться к элементам массива можно, указав имя массива и в квадратных скобках индекс массива. Индекс массива задаётся с нуля. Давайте приведу пример массива, состоящего из 4 элементов и выведу 2 элемент:

var mas = new Array("privet", 1, 10, 5); document.write("Второй элемент массива = "+mas); // будет выведено число 10

Если мы поставим mas , то будет выведено "privet" , так как индексация массива начинается с нуля. Давайте теперь разберемся, как вывести все элементы массива. Для этого нужно воспользоваться циклом. Помимо знания циклов в Javascript , необходимо знать свойство массивов length , которое возвращает количество элементов массива (или по-другому его длину). Давайте выведем длину массива mas :

var mas = new Array("privet", 1, 10, 5); document.write("Длина массива = "+mas.length); // будет выведено число 4

Вывод всех элементов массива:

var mas = new Array("privet", 1, 10, 5); var i; for (i = 0; i < mas.length; i++) document.write(mas[i]+" ");

Пока что, мы с вами рассматривали одномерные массивы. Вообще массивы могут быть многомерными. Главное необходимо понимать, что, например двумерный массив — это массив элементами которого являются массивы. Давайте с вами разберем такую задачу: необходимо создать двумерный массив 3 на 3, элементы которого задаются пользователем и вывести этот массив. Здесь будем использовать оператор prompt для запроса числа у пользователя:

var mas = new Array(); //объявляем массив const n = 3; //объявляем константу, т.е. массив у нас размером 3 на 3 //для задания двумерного массива необходимо использовать двойной цикл var i; var j; for (i = 0; i < n; i++) { mas[i] = new Array();//Здесь мы как раз каждый элемент массива делаем массивом for (j = 0; j < n; j++) { mas[i][j] = prompt("[" + i +","+j+"]= " ,"..."); //запрашиваем число у пользователя } } for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { document.write("[" + i +","+j+"]= "+ mas[i][j]);} //выводим элемент массива document.write("
"); //переход на новую строку после каждой заполненной строки массива }

В нашем случае двумерный массив соответствует (для примера) такой структуре: mas=[,,] . Видно, что у массива 3 элемента, каждый из которых является сам массивом.

Изначально задача Javascript’а была в том, чтобы делать динамические сайты. В своей практике я нигде не использовал двумерные массивы, только одномерные, так что тех знаний по массивам, которые вы получили из данной статьи, будет вполне достаточно. В одной из следующих статей я расскажу об объекте Array , его свойствах и методах.

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

Предположим, что переменная matrix представляет собой массив массивов целых чисел. Каждый из элементов matrix[j] представляет собой массив чисел. Для обращения к отдельному числу используем запись: matrix[j][k].

Пример. Используем для создания таблицы умножения двухмерный массив.

var matrix = new Array(10); // в матрице 10 строчек

for(var j = 0; j < matrix.length; j++)

matrix [j] = new Array(10); //d каждой строчке создали 10 столбцов

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

for(col = 0; col < matrix .length; col++) {

matrix = row*col; // заполнение элементов массива

var rezult = matrix ; // результат умножения 24

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

mеnu = nеw Аrrаy();

mеnu = nеw Аrrаy ("Опция 1.1", " Опция 1.2", ", " Опция 1.3");

mеnu = nеw Аrrаy ("Опция 2.1", " Опция 2 . 2 ");

mеnu = nеw Аrrаy("Опция 3.1", "Опция 3.2", "Опция 3.3", "Опция 3.4");

Для обращения к 1-й опции 2-го подменю, нужно написать:

menu // значение равно "Опция 2.1";

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

mеnu = nеw Аrrау()

menu = nеw Аrrау ("Меню1", "Меню2", "МенюЗ");

menu = nеw Аrrау ();

menu = nеw Аrrау ("Опция 1.1". " Опция 1.2", " Опция 1.3");

menu = nеw Аrrау ("Опция 2.1", " Опция 2 . 2 ");

menu = nеw Аrrау ("Опция 3.1", " Опция 3 . 2 " , " Опция З.3", " Опция 3.4");

menu // значение равно "Меню2"

menu // значение равно "Меню3"

menu // значение равно " Опция 2.1"

menu // значение равно " Опция 3.2 "

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

В данном разделе рассмотрим методы, с помощью которых можно манипулировать элементами массивов.

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

var arr = ; // задан массив из трех элементов

var str = arr.join(); // значение str равно "12,23,38"

str = arr.join("; "); // str == "12; 23; 38"

Как уже отмечалось ранее, метод Array.join() является обратным по отношению к строковому методу String.split(), разбивающему строки на элементы массива.

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

var arr = nеw Аrrау (1,2,3); // arr = 1, arr = 2, arr = 3

arr.reverse(); // arr = 3, arr = 2,arr = 1

var str = arr.jоin(); // str == "3,2,1"

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

var arr = nеw Аrrаy("bаnаnа", "сhеrrу", "аррlе");

var str = arr.join(", "); // str == " аррlе, bаnаnа, сhеrrу"

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

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

Произведем сортировку в числовом порядке.

var arr = ;

arr.sort(); // в алфавитном порядке: 11111, 2222, 333, 44

arr.sort(function(first,second) { //

return first - second; }); // Числовой порядок: 44, 333, 2222, 11111

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

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

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

var arr = ;

arr.соncаt(4, 5) // результат

arr. соncаt (); // результат

arr. соncаt (,) // результат

arr. соncаt (4, ]) // результат ]

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

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

var arr = ;

arr.sliсе(0,3); // вернет

arr. sliсе (3); // вернет

arr. sliсе (1,-1); // вернет

arr. sliсе (-3,-2); // вернет

splice() - универсальный метод, который может быть использован и для добавления, и для удаления элементов массива, или для обеих операций одновременно. В результате работы метода исходный массив изменяется.

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

var arr = ;

arr.splice(4); // вернет ; arr станет равен

arr.splice(1,2); // вернет ; arr станет равен

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

var arr = ;

arr.splice(2,0,"ab","cd"); /* вернет ; arr станет равен */

arr.splice(2,2,,3); /* вернет ["ab","cd"]; arr станет равен ,3,33,44,55] */

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

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

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

vаr stасk = ; // пустой стек

stасk.push(1,2); // массив: вернет 2

stасk. рор (); // массив: вернет 2

stасk.push(3); // массив: вернет 2

stасk.рор(); // массив: вернет 3

stасk.push(); // массив: ] вернет 2

stасk. рор () // массив: вернет

stасk. рор (); // массив: вернет 1

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

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

var arr = ; // arr:

arr.unshift(1); // arr: вернет 1

arr.unshift(22); // arr: вернет 2

arr.shift(); // arr: вернет 22

arr.unshift(3,); // arr:,1] вернет 3

arr.shift(); // arr:[,1] вернет 3

arr.shift(); // arr: вернет

arr.shift(); // arr: вернет 1

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

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

ToString() // вернет "1,2,3"

["а", "b", "с"].tоString() // вернет "а,b,c"

].tоString() // вернет "1,2,с"

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

toLocaleString() – метод, при котором итоговые строки конкатенируются с использованием разделителя, специфического для региона.

Пример 1. Создание циклического баннера (слайд-шоу).

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

Смена изображений

Slide = new Array("./pic/1.gif", "./pic/2.gif", "./pic/3.gif", "./pic/4.gif", "./pic/5.gif", "./pic/6.gif", "./pic/7.gif","./pic/8.gif", "./pic/9.gif");

//Изображения находятся во вложенной папке pic

k=0; Len=Slide.length;

function rotate(){

if (document.images){

document.banner.src=Slide[k];

setTimeout ("rotate()",1*1000);

Пример 2. Вывод случайного афоризма на странице. Случайный афоризм появляется при каждом обновлении страницы.

Случайный афоризм на странице

quote= new Array();

author= new Array();

quote="Одни едят, чтобы жить. Другие - живут, чтобы есть.";

author="Мольер";

quote="Работа не волк, в лес не убежит";

author="Народная мудрость";

quote="Узкий специалист подобен флюсу.";

author="Кoзьма Прутков";

quote="Скорость процессоров каждые два года удваивается.";

author="Не помню";

quotes = new Array();

quotes =

function getSay() {

var k=Math.floor(Math.random()*(quote.length));

var tmp=("Афоризм " +quotes[k]+ "

document.write(getSay())

Объект Date

В JavaScript объект Date предназначен для работы со значениями даты и времени. Создается экземпляр объекта конструктором Date() с использованием оператора new.

var nеw_day = new Date(); /* Создан экземпляр объекта, в котором хранится информация о текущем времени и дате (считываются показания системного времени компьютера). */

var Christmas = new Date(2016, 11, 25); /*Создан экземпляр объекта с датой Рождества. Номера месяцев отсчитываются с нуля, поэтому декабрь по порядку имеет номер 11 */

Методы, определенные для объекта Date(), позволяют устанавливать и сохранять различные значения времени и даты, выполнять над ними ряд действий с использованием либо локального времени, либо времени по Гринвичу (GMT).

Christmas.setFullYear(xmas.getFullYear() + 1); /* Дата Рождества в следующем году */

var wееkdау = Christmas.getDay(); // День недели Рождества.

document.write("Сегодня: " + nеw_day.toLocaleString()); // Строковое значение текущей даты и времени.

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

Конструктор при создании нового экземпляра объекта Date() можно использовать в следующих вариантах:

nеw Dаtе(); /*Конструктор Date() без аргументов создает объект, у которого значение равно текущей дате и времени. */

nеw Dаtе(число_миллисекунд); /* В конструкторе указано единственное числовое значение, оно используется как представление даты в миллисекундах, что аналогично такому значению, которое вернет метод getTime().*/

new Dаtе(дата_строковое_представление); /* Если в конструкторе указан один строковый аргумент, его рассматривают как строковое представление даты в формате, который принимает метод Date.parse(). */

new Dаtе(год, месяц, день, часы, минуты, секунды, миллисекунды); /* Конструктору может быть передано от двух до семи числовых аргументов, указывающих отдельные поля даты и времени. Кроме первых двух полей, указывающих год и месяц, все прочие аргументы являются необязательными. */

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

Укажем, какие значения могут принимать аргументы при использовании разных форм конструктора:

число_миллисекунд - количество миллисекунд в промежутке между нужной датой и полуночью 01 января 1970 года (UTC). Скажем, если аргумент равен 5000, будет создана дата, обозначающая пять секунд после полуночи 01.01.1970.

дата_строковое_представление – аргумент задает в виде строки дату и необязательное время. Строка должна быть указана в формате, понятном для метода Date.parse().

год - четыре цифры года. Для совместимости с более ранними реализациями JavaScript, если значение аргумент находится между 0 и 99, к его значению добавляется число 1900.

день - целое число от 1 до 31, означающее день месяца. Аргумент необязателен.

часы – целое число от 0, означающего полночь, до 23. Аргумент необязателен.

минуты – целое число от 0 до 59. Аргумент необязателен.

секунды. Секунды в минутах, указанные в виде целого от 0 до 59. Необязательный аргумент.

миллисекунды – количество миллисекунд, указанное в виде целого числа в пределах от 0 до 999. Аргумент необязателен.

В этой статье мы рассмотрим стандартные JavaScript массивы с числовыми индексами. Массивы объявляются с помощью квадратных скобок:

var fruits = ["Apple", "Orange", "Donkey"]

Чтобы извлечь элемент, поместите его индекс в квадратные скобки. Первый индекс 0 :

var fruits = ["Apple", "Orange", "Donkey"] alert(fruits) alert(fruits) alert(fruits)

Мы также можем получить длину массива JavaScript :

var fruits = ["Apple", "Orange", "Donkey"] alert(fruits.length)

Упс! Мы создали массив с двумя фруктами и ослом. Теперь нам нужно удалить осла.

Методы pop и push

Метод pop в JavaScript удаляет элемент массива и возвращает его.

В следующем примере показано, как «Осел » извлекается из массива:

var fruits = ["Apple", "Orange", "Donkey"] alert("Я удаляю "+fruits.pop()) // Теперь у нас только ["Apple","Orange"] alert("Теперь размер массива: "+fruits.length) // осел удален

Обратите внимание, что pop изменяет сам массив.

Аналог pop — это метод push , который добавляет элемент в массив. Например, мы забыли добавить персик:

var fruits = ["Apple", "Orange"] fruits.push("Peach"); // теперь у нас есть ["Apple", "Orange", "Peach"] alert("Последний элемент:"+fruits)

Создайте массив styles с элементами “Jazz ”, “Blues ”;

Добавьте значение «Rock’n’Roll «;

Замените второе значение с конца значением «Classic «. У вас должен получиться массив: “Jazz ”, ”Classic ”, ”Rock’n’Roll ”. Код должен работать для любой длины массива;

Извлеките последнее значение из массива и выведите его через alert .

Решение

// 1 var styles = ["Jazz", "Bluez"] // 2 styles.push("Rock"n"Roll") // или: styles = "Rock"n"Roll" // 3 styles = "Classic" // 4 alert(styles.pop())

Методы shift/unshift

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

var fruits = ["Apple", "Orange"] var apple = fruits.shift() // теперь у нас остался только ["Orange"] fruits.unshift("Lemon") // теперь мы имеем ["Lemon", "Orange"] alert(fruits.length) // 2

И shift , и unshift могут работать с несколькими элементами одновременно:

var fruits = ["Apple"] fruits.push("Orange","Peach") fruits.unshift("Pineapple","Lemon") // теперь массив выглядит так: ["Pineapple", "Lemon", "Apple", "Orange", "Peach"]

Задание для самостоятельного выполнения

Напишите код, чтобы вывести через alert случайное значение из массива arr :

var arr = ["Plum","Orange","Donkey","Carrot","JavaScript"]

Примечание: Код для получения случайного числа от минимального до максимального значения (включительно ) следующий:

var rand = min + Math.floor(Math.random()*(max+1-min))

Решение

Нам нужно извлечь случайное число от 0 до arr.length-1 (включительно ):

var arr = ["Plum","Orange","Donkey","Carrot","JavaScript"] var rand = Math.floor(Math.random()*arr.length) alert(arr)

Перебор массива

В JavaScript перебор массива осуществляется с помощью цикла for :

var fruits = ["Pineapple", "Lemon", "Apple", "Orange", "Peach"] for(var i=0; i=0 проверить быстрее, чем i . Что в JavaScript ускоряет поиск в массиве.

Использование length для обрезки массива

С помощью свойства length можно обрезать массив следующим образом:

Вы задаете длину, и браузер обрезает массив.

Array представляет собой объект, что из этого следует

На самом деле в JavaScript Array — это Object , дополненный автоматической установкой длины и специальными методами.

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

Нечисловые ключи массива

Ключи — это числа, но они могут иметь любые имена:

arr = arr = 5 arr.prop = 10 // не делайте так

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

Например, push/pop работают только с крайними элементами массива, поэтому они невероятно быстры.

push работает только с концом:

var arr = ["My", "array"] arr.push("something") alert(arr) // строка "array"

Методы shift/unshift медленные, потому что им нужно изменить нумерацию всего массива. Метод splice также может привести к изменению нумерации:

Таким образом, shift/unshift работают медленнее, чем push/pop . Чем больше массив, тем больше времени занимает в JavaScript сортировка массива.

Задание для самостоятельного выполнения

Какой получится результат? Почему?

arr = ["a", "b"] arr.push(function() { alert(this) }) arr() // ?

Решение

Поскольку массивы являются объектами, arr.. фактически является вызовом метода объекта, таким как objmethod:

arr() // то же самое что arr() // синтаксически это неправильно, но концептуально то же самое: arr.2() // переписанное в том же стиле, что и obj.method() this = arr в таком случае передается функции, поэтому выводится содержимое arr. arr = ["a", "b"] arr.push(function() { alert(this) }) arr() // "a","b",функция

Разреженные массивы, описание length

Свойство length позволяет получить не размер массива в JavaScript , а последний индекс + 1 . Это важно, если речь идет о разреженных массивах, с «промежутками » в индексах.

В следующем примере мы добавим два элемента в пустые fruits , но значение length останется 100 :

var fruits = // пустой массив fruits = "Peach" fruits = "Apple" alert(fruits.length) // 100 (но элементов в массиве всего 2)

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

var fruits = // пустой массив fruits = "Peach" fruits = "Apple" alert(fruits) // ,Peach,Apple (или что-то вроде этого)

Но массив — это объект с двумя ключами. Недостающие значения не занимают места.

Разреженные массивы ведут себя причудливо, когда к ним применяются методы массива. Они понятия не имеют о том, что индексы пропущены:

var fruits = fruits = "Peach" fruits = "Apple" alert(fruits.pop()) // выталкиваем "Apple" (на индекс 9) alert(fruits.pop()) // выталкиваем не заданный элемент (на индекс 8)

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

Удаление из массива

Как мы знаем, массивы — это объекты, поэтому мы могли бы использовать delete , чтобы удалить значение:

var arr = ["Go", "to", "home"] delete arr // теперь arr = ["Go", undefined, "home"] alert(arr) // не задано

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

Оператор delete удаляет пару ключ-значение, и это все. Естественно, так как массив — это только хэш, позиция удаленного элемента становится undefined .

Чаще всего нам нужно удалить элемент, не оставляя «дыр » между индексами. Существует еще один метод, который поможет нам в этом.

Метод splice

Метод splice может удалять элементы и заменять их в JavaScript многомерных массивах. Его синтаксис:

arr.splice(index, deleteCount[, elem1, ..., elemN])

Удаляет элемент deleteCount , начиная с index , а затем вставляет на его место elem1, …, elemN .

Давайте рассмотрим несколько примеров:

var arr = ["Go", "to", "home"] arr.splice(1, 1) // удалить 1 элемент, начиная с индекса 1 alert(arr.join(",")) // ["Go", "home"] (1 элемент удален)

Таким образом, вы можете использовать splice , чтобы удалить один элемент из массива. Номера элементов массива сдвигаются, чтобы заполнить пробел:

var arr = ["Go", "to", "home"] arr.splice(0, 1) // удаляем 1 элемент, начиная с индекса 0 alert(arr) // "to" стал первым элементом

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

Метод splice возвращает массив удаленных элементов:

var arr = ["Go", "to", "home", "now"]; // удаляем 2 первых элемента var removed = arr.splice(0, 2) alert(removed) // "Go", "to" =0; i--) { if (c[i] == cls) c.splice(i,1) } elem.className = c.join(" ") } var obj = { className: "open menu" } removeClass(obj, "open") removeClass(obj, "blabla") alert(obj.className) // menu

В приведенном выше примере переменная c задана в начале цикла, и для i задан ее последний индекс.

Сам цикл выполняется в обратном направлении, заканчиваясь условием i>=0 . Это сделано потому, что i>=0 проверяется быстрее, чем i . Что ускоряет поиск свойства в c .

Метод slice

Можно извлечь часть массива с помощью метода slice(begin[, end]): var arr = ["Why", "learn", "JavaScript"]; var arr2 = arr.slice(0,2) // принимает 2 элемента, начиная с 0 alert(arr2.join(", ")) // "Why, learn"

Обратите внимание, что этот метод не изменяет в JavaScript количество элементов в массиве, а копирует его часть.

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

var arr = ["Why", "learn", "JavaScript"]; var arr2 = arr.slice(1) // принимает все элементы, начиная с 1 alert(arr2.join(", ")) // "learn, JavaScript"

Метод поддерживает отрицательные индексы, так же, как String#slice .

Метод reverse

Еще один полезный метод — reverse . Предположим, я хочу получить последнюю часть домена, например, “com ” от “my.site.com ”. Вот как это можно сделать:

var domain = "my.site.com" var last = domain.split(".").reverse() alert(last)

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

Вы можете создавать более длинные вызовы, например, reverse()0] arr.sort() alert(arr) // 1, 15, 2

Запустите приведенный выше код. Вы получите порядок 1 , 15 , 2 . Это потому, что метод преобразует все в строку и использует по умолчанию лексикографический порядок.

Приветствую всех, кто заинтересовался такой темой, как JavaScript многомерные массивы и сортировка. В текущей публикации я постараюсь во всех подробностях раскрыть данную тему.

Поэтому после прочтения статьи вы узнаете, зачем в веб-приложениях используются многомерные массивы, как они создаются и каким образом ими можно управлять и сортировать. Давайте приступим к обучению!

Как создаются многомерные массивы и для чего они нужны?

Для начала стоит вспомнить, как создается обычный одномерный массив.

var array =

А теперь запомните, что многомерный массив – это массив массивов. Соглашусь, звучит, как тавтология. Однако прочитайте определение еще раз. Действительно, многомерный массив состоит из определенного количества вложенных в него .

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

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

Выглядеть все это будет следующим образом:

var results = [ ["Маркус", 333], ["Наташа", 211], ["Алексей", 124] ];

Как видите, информация может храниться разнородная. Это могут быть и строки, и числа, и даже . Такое возможно потому, что массивы в являются нетипизированными.

При этом обращение к элементам происходит через двойной оператор .

Для закрепления материала проанализируйте небольшую программку.

Значение results =

var results = [ ["Маркус", 333], ["Наташа", 211], ["Алексей", 124] ]; document.getElementById("demo").innerHTML = results;

Массивы являются достаточно удобным средством для хранения упорядоченных комплексных данных при их обработке. К тому же работать с ними очень удобно и при этом скорость их обработки достаточно высокая.

Способы сортировки данных

Для массивов в JavaScript-е предусмотрен встроенный метод под названием sort () . Данный инструмент очень гибок. И сейчас объясню почему.

Если вы используете метод без параметров, то он автоматически упорядочивает подмассивы по первому элементу в алфавитном порядке. Так, при вызове results. sort () разбираемый объект будет выглядеть вот так:

Алексей,124

Маркус,333

Наташа,211

А если поменять в каждом вложенном массиве элементы местами, то получится:

124,Алексей

211,Наташа

333,Маркус

При этом для сравнения все элементы временно преобразовываются к строкам.

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

• положительное число (в основном выбирают 1), если первый указанный элемент следует за вторым при сравнении;
• отрицательное число (обычно -1), если второй выбранный элемент должен следовать за первым;
• нуль, если два проверяемых значения равны.

В качестве примера давайте первоначальный массив results отсортируем по очкам. При чем результаты будут упорядочены от большего к меньшему. Это можно реализовать двумя способами.

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

Рекордная таблица:

var results = [ ["Маркус", 333], ["Наташа", 211], ["Алексей", 124] ]; results.sort(RecordSort); function RecordSort(a, b) { if (a > b) return -1; else if (a < b) return 1; else return 0; } for(var i=0; i b) return 1; else if (a < b) return -1; else return 0; }

function RecordSort(a, b) { if (a > b) return 1; else if (a < b) return -1; else return 0; }

А вот после нее добавим указанный выше метод.

Вывод производится аналогичным образом.

Хочу обратить ваше внимание на один важный момент. При использовании данных функций все изменения происходят с массивом, к которому вы их применяете. Таким образом, если вам необходимо сохранить первоначальный вид данных, то создавайте копию, а после редактируйте уже ее.

Ну, вот я и рассказал о многомерных массивах и их сортировке. Если вам понравилась статья, то подписывайтесь на блог и читайте другие не менее интересные публикации. Буду благодарен за репосты. До новых встреч!

Пока-пока!

С уважением, Роман Чуешов