Пустой массив в языке javascript. JavaScript - Массивы. Метод forEach и родственные методы

Массивы

Массив - это упорядоченная коллекция значений. Значения в массиве называются элементами, и каждый элемент характеризуется числовой позицией в массиве, которая называется индексом. Массивы в языке 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 , его свойствах и методах.

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

Методы pop/push и shift/unshift

Рассмотрим методы pop() и push(). Эти методы позволяют работать с массивами как со стеками. Стек - это структура данных, в которой доступ к элементам организован по принципу LIFO (англ. last in - first out, «последним пришёл - первым ушел»). Принцип работы стека можно сравнить со стопкой тарелок: чтобы взять вторую сверху, нужно снять верхнюю. Как это работает изображено на рисунке:

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

Var foo = ; // foo: foo.push(1,2); // foo: Возвращает 2 foo.pop(); // foo: Возвращает 2 foo.push(3); // foo: Возвращает 2 foo.pop(); // foo: Возвращает 3 foo.push(); // foo: ] Возвращает 2 foo.pop() // foo: Возвращает foo.pop(); // foo: Возвращает 1 var fruits = ["груши", "бананы", "яблоки"]; var picked = fruits.pop(); document.write("Вы сорвали мои " + picked); Попробовать »

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

Var f = ; // f: f.unshift(1); // f: Возвращает: 1 f.unshift(22); // f: Возвращает: 2 f.shift(); // f: Возвращает: 22 f.unshift(3,); // f:,1] Возвращает: 3 f.shift(); // f:[,1] Возвращает: 3 f.shift(); // f: Возвращает: f.shift(); // f: Возвращает: 1

Метод join

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

Var a = ["Ветер","Дождь","Огонь"]; var myVar1 = a.join(); //"Ветер,Дождь,Огонь" var myVar2 = a.join(", "); //"Ветер, Дождь, Огонь" var myVar3 = a.join(" + "); //"Ветер + Дождь + Огонь" document.write(myVar1 + "
" + myVar2 + "
" + myVar3); Попробовать »

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

Метод reverse

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

Var myArr = ["один", "два", "три"]; document.write(myArr.reverse()); Попробовать »

Метод concat

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

Var a = ; a.concat(4, 5) //Возвращает a.concat(); //тоже самое - возвращает a.concat(,) //Возвращает

Метод sort

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

Var a = ["Киви", "Апельсины", "Груши"]; a.sort(); var s = a.join(", "); //Апельсины, Груши, Киви document.write(s); //пример с числами var myArr = ; myArr.sort(); document.write(myArr); //1,10,2 Попробовать »

Наверное от сортировки чисел вы ожидали увидеть немного другой результат. Такая сортировка произошла потому, что метод sort() сортирует элементы, преобразуя их в строки. Поэтому и порядок у них получается строковой - ведь "10"

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

• Если первый аргумент должен предшествовать второму, функция сравнения возвращает отрицательное число (если a
• Если первый аргумент должен следовать за вторым, то функция сравнения возвращает положительное число (если a > b)
• Если два значения эквивалентны (т. е. порядок их расположения не важен), функция сравнения возвращает 0 (если a == b)

Для сравнения в качестве своих аргументов функция использует элементы массива:

Function foo(a,b) { //определяем функцию проверки if (a b) return 1; return 0; //если a == b } var a = ; a.sort(foo); //в качестве аргумента передается только имя функции document.write(a.join(", ")); //тоже самое записать более коротко var a = ; a.sort(function(a,b) { //используем анонимную функцию return a - b; //функция возвращает значение 0 }); document.write(a); //1,2,5,10 Попробовать »

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

Примечание: Если в массиве есть неопределенные элементы (undefined), они переносятся в конец массива.

Метод slice

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

Синтаксис метода:

Имя_массива.slice(begin, end);

Имя_массива следует заменить именем того массива, из которого нужно извлечь определенный набор элементов для нового массива. Метод принимает два аргумента, которые определяют начало и конец возвращаемого участка массива. Метод копирует участок массива, начиная от begin до end, не включая end. Если указан только один аргумент, возвращаемый массив будет содержать все элементы от указанной позиции до конца массива. Можно использовать отрицательные индексы - они отсчитываются с конца массива.

Var arr = ; arr.slice(0,3); //Возвращает arr.slice(3); //Возвращает arr.slice(1,-1); //Возвращает arr.slice(-3,-2); //Возвращает

Метод splice

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

Синтаксис метода:

Имя_массива.splice(index , кол-во, elem1, ..., elemN);

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

Var fruits = ["апельсины", "яблоки", "груши", "виноград"]; var deleted = fruits.splice(2,2); //возвращает ["груши", "виноград"] document.write(deleted); var arr = ; arr.splice(4); //Возвращает ; массив стал: arr.splice(1,2); //Возвращает ; массив стал: arr.splice(1,1); //Возвращает ; массив стал: Попробовать »

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

Var fruits = ["апельсины", "яблоки"]; fruits.splice(2,0, "арбузы"); //возвращает document.write(fruits); //стало ["апельсины", "яблоки", "арбузы"] var arr = ; arr.splice(2,0,"a","b"); //Возвращает ; стало arr.splice(2,2,); //Возвращает ["a","b"]; стало ,3,4,5] Попробовать »

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

Метод toString

Метод toString() преобразует элементы массива в строку, используя в качестве символа-разделителя запятую.

Var arr = ["Молоко","Хлеб","Печенье"]; var food = arr.toString(); document.write(food); //Молок,Хлеб,Печенье Попробовать »

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

indexOf и lastIndexOf

Метод indexOf возвращает индекс элемента, значение которого равно значению, переданному методу в качестве аргумента.

Синтаксис методов indexOf() и lastIndexOf():

Имя_массива.indexOf(искомый_элемент, индекс) имя_массива.lastIndexOf(искомый_элемент, индекс)

Первый аргумент метода указывает значение элемента, индекс которого нужно найти, второй аргумент (необязательный), указывает индекс с которого будет начинаться поиск. Если одинаковых вхождений несколько, выбирается наименьший (первый) индекс. Если элемент с искомым значением не найден, метод вернет -1. Внутри метода для поиска используется строгое сравнение (===).

Var a = ; a.indexOf(3); //вернет 2 a.indexOf(3,4); //вернет 6 a.indexOf(35); //вернет -1: нет элемента с таким значением a.indexOf(2); // 1

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

Var a = ; a.lastIndexOf(3); //вернет 7 a.lastIndexOf(35); //вернет -1: нет элемента с таким значением a.lastIndexOf(2); // 6

Методы итераторы

Методы, описанные ниже, являются итераторами. Во всех современных браузерах для работы с массивами есть методы, которые предназначены для перебора элементов и выполнения различных действий над ними. Это методы forEach(), map(), filter(), every(), some, reduce() и reduceRight().

Они перебирают элементы массива начиная с 0 до length - 1 и, если элемент существует, передают его в callback обработчик-функцию.

forEach

Синтаксис метода:

Имя_массива.forEach(callback, thisArg)

В качестве первого аргумента указывается callback-функция, которую метод forEach() будет вызывать для каждого элемента массива. Реализацию вызываемой функции-обработчика нужно писать самим. Вызываемая функция должна иметь три параметра: первый параметр принимает в качестве аргумента - значение элемента массива, второй - индекс элемента, и третий - сам массив. Однако, если нужно использовать только значения элементов массива, можно написать функцию только с одним параметром. Второй аргумент - thisArg (необязательный) будет передан в качестве значения this.

Var arr = ; function foo(value) { var sum = value * this; return document.write(sum + "
"); } arr.forEach(foo, 5); //второй аргумент будет передан в качестве значения this //пример с тремя параметрами var a = ; a.forEach(function(el, idx, a) { document.write("a["+idx+"] = "+el+" в ["+a+"]
"); }); Попробовать »

filter

Синтаксис метода:

Имя_массива.filter(callback, thisObject)

Метод filter() создает и возвращает новый массив, который будет содержать только те элементы массива, для которых вызов функции callback возвратит true.

Function isBig(element, index, array) { //возвращает числа, которые больше или равны 10 return (element >= 10); //если значение элемента больше или равно 10 - выражение вернет true } var filtered = .filter(isBig); //filtered

map

Метод map() создает и возвращает новый массив, который будет состоять из результатов вызова функции callback(item, idx, ar) для каждого элемента массива.

Var a = ; var b = a.map(function(item, idx, arr) { return item * item; }); // b =

every и some

Метод every() возвращает true, если для всех элементов массива указанная функция, используемая для их проверки, вернет true.

Метод some() возвращает true, если во время проверки в указанной функции один или несколько элементов вернут true.

Var a = ; a.every(function(x) { return x 10; }) //true: одно число > 10

reduce и reduceRight

Синтаксис методов:

Имя_массива.reduce(callback, initialValue) имя_массива.reduceRight(callback, initialValue)

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

Аргументы функции callback: (previousValue, currentItem, index, array)

• previousValue - возвращаемый результат callback функции (он же промежуточный результат)
• currentItem - текущий элемент массива (элементы перебираются по очереди слева-направо)
• index - индекс текущего элемента
• array - обрабатываемый массив

initialValue (инициализирующее значение) - объект, используемый в качестве первого аргумента первого вызова функции callback. Проще говоря, значение previousValue при первом вызове равно initialValue. Если initialValue нет, то оно равно первому элементу массива, а перебор начинается со второго:

Var a = ; function foo(prevNum,curNum) { sum = prevNum + curNum; alert(sum); return sum; } var result = a.reduce(foo, 0); document.write(result); Попробовать »

Разберем как работает этот пример. Первыми аргументами функции foo являются:

• prevNum = 0 (так как initialValue - 0)
• curNum = 1 (текущий элемент - 1-ый элемент массива)

К числу 0 прибавляется 1. Этот результат (sum: 1) будет передан как prevNum при следующем запуске функции. И так далее пока не дойдет до последнего элемента. Возвращенный результат - сумма от последнего запуска, составит 15 (1+2+3+4+5).

Метод reduceRight работает аналогично методу reduce, но идет по массиву справа-налево:

Var a = ["h","o","m","e"]; function bar(prevStr, curItem) { return prevStr + curItem; } document.write(a.reduceRight(bar)); //emoh

• Перевод

• I. Перебор настоящих массивов
• Метод forEach и родственные методы
• Цикл for
• Правильное использование цикла for...in
• Цикл for...of (неявное использование итератора)
• Явное использование итератора
• Использование способов перебора настоящих массивов
• Преобразование в настоящий массив
• Замечание по объектам среды исполнения

I. Перебор настоящих массивов На данный момент есть три способа перебора элементов настоящего массива:

метод Array.prototype.forEach ;

классический цикл for ;

«правильно» построенный цикл for...in .

Кроме того, в скором времени, с появлением нового стандарта ECMAScript 6 (ES 6), ожидается еще два способа:

цикл for...of (неявное использование итератора);

явное использование итератора.

1. Метод forEach и родственные методы Если ваш проект рассчитан на поддержку возможностей стандарта ECMAScript 5 (ES5), вы можете использовать одно из его нововведений - метод forEach .

Пример использования:
var a = ["a", "b", "c"]; a.forEach(function(entry) { console.log(entry); });
В общем случае использование forEach требует подключения библиотеки эмуляции es5-shim для браузеров, не имеющих нативной поддержки этого метода. К ним относятся IE 8 и более ранние версии, которые до сих пор кое-где еще используются.

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

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

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

• every - возвращает true , если для каждого элемента массива колбек возвращает значение приводимое к true .
• some - возвращает true , если хотя бы для одного элемента массива колбек возвращает значение приводимое к true .
• filter - создает новый массив, включающий те элементы исходного массива, для которых колбек возвращает true .
• map - создает новый массив, состоящий из значений возращаемых колбеком.
• reduce - сводит массив к единственному значению, применяя колбек по очереди к каждому элементу массива, начиная с первого (может быть полезен для вычисления суммы элементов массива и других итоговых функций).
• reduceRight - работает аналогично reduce, но перебирает элементы в обратном порядке.

2. Цикл forСтарый добрый for рулит :

Var a = ["a", "b", "c"]; var index; for (index = 0; index < a.length; ++index) { console.log(a); }
Если длина массива неизменна в течение всего цикла, а сам цикл принадлежит критическому в плане производительности участку кода (что маловероятно), то можно использовать «более оптимальную» версию for с хранением длины массива:

Var a = ["a", "b", "c"]; var index, len; for (index = 0, len = a.length; index < len; ++index) { console.log(a); }
Теоретически этот код должен выполняться чуть быстрее, чем предыдущий.

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

Var a = ["a", "b", "c"]; var index; for (index = a.length - 1; index >= 0; --index) { console.log(a); }
Тем не менее, в современных движках JavaScript подобные игры с оптимизацией обычно ничего не значат.

3. Правильное использование цикла for...in Если вам посоветуют использовать цикл for...in , помните, что перебор массивов - не то, для чего он предназначен . Вопреки распространенному заблуждению цикл for...in перебирает не индексы массива, а перечислимые свойства объекта.

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

// a - разреженный массив var a = ; a = "a"; a = "b"; a = "c"; for (var key in a) { if (a.hasOwnProperty(key) && /^0$|^\d*$/.test(key) && key