Массивы
Массив - это упорядоченная коллекция значений. Значения в массиве называются элементами, и каждый элемент характеризуется числовой позицией в массиве, которая называется индексом. Массивы в языке 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() удаляет и возвращает первый элемент массива, смещая все последующие элементы на одну позицию вниз, чтобы занять место, освободившееся в начале массива.
Приветствую всех, кто заинтересовался такой темой, как 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 () . При этом стоит учесть, что пользовательская функция должна возвращать:
В качестве примера давайте первоначальный массив results отсортируем по очкам. При чем результаты будут упорядочены от большего к меньшему. Это можно реализовать двумя способами.
В первом варианте я изменил логику сортировки, т.е. в ситуации, когда надо возвращать положительное число, возвращаю отрицательное и наоборот.
Рекордная таблица:
function RecordSort(a, b) { if (a > b) return 1; else if (a < b) return -1; else return 0; }
А вот после нее добавим указанный выше метод.
Вывод производится аналогичным образом.
Хочу обратить ваше внимание на один важный момент. При использовании данных функций все изменения происходят с массивом, к которому вы их применяете. Таким образом, если вам необходимо сохранить первоначальный вид данных, то создавайте копию, а после редактируйте уже ее.
Ну, вот я и рассказал о многомерных массивах и их сортировке. Если вам понравилась статья, то подписывайтесь на блог и читайте другие не менее интересные публикации. Буду благодарен за репосты. До новых встреч!
Пока-пока!
С уважением, Роман Чуешов
В этой статье мы рассмотрим стандартные 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)
// 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 . Это потому, что метод преобразует все в строку и использует по умолчанию лексикографический порядок.
Пример использования:
var a = ["a", "b", "c"];
a.forEach(function(entry) {
console.log(entry);
});
В общем случае использование forEach требует подключения библиотеки эмуляции es5-shim для браузеров, не имеющих нативной поддержки этого метода. К ним относятся IE 8 и более ранние версии, которые до сих пор кое-где еще используются.
К достоинствам forEach относится то, что здесь не нужно объявлять локальные переменные для хранения индекса и значения текущего элемента массива, поскольку они автоматически передаются в функцию обратного вызова (колбек) в качестве аргументов.
Если вас беспокоят возможные затраты на вызов колбека для каждого элемента, не волнуйтесь и прочитайте это .
ForEach предназначен для перебора всех элементов массива, но кроме него ES5 предлагает еще несколько полезных методов для перебора всех или некоторых элементов плюс выполнения при этом каких-либо действий с ними:
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 подобные игры с оптимизацией обычно ничего не значат.
Тем не менее, в некоторых случаях, таких как перебор разреженных массивов , 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
