Удалить последний элемент из массива
Содержание:
- Синтаксис
- Описание
- 5 ответов
- Синтаксис
- Мое решение
- Используем для удаления функцию delete
- Копирование массива в JavaScript
- # includes
- Объекты не работают одинаково
- Удаляем элемент с помощью splice
- Большинство методов поддерживают «thisArg»
- Общие методы массива
- Демонстрация удаления конкретного элемента с использованием метода splice
- Использование функции delete для удаления элемента массива
- Поиск индекса элемента в JS
Синтаксис
Массив в JavaScript инициализируется с помощью переданных элементов, за исключением случая, когда в конструктор передаётся один аргумент и этот аргумент является числом (см. ниже)
Стоит обратить внимание, что этот особый случай применяется только к JavaScript-массивам, создаваемым с помощью конструктора , а не к литеральным массивам, создаваемым с использованием скобочного синтаксиса.
Если конструктору передаётся единственный аргумент, являющийся целым числом в диапазоне от 0 до 232-1 (включительно), будет возвращён новый пустой JavaScript-массив, длина которого установится в это число (примечание: это означает массив, содержащий пустых ячеек, а не ячеек со значениями ). Если аргументом будет любое другое число, возникнет исключение .
Описание
Массивы являются спископодобными объектами, чьи прототипы содержат методы для операций обхода и изменения массива. Ни размер JavaScript-массива, ни типы его элементов не являются фиксированными. Поскольку размер массива может увеличиваться и уменьшаться в любое время, то нет гарантии, что массив окажется плотным. То есть, при работе с массивом может возникнуть ситуация, что элемент массива, к которому вы обратитесь, будет пустым и вернёт . В целом, это удобная характеристика; но если эта особенность массива не желательна в вашем специфическом случае, вы можете рассмотреть возможность использования типизированных массивов.
Некоторые полагают, что вы не должны использовать массив в качестве ассоциативного массива. В любом случае, вместо него вы можете использовать простые , хотя у них есть и свои подводные камни. Смотрите пост Легковесные JavaScript-словари с произвольными ключами(англ.) в качестве примера.
Массивы в JavaScript индексируются с нуля: первый элемент массива имеет индекс, равный , а индекс последнего элемента равен значению свойства массива минус 1.
Элементы массива являются свойствами, точно такими же, как, например, свойство , однако попытка получить элемент массива по имени его свойства приведёт к синтаксической ошибке, поскольку имя свойства не является допустимым именем JavaScript:
Это не особенность массивов или их свойств. В JavaScript к свойствам, начинающимся с цифры, невозможно обратиться посредством точечной нотации; к ним можно обратиться только с помощью скобочной нотации. Например, если у вас есть объект со свойством, названным , вы сможете обратиться к нему только посредством скобочной нотации. Примеры:
Обратите внимание, что во втором примере заключено в кавычки:. Индексы можно заключать в кавычки (например вместо ), но в этом нет необходимости
Значение 2 в выражении будет неявно приведено к строке движком JavaScript через метод преобразования . Именно по этой причине ключи и будут ссылаться на два разных элемента в объекте и следующий пример выведет :
Аналогично, к свойствам объекта, являющимся зарезервированными словами(!) можно получить доступ только посредством скобочной нотации:
Свойство массивов взаимосвязано с числовыми свойствами. Некоторые встроенные методы массива (например, , , и т.д.) учитывают значение свойства при своём вызове. Другие методы (например, , и т.д.) в результате своей работы также обновляют свойство массива.
При установке свойства в массиве, если свойство имеет действительный индекс и этот индекс выходит за пределы текущих границ массива, движок соответствующим образом обновит свойство :
Увеличиваем свойство
Однако, уменьшение свойства приведёт к удалению элементов.
Более подробно эта тема освещена на странице, посвящённой свойству .
Результатом сопоставления регулярного выражения строке является JavaScript-массив. Этот массив имеет свойства и элементы, предоставляющие информацию о сопоставлении. Подобные массивы возвращаются методами , и . Чтобы было проще понять, откуда и какие появились свойства и элементы, посмотрите следующий пример и обратитесь к таблице ниже:
Свойства и элементы, возвращаемые из данного сопоставления, описаны ниже:
| Свойство/Элемент | Описание | Пример |
| Свойство только для чтения, отражающее оригинальную строку, с которой сопоставлялось регулярное выражение. | cdbBdbsbz | |
| Свойство только для чтения, являющееся индексом (отсчёт начинается с нуля) в строке, с которого началось сопоставление. | 1 | |
| Элемент только для чтения, определяющий последние сопоставившиеся символы. | dbBd | |
| Элементы только для чтения, определяющие сопоставившиеся подстроки, заключённые в круглые скобки, если те включены в регулярное выражение. Количество возможных подстрок не ограничено. | : bB : d |
5 ответов
Лучший ответ
Я считаю это довольно глупым вопросом, чтобы использовать только . Это пахнет домашней работой и никак не является вопросом реального мира.
Хорошо, теперь, когда фактические правила были раскрыты (используйте только для удаления значений, а не временных массивов), вот метод, который использует только для удаления значений из массива. Предполагается, что исходный порядок не нужно сохранять (хотя это можно сделать с помощью большего количества кода). Это работает в обратном порядке через массив и каждый раз, когда он находит отрицательное значение, он меняет это значение на последнее значение в массиве, а затем сбрасывает это отрицательное значение:
Рабочая демонстрация: http://jsfiddle.net/jfriend00/wo8fhoor/
И вот версия, которая сохраняет порядок массива, используя только для удаления элементов из массива. Когда он находит отрицательное значение, он копирует все последующие элементы после него в массив (таким образом удаляя его) и затем использует , чтобы сократить массив на единицу:
Рабочая демонстрация: http://jsfiddle.net/jfriend00/uvqx6hq0/
Эти версии кода появились до того, как были раскрыты полные правила.
Вы можете циклически перемещаться по массиву, каждый раз выталкивая последний элемент, а затем создавать новый массив только с теми значениями, которые вам нравятся:
Рабочая демонстрация: http://jsfiddle.net/jfriend00/2atz6ck9/
удаляет только последний элемент в массиве. Для удаления этого конкретного элемента не требуется аргумент, поэтому вы не можете использовать его для удаления n-го элемента в массиве.
В реальном мире вы либо использовали бы для создания нового массива, либо использовали бы для удаления отдельных элементов.
Вот решение:
Рабочая демонстрация: http://jsfiddle.net/jfriend00/gqt5avLb/
И вот решение с использованием :
Или в ES6:
2
jfriend00
11 Дек 2018 в 21:06
Это , несмотря на мои предыдущие комментарии, возможно с , но оно требует создания другого массива, итерируя по существующему массиву:
Это, однако, смешно, так как было бы проще и гораздо разумнее не добавлять отрицательные числа в массив в первую очередь:
David says reinstate Monica
22 Фев 2015 в 00:54
Попробуй это:
Конечно, это не хороший способ удалить негативы.
Oriol
22 Фев 2015 в 00:52
Возможно, вы можете использовать 2D-массив.
Это ни в коем случае не эффективное решение, но если у вас есть небольшое количество элементов, это должно быть хорошо.
EDIT :
Вот функция для создания 2D-массива:
Lee Yi
22 Фев 2015 в 02:20
Вы можете достичь того, чего хотите, используя функцию .
Кроме того, вы не можете одновременно пытаться перебирать элементы массива и удалять элементы из этого массива. Это не имеет смысла. Вы можете фильтровать элементы массива, вы можете удалять определенные элементы, вы можете добавлять элементы в массив, но вы определенно не можете циклически просматривать его элементы и в то же время удалять элементы из него.
Christos
22 Фев 2015 в 00:55
Синтаксис
где результат вычисления выражения должен быть ссылкой на свойство (объекта), например:
delete object.property
delete object
delete object
delete property // удаляет свойства глобального объекта, или,
// используя инструкцию with, свойства объекта, на который ссылается инструкция
Если результат вычисления выражения не является свойством (объекта), ничего не делает.
- Имя объекта или выражение, результатом вычисления которого является объект.
- Удаляемое свойство.
- Целое число, представляющее собой индекс массива, который должен быть удалён.
Возвращает false, только если свойство существует в самом объекте, а не в его прототипах, и не может быть удалено. Во всех остальных случаях возвращает true.
Мое решение
Единственным способом сравнения объектов является проверка свойств и значений каждого из них. Поэтому решение заключается в ручной проверке. Механизм реализации:
- Проверять каждый элемент в массиве на соответствие последующему, который идет после него.
- Проверять только те элементы, которые не были определены как дубликаты другого элемента.
- Если значения каждого свойства объектов одинаковы, проверить, имеют ли объекты одинаковые ключи.
Финальная функция выглядит так:
function removeDuplicates(arr) {
const result = [];
const duplicatesIndices = [];
// Перебираем каждый элемент в исходном массиве
arr.forEach((current, index) => {
if (duplicatesIndices.includes(index)) return;
result.push(current);
// Сравниваем каждый элемент в массиве после текущего
for (let comparisonIndex = index + 1; comparisonIndex < arr.length; comparisonIndex++) {
const comparison = arr;
const currentKeys = Object.keys(current);
const comparisonKeys = Object.keys(comparison);
// Проверяем длину массивов
if (currentKeys.length !== comparisonKeys.length) continue;
// Проверяем значение ключей
const currentKeysString = currentKeys.sort().join("").toLowerCase();
const comparisonKeysString = comparisonKeys.sort().join("").toLowerCase();
if (currentKeysString !== comparisonKeysString) continue;
// Проверяем индексы ключей
let valuesEqual = true;
for (let i = 0; i < currentKeys.length; i++) {
const key = currentKeys;
if ( current !== comparison ) {
valuesEqual = false;
break;
}
}
if (valuesEqual) duplicatesIndices.push(comparisonIndex);
} // Конец цикла
});
return result;
}
Используем для удаления функцию delete
Для удаления элемента массива в JavaScript нередко используют и функцию delete. Однако тут следует учесть, что эта функция сохраняет пустое место, поэтому, когда вы вернёте данный массив после применения delete, удалённый таким образом элемент отобразится как undefined.
Рассмотрим соответствующий JavaScript-код:
<script type="text/javascript">
var Arr_Strings = 'The','JavaScript','Array','Totorial'];
var i;
var the_arr_before_after = "The original string array elements: <BR><BR>";
for (i=; i < Arr_Strings.length; i++){
the_arr_before_after += Arr_Stringsi + "<BR>";
}
document.getElementById("p1").innerHTML = the_arr_before_after;
//Применение delete
delete Arr_Strings2];
var the_arr_before_after = "Array elements after splice method: <BR><BR>";
for (i=; i < Arr_Strings.length; i++){
the_arr_before_after += Arr_Stringsi + "<BR>";
}
document.getElementById("p2").innerHTML = the_arr_before_after;
</script>
А теперь посмотрим на результат:
По примеру видно, что вместо 3-го элемента теперь отображается undefined, т. к. элемент был удалён функцией delete
Единственное, на что стоит обратить внимание, — номер индекса надо указывать в квадратных скобках
Копирование массива в JavaScript
slice()
В JS копирование массива бывает поверхностным либо неглубоким (shallow copy) а также deep copy, то есть глубоким.
В первом случае мы присваиваем переменной значение другой переменной, хранящей массив:
var users = "Tom", "Bob", "Bill"]; console.log(users); // var people = users; // shallow copy people1 = "John"; // меняем 2-й элемент console.log(users); //
В нашем случае переменная people после неглубокого копирования станет указывать на тот же массив, что и переменная users. Именно поэтому в случае изменения элементов в people, поменяются элементы и в users, ведь по факту это один и тот же массив.
Вышеописанное поведение не всегда желательно. К примеру, нам надо, чтобы после копирования переменные указывали на отдельные массивы. Тогда подойдёт глубокое копирование посредством метода slice():
var users = "Tom", "Bob", "Bill"]; console.log(users); // var people = users.slice(); // deep copy people1 = "John"; // меняем 2-й элемент console.log(users); // console.log(people); //
Теперь после копирования переменные станут указывать на разные массивы, поэтому мы сможем менять их отдельно друг от друга.
Кроме того, функция slice() даёт возможность копировать часть массива:
var users = "Tom", "Bob", "Bill", "Alice", "Kate"]; var people = users.slice(1, 4); console.log(people); //
В функцию slice() мы передаём начальный и конечный индексы, используемые для выборки значений из нашего массива. В таком случае выборка в новый массив начнётся с первого индекса по индекс № 4, не включая его. И, так как индексация массивов в JavaScript начинается с нуля, в новом массиве будут 2-й, 3-й и 4-й элементы.
push()
Функция push() добавит элемент в конец нашего массива:
var fruit = [];
fruit.push("груши");
fruit.push("яблоки");
fruit.push("сливы");
fruit.push("вишни","абрикосы");
document.write("В массиве fruit " + fruit.length + " элемента: <br/>");
document.write(fruit); // груши,яблоки,сливы,вишни,абрикосы
pop()
Такая функция, как pop(), удалит последний элемент из JavaScript-массива:
var fruit = "груши", "яблоки", "сливы"];
var lastFruit = fruit.pop(); // из массива извлекается последний элемент
document.write(lastFruit + "<br/>");
document.write("В массиве fruit " + fruit.length + " элемента: <br/>");
for(var i=; i <fruit.length; i++)
document.write(fruiti + "<br/>");
Итоговый вывод:
сливы В массиве fruit 2 элемента: груши яблоки
shift()
Теперь рассмотрим функцию shift(). Она может извлекать и удалять 1-й элемент из массива:
var fruit = "груши", "яблоки", "сливы"];
var firstFruit = fruit.shift();
document.write(firstFruit + "<br/>");
document.write("В массиве fruit " + fruit.length + " элемента: <br/>");
for(var i=; i <fruit.length; i++)
document.write(fruiti + "<br/>");
Вывод следующий:
груши В массиве fruit 2 элемента: яблоки сливы
unshift()
Что касается функции unshift(), то она добавит новый элемент в самое начало массива:
var fruit = "груши", "яблоки", "сливы"];
fruit.unshift("апельсины");
document.write(fruit);
Вывод браузера:
апельсины,груши,яблоки,сливы
# includes
Метод определяет, содержит ли массив определённый элемент, возвращая в зависимости от этого или .
Пример использования .
Вот такое логическое выражение:
используя метод includes можно записать вот так:
JavaScript методы, свойства и события для video и audio
Эти методы, свойства и события позволяют нам управлять элементами audio и video с помощью JavaScript, что позволяет писать собственные видео-плееры и аудио-проигрыватели с любым необходимым функционалом.
Генератор случайных чисел кратных заданному значению
Готовое решение для задач в которых необходимо генерировать случайные числа в заданном диапазоне, при этом чтобы эти числа были кратны какому то заданному числу.
Гугл карта для сайта — Google Maps API
Как самостоятельно без дополнительных расширений внедрить на сайте гугл-карту с меткой маркером и описанием в сплывающей подсказке, появляющейся при клике по маркеру.
Математические функции и операторы в JavaScript
Сборка арифметических операторов и методов чисел в JavaScript. Всё что связано с математикой в JavaScript с примерами функций и решений, собрано вместе на одной странице.
Методы консоли в JavaScript
В JavaScript специально для работы с консолью есть объект console. Ниже описаны доступные для объекта Console методы и приведены несколько примеров их использования.
Получение параметров из урла
Данное решение — это готовая javascript-функция, которая послужит для получения параметров из url-адреса веб-страницы.
Объекты не работают одинаково
Этот способ не подходит для сравнения объектов. В JavaScript любые два объекта с одинаковыми свойствами и значениями не считаются одинаковыми.
const a = {
name: "My Sister the Serial Killer",
author: "Oyinkan Braithwaite"
};
const b = {
name: "My Sister the Serial Killer
",
author: "Oyinkan Braithwaite"
};
a === b // false
В JavaScript объекты имеют ссылочный тип. Поэтому равными будут только ссылки на один и тот же объект. Таким образом, indexOf(object) в массиве объектов всегда будет возвращать индекс переданного элемента, даже если там есть другой объект с одинаковыми свойствами и значениями.
Удаляем элемент с помощью splice
Представьте, что мы создаём массив чисел и добавляем туда 5 элементов. Далее удаляем 3-й элемент с помощью splice. Кстати, точно таким же образом мы можем удалить и 1-й элемент массива.
Теперь посмотрим, что будет в нашем числовом массиве до и после применения метода JavaScript splice:
Теперь предлагаем вашему вниманию соответствующий JavaScript-код:
<script type="text/javascript">
var Arr_Numbers = 10,20,30,40,50];
var i;
var the_arr_before_after = "The original array: <BR>";
for (i=; i < Arr_Numbers.length; i++){
the_arr_before_after += Arr_Numbersi + "<BR>";
}
document.getElementById("p1").innerHTML = the_arr_before_after;
Arrretrun = Arr_Numbers.splice(2,1);
var the_arr_before_after = "Array elements after splice method: <BR>";
for (i=; i < Arr_Numbers.length; i++){
the_arr_before_after += Arr_Numbersi + "<BR>";
}
document.getElementById("p2").innerHTML = the_arr_before_after;
</script>
Обратите внимание, что для удаления элемента JS-массива использовались 2 параметра: один указывал на индекс удаляемого элемента, а второй на количество элементов, подлежащих удалению (в нашем случае, это 1). Но что будет, если мы не укажем второй параметр? Для ответа на этот вопрос, задействуем тот же код, но уже без указания количества элементов массива, подлежащих удалению (то есть без второго параметра):
Но что будет, если мы не укажем второй параметр? Для ответа на этот вопрос, задействуем тот же код, но уже без указания количества элементов массива, подлежащих удалению (то есть без второго параметра):
Arr_Numbers.splice(2);
Вот наш JavaScript-код:
<script type="text/javascript">
var Arr_Numbers = 10,20,30,40,50];
var i;
var the_arr_before_after = "The original array: <BR>";
for (i=; i < Arr_Numbers.length; i++){
the_arr_before_after += Arr_Numbersi + "<BR>";
}
document.getElementById("p1").innerHTML = the_arr_before_after;
Arrretrun = Arr_Numbers.splice(2);
var the_arr_before_after = "Array elements after splice method: <BR>";
for (i=; i < Arr_Numbers.length; i++){
the_arr_before_after += Arr_Numbersi + "<BR>";
}
document.getElementById("p2").innerHTML = the_arr_before_after;
//Удалённые элементы в возвращаемом массиве
var the_arr_before_after = "The removed array elements: <BR>";
for (i=; i < Arrretrun.length; i++){
the_arr_before_after += Arrretruni + "<BR>";
}
document.getElementById("p3").innerHTML = the_arr_before_after;
</script>
А вот итог:
Мы видим, что произошло удаление всех элементов, которые находились перед указанным номером индекса. Вдобавок к этому, splice возвратил нам массив удалённых элементов.
Большинство методов поддерживают «thisArg»
Почти все методы массива, которые вызывают функции – такие как , , , за исключением метода , принимают необязательный параметр .
Этот параметр не объяснялся выше, так как очень редко используется, но для наиболее полного понимания темы мы обязаны его рассмотреть.
Вот полный синтаксис этих методов:
Значение параметра становится для .
Например, вот тут мы используем метод объекта как фильтр, и передаёт ему контекст:
Если бы мы в примере выше использовали просто , то вызов был бы в режиме отдельной функции, с . Это тут же привело бы к ошибке.
Вызов можно заменить на , который делает то же самое. Последняя запись используется даже чаще, так как функция-стрелка более наглядна.
Общие методы массива
Иногда хочется применить методы массива к строкам или другим массивоподобным объектам (например, к аргументам (en-US) функции). Делая это, вы трактуете строку как массив символов (другими словами, рассматриваете не-массив в качестве массива). Например, в порядке проверки каждого символа в переменной str на то, что он является буквой (латинского алфавита), вы пишете следующий код:
Эта запись довольно расточительна и в JavaScript 1.6 введён общий сокращённый вид:
также доступны для объекта .
В настоящее время они не являются частью стандартов ECMAScript (хотя в ES2015 для достижения поставленной цели можно использовать ). Следующая прослойка позволяет использовать их во всех браузерах:
Демонстрация удаления конкретного элемента с использованием метода splice
В этой демо-версии создается массив чисел. Первоначально в массив добавляются пять элементов. После этого используется метод splice для удаления третьего элемента. Таким же образом в JavaScript можно удалить первый элемент массива.
Элементы числового массива отображаются до и после использования метода JavaScript splice следующим образом:
Посмотреть онлайн демо-версию и код
Код JavaScript с методом splice:
<script>
var Arr_Numbers = ;
var i;
var the_arr_before_after = "The original array: <BR>";
for (i=0; i < Arr_Numbers.length; i++){
the_arr_before_after += Arr_Numbers + "<BR>";
}
document.getElementById("p1").innerHTML = the_arr_before_after;
Arrretrun = Arr_Numbers.splice(2,1);
var the_arr_before_after = "Array elements after splice method: <BR>";
for (i=0; i < Arr_Numbers.length; i++){
the_arr_before_after += Arr_Numbers + "<BR>";
}
document.getElementById("p2").innerHTML = the_arr_before_after;
</script>
Вы заметили, что я использовал для JavaScript удаления элемента массива два параметра. Первый указывает индекс элемента, который нужно удалить. Второй – сколько элементов нужно удалить после указанного ключа.
В следующей демо-версии показан случай, когда мы используем второй параметр.
Использование функции delete для удаления элемента массива
Также, чтобы в JavaScript удалить элемент массива, можно использовать функцию delete. Но она сохраняет пустое место, и если вы вернете этот массив после использования функции, то удаленный элемент будет отображен как undefined.
Рассмотрим демо-версию, в которой используется функция delete:
Посмотреть онлайн демо-версию и код
Код JavaScript:
<script>
var Arr_Strings = ;
var i;
var the_arr_before_after = "The original string array elements: <BR><BR>";
for (i=0; i < Arr_Strings.length; i++){
the_arr_before_after += Arr_Strings + "<BR>";
}
document.getElementById("p1").innerHTML = the_arr_before_after;
//Использование функции delete
delete Arr_Strings;
var the_arr_before_after = "Array elements after splice method: <BR><BR>";
for (i=0; i < Arr_Strings.length; i++){
the_arr_before_after += Arr_Strings + "<BR>";
}
document.getElementById("p2").innerHTML = the_arr_before_after;
</script>
Вы видите, что для третьего элемента отображается undefined после его удаления с помощью функции delete.
Примечание. Вы должны указать номер индекса в квадратных скобках.
Чтобы в JavaScript удалить элемент массива, рекомендуется использовать splice. Метод delete может привести к возникновению сложностей по мере того, как количество undefined элементов будет увеличиваться.
Пожалуйста, оставляйте ваши мнения по текущей теме статьи. Мы крайне благодарны вам за ваши комментарии, отклики, дизлайки, подписки, лайки!
Поиск индекса элемента в JS
Функции indexOf() и lastIndexOf() вернут индекс 1-го и последнего включения элемента в массиве. К примеру:
var fruit = "яблоки", "груши", "огурцы", "яблоки", "груши"];
var firstIndex = fruit.indexOf("яблоки");
var lastIndex = fruit.lastIndexOf("яблоки");
var otherIndex = fruit.indexOf("черешня");
document.write(firstIndex); // 0
document.write(lastIndex); // 3
document.write(otherIndex); // -1
У firstIndex значение 0, так как первое включение «яблоки» в нашем массиве приходится на индекс 0, последнее — на индекс № 3. Если же элемент в массиве отсутствует, функции indexOf() и lastIndexOf() вернут значение -1.
every()
С помощью every() мы проверим, все ли наши элементы соответствуют какому-нибудь условию:
var numbers = 1, -12, 8, -2, 25, 62 ];
function condition(value, index, array) {
var result = false;
if (value > ) {
result = true;
}
return result;
};
var passed = numbers.every(condition);
document.write(passed); // false
В метод every() в качестве параметра осуществляется передача функции, представляющей условие. Данная функция принимает 3 параметра:
function condition(value, index, array) {
}
Здесь параметр value представляет перебираемый текущий элемент массива, параметр index представляет индекс данного элемента, а параметр array осуществляет передачу ссылки на массив.
В такой функции можно проверить переданное значение элемента на его соответствие определённому условию. В нашем примере мы проверяем каждый элемент массива на условие, больше ли он нуля. Когда больше, возвращается значение true, так как элемент соответствует условию. Когда меньше, возвращается значение false, т. к. элемент не соответствует нашему условию.
В результате, когда осуществляется вызов метода numbers.every(condition) он выполняет перебор всех элементов нашего массива numbers, а потом поочерёдно передает их в функцию condition. Когда эта функция возвращает значение true для всех элементов, метод every() тоже возвращает true. Когда хоть один элемент условию не соответствует, возвращается false.
some()
Функция/метод some() похожа на every() с той лишь разницей, что осуществляется проверка на соответствие условию хотя бы одного элемента.
Здесь some() вернёт true. Но если соответствующих условию элементов в массиве не будет, вернётся false:
var numbers = 1, -12, 8, -2, 25, 62 ];
function condition(value, index, array) {
var result = false;
if (value === 8) {
result = true;
}
return result;
};
var passed = numbers.some(condition); // true
filter()
Как some() и every(), метод filter()принимает функцию условия. Но тут возвращается массив элементов, соответствующих условию:
var numbers = 1, -12, 8, -2, 25, 62 ];
function condition(value, index, array) {
var result = false;
if (value > ) {
result = true;
}
return result;
};
var filteredNumbers = numbers.filter(condition);
for(var i=; i < filteredNumbers.length; i++)
document.write(filteredNumbersi + "<br/>");
Вот результат вывода:
1 8 25 62
forEach() и map()
Функции forEach() и map() выполняют перебор элементов, осуществляя с ними некоторые операции. К примеру, чтобы вычислить квадраты чисел в массиве, делаем так:
var numbers = 1, 2, 3, 4, 5, 6];
for(var i = ; i<numbers.length; i++){
var result = numbersi * numbersi];
document.write("Квадрат нашего числа " + numbersi + " равен " + result + "<br/>");
}
Конструкция может быть упрощена посредством forEach():
var numbers = 1, 2, 3, 4, 5, 6];
function square(value, index, array) {
var result = value * value;
document.write("Квадрат нашего числа " + value + " равен " + result + "<br/>");
};
numbers.forEach(square);
Здесь forEach() в качестве параметра принимает ту же функцию, в которую в процессе перебора элементов передаётся перебираемый текущий элемент, и над ним выполняются операции.
Что касается map(), то этот метод похож на forEach с той лишь разницей, что map() возвращает новый массив, где отображены результаты операций над элементами массива.
Допустим, давайте, применим map к вычислению квадратов чисел нашего массива:
var numbers = 1, 2, 3, 4, 5, 6];
function square(value, index, array) {
return result = value * value;
};
var squareArray = numbers.map(square);
document.write(squareArray);
Функция, передаваемая в map(), получает текущий перебираемый элемент, выполняя над ним операции и возвращая некоторое значение. Именно это значение и попадает в результирующий массив squareArray.
