Синтаксис добавления элемента в массив javascript. Явное использование итератора. Методы push() и pop()

В этой статье мы рассмотрим JavaScript-массив, его составляющие. JavaScript является идеально-ориентированным созданным для программирования. Фактически он реализует язык ECMAScript (эталон ECMA-262).

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

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

Вообще, на JavaScript повлияли разные причины, ведь при разработке хотели создать язык, похожий на Java, но лёгкий для использования программистами. Кстати, языком JavaScript не владеет какое-либо предприятие или организация, что делает его непохожим на ряд программных стилей, применяемых веб-разработчиками.

Необходимо отметить, что JavaScript - зарегистрированный товарный знак концерна Oracle Corporation.

Что такое массив?

Массивом называют который хранит пронумерованные значения. Каждое такое значение именуется компонентом массива, а цифру, с которой связывается компонент, называют индексом. JavaScript-массив нетипизирован. Это означает, что детали массива могут иметь какой угодно тип, причём разные детали, принадлежащие одному массиву, имеют совершенно разные типы.

Кроме этого, JavaScript-массив является динамическим, а это говорит о том, что фиксированный размер нет необходимости объявлять. Ведь добавлять новые детали можно в любой момент.

Производство массива

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

• var empty = ; //пустой массив;
• var numers = ; //массив с пятью цифровыми компонентами;
• var diff = ; //массив с тремя элементами разного вида.

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

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

• Вызов проектировщика без доводов: var b - new Array(). Здесь предусмотрено создание пустого массива, эквивалентного пустому литералу .
• Конструктор явно имеет указания значения n компонентов массива: var b = new Array (1, 3, 5, 8, «строка», true). В данном случае проектировщику преподносится список аргументов, которые превращаются в компоненты нового массива. Аргументы пишутся в массив в том расположении, в котором указаны.
• Определение области для последующего приписывания значений. Это делается с помощью указания при выявлении массива одного числа, заключённого в круглые скобки: var b = new Array(5). Данный способ выявления предполагает выделение массиву необходимого количества компонентов (каждый из которых значится как undefined) с возможностью последующего приписывания значений в процессе изложения. Такую форму обычно используют, чтобы предварительно разместить тот Javascript-массив, у которого длина известна заранее.

Запись, чтение и добавление деталей массива

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

Необходимо отметить, что в массивах JavaScript можно хранить какое угодно количество элементов любого вида.

Длина массива

Итак, мы знаем, Длина массива вообще является интересным явлением. Рассмотрим его подробней. Все массивы, как сконструированные с помощью проектировщика Array(), так и выявленные благодаря литералу массива, имеют специфическое свойство length, которое отзывает общее количество сберегаемых элементов. Так как в массиве могут находиться неопределённые детали (обозначаемые undefined), более точное выражение звучит таким образом: качество length всегда больше на единицу, чем самый большой номер (индекс) компонента массива. Качество length корректируется автоматически, оставаясь точным при появлении в массиве новых деталей.

Чтобы появился завершающий компонент массива, можно использовать свойство length.

Последняя деталь имеет индекс на единицу меньше чем, размер массива. Ведь отсчёт начинают всегда с нуля. Ох уж этот JavaScript! Длина массива его зависит от точного количества элементов. Поэтому если вы не знаете, сколько их должно быть, но вам нужно обратиться к завершающему элементу массива, нужно применить запись: v.length - 1.

Перебор деталей массива

Очень часто свойство length используют для перебора деталей массива в цикле:

• var fruits = [«клубника», «персик», «яблоко», «банан»];
• for(var I = 0; i < fruits.lenght; i++);
• document.write(fruits[i] + «...»).

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

Цикл также иногда используют для инициализации компонентов.

Увеличение и усечение массива

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

Весьма просто очистить массив так: foo.length = 0.

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

Удаление деталей массива

Оператор delete указывает в компоненте массива значение undefined, а он при этом продолжает существование. Если необходимо удалить элемент массива JavaScript так, чтобы оставшиеся детали сместились на освободившееся место, нужно использовать один из предугаданных способов массива. Способ Array.shift() ликвидирует первый компонент, pop() - завершающий компонент, а способ splice() - один либо диапазон компонентов в любом месте массива.

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

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

Ассоциативные массивы

А теперь изучим, как товарный знак JavaScript ассоциативные массивы использует. Для этого нам нужно заглянуть в теорию: массивы ассоциативные иногда называют хэш-таблицами. Благодаря им вместо индексов применяются строки. Использование таких конструкций напоминает применение имени свойства простого объекта, но в данном варианте при выполнении работ в формате массива. Так как в JavaScript отсутствуют способы оперирования массивами ассоциативными, они используются гораздо реже, чем обычные. Необходимо отметить, что они всё же могут быть полезны для хранения данных и упрощают запоминание деталей, к которым необходимо получить доступ.

Вывод массива

А что теперь мы изучим в системе JavaScript? Вывод массива в диалоговое окно (на экран монитора), а также вывод значений компонентов массива.

Если в программе нужно вывести значения всех компонентов, то для этого удобно применить инструкцию for. Интересно, что переменная-счётчик правил for используется при этом как индекс компонента массива.

Очистка

Для того чтобы отфильтровать массив JavaScript, нужно обнулить его длину:

• var myArray = ;
• myArray.length = 0.

• clear: function() {;
• this.length = 0;
• return this;

Добавление и удаление компонентов

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

• При добавлении неизвестного цифрового свойства i, если length равен либо меньше i, length определяется равным i+1.
• При перемене качества length совершаются следующие действия: если присвоенное значение меньше нуля, то кидается RangeError. Ликвидируются все числовые качества и индексы, которые равны новому length и которых больше.

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

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

Несмотря на то что компоненты массива изменяются вручную, многие рекомендуют для этого применять встроенные методы. Именно этот нюанс гарантирует корректное значение качества length и отсутствие в массиве пропусков. Кстати, корректное качество length будет соответствовать числу компонентов.

Способ push переносит в конец массива переданные детали. Способ pop отдаёт обратно завершающий компонент и удаляет его.

Вообще в Internet Explorer младше восьмой версии unshift может вернуть undefined, в иных браузерах - новое значение length. Так что на возвращаемое от unshift значение лучше не надеяться.

Добавление и ликвидация деталей в середине массива

Если необходимо удалить массив JavaScript, что нужно предпринять? Известно, что способ splice имеет сигнатуру Array.prototype.splice.

Он из массива изымает deleteCount компонентов, начиная с показателя start. Если передано более двух аргументов, то все последующие аргументы в массиве размещаются вместо ликвидированных. Если start минусовый, то индекс, с которого возобновится изъятие, будет равен length + start. Возврат в массив происходит из удалённых элементов.

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

В простейшем варианте, если нужно удалить компонент с индексом i, нужно у массива запросить метод splice с параметрами i и 1.

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

К примеру, в Firefox, в последних вариациях Opera, в Safari и в Chrome будут изъяты все детали до конца массива.

В IE не будет ликвидирован ни один компонент. В первых вариациях Opera поведение предсказать невозможно - будет изъята одна деталь с индексом start - 1. Поэтому всегда нужно в данный метод передавать как минимум два компонента.

Ключи

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

FIND (ключ).

INSERT (значение, ключ).

REMOVE (ключ).

Предполагают, что в ассоциативном массиве не могут сберегаться две пары с похожими ключами. В паре k + v v называется величиной, ассоциированной с ключом k. Семантика и наименования вышеупомянутых операций в различных реализациях таких массивов могут быть разными.

Так, действие FIND (ключ) возвращает величину, ассоциированную с заданным ключом, или некий специфический объект UNDEF, означающий, что величина, ассоциированная с заданным ключом, отсутствует. Два других действия ничего не возвращают (за исключением данных о том, успешно ли была проведена эта операция).

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

Кстати, поддержка таких массивов имеется во многих трактуемых программных языках высокого уровня, таких как PHP, Perl, Ruby, Python, Tcl, JavaScript и другие. Для языков, у которых отсутствуют встроенные средства работы с ассоциативными массивами, создано колоссальное число реализаций в виде библиотек.

Примером ассоциативного массива может служить телефонный справочник. В данном варианте значением является комплекс «Ф. И. О. + адрес», а ключом - номер телефона. Один телефонный номер имеет одного хозяина, но один человек может владеть несколькими номерами.

Ассоциативные расширения

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

• EACH - «пройтись» по всем сберегаемым парам.
• CLEAR - изъять все записи.
• MIN - найти пару с наименьшим ключевым значением.
• MAX - найти пару с наибольшим ключевым значением.

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

Реализации ассоциативных массивов

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

Наиболее известны реализации, базирующиеся на различных деревьях поиска. К примеру, в типовой читальне STL языка C++ контейнер map реализован на базе чёрно-красного дерева. В стилях Ruby, Tcl, Python применяется один из видов хэш-таблицы. Существуют и иные реализации.

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

Известно, что в реализациях, базирующихся на хэш-таблицах, среднее время определяется как О(1), что лучше, чем в действиях, базирующихся на деревьях поиска. Конечно, при этом не гарантируется высокоскоростное выполнение отдельных операций: время действия INSERT в худшем случае обозначается как О(n). Процесс INSERT выполняется длительное время, когда коэффициент заполнения достигает наивысшей точки и появляется необходимость реконструкции индекса хэш-таблицы.

Кстати, эти хэш-ведомости плохи тем, что на их базе нельзя исполнить быстрые дополнительные действия MAX, MIN и алгоритм обхода всех сберегаемых пар в порядке убывания либо возрастания ключей.

Я описал лишь часть методов для работы с массивами.

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

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

Вы можете использовать свойство length для добавления новых элементов в массив:

Var myArray = ["Apple", "Microsoft", "Google", "Facebook"]; myArray = "Yahoo!"; console.log(myArray); // ["Apple", "Microsoft", "Google", "Facebook", "Yahoo!"]

Это сработает, т.к. элементы массива нумеруются с нуля, а length на единицу больше. Length всегда эквивалентно index + 1 , поэтому очень легко добавить новый элемент в конец массива. Странно, но вы можете добавить элемент на позицию, которая намного больше, чем длина самого массива:

Var myArray = ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards"]; myArray = "Lindsey Buckingham"; console.log(myArray); // ["Jimi Hendrix", "Eric Clapton", "Jimmy Page", "Keith Richards", undefined × 95, "Lindsey Buckingham"] console.log(myArray.length); // 100

Как показано в комментариях, будет добавлено 95 пустых слотов и элемент «Lindsey Buckingham» в конец массива. После этого мы получим длину 100. Еще один способ добавить новый элемент в массив — использовать метод push():

Var myArray = ["Paul McCartney", "John Lennon", "George Harrison"]; myArray.push("Ringo Starr", "George Martin"); console.log(myArray); // ["Paul McCartney", "John Lennon", "George Harrison", "Ringo Starr", "George Martin"]

Метод push() всегда возвращает новую длину массива (в нашем случае 5). Добавить элемент можно с помощью splice():

Var myArray = ["acorn", "beech", "mongongo", "macadamia"]; myArray.splice(2, 0, "cashew"); // adds "cashew" into index 2 console.log(myArray); // ["acorn", "beech", "cashew", "mongongo", "macadamia"]

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

Удаление элементов из массива

Удалить элемент немножко сложнее, чем его добавить. Чтобы удалить элемент из конца массива, можно использовать pop():

Var myArray = ["7-up", "Sprite", "Ginger Ale", "Lemonade"]; myArray.pop(); console.log(myArray); // ["7-up", "Sprite", "Ginger Ale"]

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

Вы так же можете использовать splice() метод:

Var myArray = ["cassava", "nutmeg", "lupin", "rhubarb"]; myArray.splice(2, 1); // удалить элемент с индексом 2 console.log(myArray); // ["cassava", "nutmeg", "rhubarb"]

В отличии от метода splice(), который используется для добавления элементов, здесь вторым аргументом идет 1, которая говорит, что мы хотим удалить элемент с индексом 2 (или 3-ий по счету). В данном случае удалился элемент «lupin».

Вы можете удалить элемент массива используя оператор delete:

Var myArray = ["Byte Bandit", "Eliza", "Jeefo", "Michelangelo"]; console.log(myArray.length); // 4 delete myArray; // удалить Eliza console.log(myArray.length); // 4 console.log(myArray); // ["Byte Bandit", undefined × 1, "Jeefo", "Michelangelo"]

Первое важное замечание: delete() не изменяет длину массива после удаления элемента (даже, если это был последний элемент в массиве). Второе: delete() изменяет значение удаляемого элемента на undefined, поэтому при обращении myArray = undefined .

Хороший способ удалить элемент из массива — использовать John Resig’s Array.remove . Ниже пример использования, взятый с его страницы:

// Array Remove - By John Resig (MIT Licensed) Array.prototype.remove = function(from, to) { var rest = this.slice((to || from) + 1 || this.length); this.length = from < 0 ? this.length + from: from; return this.push.apply(this, rest); }; // Удаление 2 элемента из массива array.remove(1); // Удаление 2-ого элемента с конца массива array.remove(-2); // Удаление второго и третьего элемента array.remove(1,2); // Удаление последнего и предпоследнего элемента array.remove(-2,-1);

Возможно вы захотите посмотреть решение by Viral Patel , одну из функций в Underscore.js , или jQuery’s grep() .

Дополнительно, в JavaScript есть метод shift(), который удаляет первый элемент в массиве и возвращает его значение. Посмотрим код:

Var myArray = ["Matt Kramer", "Jason Bieler", "Tom Defile", "Phil Varone"]; console.log(myArray.length); // 4 var firstItem = myArray.shift(); console.log(firstItem); // Matt Kramer console.log(myArray.length); // 3 console.log(myArray); // ["Jason Bieler", "Tom Defile", "Phil Varone"]

С помощью метода shift() мы удалили элемент, но сохранили его значение в нашей переменной firstItem. Длина массива изменилась с 4 на 3.

Этот метод может быть полезен вместе с методом push(). Используя их вместе мы можем эффективно выстраивать очередь элементов в массиве. Мы сохраняем длину массива удаляя элемент с начала и добавляя новый в конец.

Наоборот, мы можем использовать метод unshift() для добавления элемент в начало массива:

Var myArray = ["apito", "castanets", "maraca"]; console.log(myArray.length); // 3 myArray.unshift("chime bar", "tan-tan"); console.log(myArray.length); // 5 console.log(myArray); // ["chime bar", "tan-tan", "apito", "castanets", "maraca"]

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

Переворачивание и сортировка элементов массива.

Чтобы перевернуть элементы в массиве, мы можем использовать reverse():

Var myArray = ["countdown", "final", "the"]; console.log(myArray); // ["countdown", "final", "the"] myArray = myArray.reverse(); console.log(myArray); // ["the", "final", "countdown"]

Сортировать элементы массива в алфавитном порядке возможно с помощью метода sort():

Var myArray = ["xylophones", "zebras", "juggernauts", "avocados"]; console.log(myArray); // ["xylophones", "zebras", "juggernauts", "avocados"] myArray = myArray.sort(); console.log(myArray); // ["avocados", "juggernauts", "xylophones", "zebras"]

Но это не будет работать с числами.

Var myArray = ; console.log(myArray); // myArray = myArray.sort(); console.log(myArray); //

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

Function compareNumbers(a, b) { return a - b; } var myArray = ; console.log(myArray); // myArray = myArray.sort(compareNumbers); console.log(myArray); //

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

Объединение массивов.

Мы можете объединить 2 или больше массивов и получить 1 массив, который содержит элементы соединенных массивов. Для этого используем метод concat():

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myArray2 = ["Chris Murphy", "Patrick Pentland"]; var myNewArray = myArray.concat(myArray2); console.log(myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

Var myArray = ["Jay Ferguson", "Andrew Scott"]; var myNewArray = myArray.concat("Chris Murphy", "Patrick Pentland"); console.log(myNewArray); // ["Jay Ferguson", "Andrew Scott", "Chris Murphy", "Patrick Pentland"]

Разделение массива.

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

Var myArray = ["Vocals", "Bass", "Guitar", "Drums", "Apples", "Oranges"]; var myNewArray = myArray.slice(4); console.log(myNewArray); // ["Apples", "Oranges"]

Метод slice() принимает 1 или 2 аргумента. Если передан 1 аргумент (индекс), то новый массив создается из всех элементов старого, начиная с данного индекса. Если передано 2 аргумента, то новый массив создается из элементов, начиная с первого аргумента и до элемента с индексом, переданным во втором параметре, не включая последний. Чтобы было понятней, посмотрим код ниже:

Var myArray = ["Vocals", "Bass", "Guitar", "Drums", "Apples", "Oranges"]; var myNewArray = myArray.slice(0, 4); console.log(myNewArray); // ["Vocals", "Bass", "Guitar", "Drums"]

Замена элементов в массиве.

Мы используем splice() для удаления элементов из массива, но мы так же можем заменить элемент в массиве на новые элементы:

Var myArray = ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Matt Sharp"]; myArray.splice(3, 1, "Scott Shriner"); // заменить 1 элемент с индексом 3 console.log(myArray); // ["Rivers Cuomo", "Patrick Wilson", "Brian Bell", "Scott Shriner"]

Метод splice() всегда возвращает массив, содержащий элементы, которые были удалены. В строчке 2 будет возвращен 1 элемент «Brian Bell».

Заключение

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

Есть что добавить? Или знаете какую-нибудь интересную библиотеку, которая поможет управлять массивами? Комментируйте, пожалуйста!

• Перевод

• 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