webdonsk.ruКак сделать обратный массив js
Добавил пользователь Валентин П. Обновлено: 10.09.2024
Язык JavaScript предоставлет богатые возможности для работы с массивами, которые реализуются с помощью методов объекта Array. Рассмотрим применение этих методов
Копирование массива. slice()
Копирование массива может быть поверхностным или неглубоким (shallow copy) и глубоким (deep copy).
При неглубоком копировании достаточно присвоить переменной значение другой переменной, которая хранит массив:
В данном случае переменная people после копирования будет указывать на тот же массив, что и переменная users. Поэтому при изменении элементов в people, изменятся элементы и в users, так как фактически это один и тот же массив.
Такое поведение не всегда является желательным. Например, мы хотим, чтобы после копирования переменные указывали на отдельные массивы. И в этом случае можно использовать глубокое копирование с помощью метода slice() :
В данном случае после копирования переменные будут указывать на разные массивы, и мы сможем изменять их отдельно друг от друга.
Но тут стоит отметить, что то же самое копирование по сути можно выполнить и с помощью spread-оператора . :
Также метод slice() позволяет скопировать часть массива. Для этого он принимает два параметра:
Первый параметр указывает на начальный индекс элемента, с которого которые используются для выборки значений из массива. А второй параметр - конечный индекс, по который надо выполнить копирование.
Например, выберем в новый массив элементы, начиная с 1 индекса по индекс 4 не включая:
И поскольку индексация массивов начинается с нуля, то в новом массиве окажутся второй, третий и четвертый элемент.
Если указан только начальный индекс, то копирование выполняется до конца массива:
Метод push() добавляет элемент в конец массива:
Метод pop() удаляет последний элемент из массива:
shift()
Метод shift() извлекает и удаляет первый элемент из массива:
unshift()
Метод unshift() добавляет новый элемент в начало массива:
Удаление элемента по индексу. splice()
Метод splice() удаляет элементы с определенного индекса. Например, удаление элементов с третьего индекса:
Метод splice возвращает удаленные элементы в виде нового массива.
В данном случае удаление идет с начала массива. Если передать отрицательный индекс, то удаление будет производиться с конца массива. Например, удалим последний элемент:
Дополнительная версия метода позволяет задать количество элементов для удаления. Например, удалим с первого индекса три элемента:
Еще одна версия метода splice позволяет вставить вместо удаляемых элементов новые элементы:
В данном случае удаляем три элемента с 1-го индекса и вместо них вставляем два элемента.
concat()
Метод concat() служит для объединения массивов. В качестве результата он возвращает объединенный массив:
Метод join() объединяет все элементы массива в одну строку, используя определенный разделитель, который передается через параметр:
В метод join() передается разделитель между элементами массива. В данном случае в качестве разделителя будет использоваться точка с запятой и пробел ("; ").
Метод sort() сортирует массив по возрастанию:
Стоит отметить, что по умолчанию метод sort() рассматривает элементы массива как строки и сортирует их в алфавитном порядке. Что может привести к неожиданным результатам, например:
Здесь мы хотим отсортировать массив чисел, но результат может нас обескуражить: [15, 200, 35, 5] . В этом случае мы можем настроить метод, передав в него функцию сортировки. Логику функции сортировки мыы определяем сами:
Функция сортировки получает два рядом расположенных элемента массива. Она возвращает положительное число, если первый элемент должен находится перед вторым элементом. Если первый элемент должен располагаться после второго, то возвращается отрицательное число. Если элементы равны, возвращается 0.
reverse()
Метод reverse() переворачивает массив задом наперед:
Поиск индекса элемента
Методы indexOf() и lastIndexOf() возвращают индекс первого и последнего включения элемента в массиве. Например:
firstIndex имеет значение 0, так как первое включение строки "Tom" в массиве приходится на индекс 0, а последнее на индекс 3.
Если же элемент отсутствует в массиве, то в этом случае методы indexOf() и lastIndexOf() возвращают значение -1.
Проверка наличия элемента
Метод includes() проверяет, есть ли в массиве значение, переданное в метод через параметр. Если такое значение есть, то метод возвращает true , если значения в массиве нет, то возвращается false . Например:
В качестве второго параметра метод includes() принимает индекс, с которого надо начинать поиск:
В данном случае мы видим, что при поиске со 2-го индекса в массиве есть строка "Bob", тогда как начиная с 5-го индекса данная строка отсутствует.
Если если этот параметр не передается, то по умолчанию поиск идет с 0-го индекса.
При передаче отрицательного значения поиск идет с конца
every()
Метод every() проверяет, все ли элементы соответствуют определенному условию:
В метод every() в качестве параметра передается функция, которая представляет условие. Эта функция в качестве параметра принимает элемент и возвращает true (если элемент соответствует условию) или false (если не соответствует).
Если хотя бы один элемент не соответствует условию, то метод every() возвращает значение false .
В данном случае условие задается с помощью лямбда-выражения n => n > 0 , которое проверяет, больше ли элемент нуля.
Метод some() похож на метод every() , только он проверяет, соответствует ли хотя бы один элемент условию. И в этом случае метод some() возвращает true . Если элементов, соответствующих условию, в массиве нет, то возвращается значение false :
filter()
Метод filter() , как some() и every() , принимает функцию условия. Но при этом возвращает массив тех элементов, которые соответствуют этому условию:
forEach() и map()
Методы forEach() и map() осуществляют перебор элементов и выполняют с ними определенный операции. Например, используем метод метода forEach() для вычисления квадратов чисел в массиве:
Метод forEach() в качестве параметра принимает функцию, которая имеет один ппараметр - текущий перебираемый элемент массива. А в теле функции над этим элементом можно выполнить различные операции.
Консольный вывод программы:
Метод map() похож на метод forEach , он также в качестве параметра принимает функцию, с помощью которой выполняются операции над перебираемыми элементами массива, но при этом метод map() возвращает новый массив с результатами операций над элементами массива.
Например, применим метод map к вычислению квадратов чисел массива:
Функция, которая передается в метод map() получает текущий перебираемый элемент, выполняет над ним операции и возвращает некоторое значение. Это значение затем попадает в результирующий массив squares
Поиск в массиве
Метод find() возвращает первый элемент массива, который соответствует некоторому условию. В качестве параметр метод find принимает функцию условия:
В данном случае получаем первый элемент, который больше 10. Если элемент, соответствующий условию, не найден, то возвращается undefined .
Метод findIndex также принимает функцию условия, только возвращает индекс первого элемента массива, который соответствует этому условию:
Если элемент не найден, то возвращается число -1.
Метод flat и преобразование массива
Метод flat() упрощает массив с учетом указанной вложенности элементов:
То есть метод flat() фактически из вложенных массивов переводит элементы во внешний массив самого верхнего уровня. Однако мы видим, что элементы массива второго уровня вложенности перешли в массив первого уровня вложенности, но тем не менее по-прежнему находятся во вложенном массиве. Дело в том, что метод flat() по умолчанию применяется только к вложенным массивам первого уровня вложенности. Но мы можем передать в метод уровень вложености:
Если массив содержит вложенные массивы гораздо более глубоких уровней вложенности, или мы даже не знаем, какие уровни вложенности есть в массиве, но мы хотим, чтобы все элементы были преобразованы в один массив, то можно использовать значение Infinity :
- это упорядоченная коллекция значений. Значения в массиве называются , и каждый элемент характеризуется числовой позицией в массиве, которая называется . Массивы в языке JavaScript являются нетипизированными: элементы массива могут иметь любой тип, причем разные элементы одного и того же массива могут иметь разные типы. Элементы массива могут даже быть объектами или другими массивами, что позволяет создавать сложные структуры данных, такие как массивы объектов и массивы массивов.
Отсчет индексов массивов в языке JavaScript начинается с нуля и для них используются 32-битные целые числа - первый элемент массива имеет индекс 0. Массивы в JavaScript являются динамическими: они могут увеличиваться и уменьшаться в размерах по мере необходимости; нет необходимости объявлять фиксированные размеры массивов при их создании или повторно распределять память при изменении их размеров.
Массивы в языке JavaScript - это специализированная форма объектов, а индексы массивов означают чуть больше, чем просто имена свойств, которые по совпадению являются целыми числами.
Создание массивов
Легче всего создать массив с помощью литерала, который представляет собой простой список разделенных запятыми элементов массива в квадратных скобках. Значения в литерале массива не обязательно должны быть константами - это могут быть любые выражения, в том числе и литералы объектов:
Синтаксис литералов массивов позволяет вставлять необязательную завершающую запятую, т.е. литерал [,,] соответствует массиву с двумя элементами, а не с тремя.
Другой способ создания массива состоит в вызове конструктора Array(). Вызвать конструктор можно тремя разными способами:
Вызвать конструктор без аргументов:
В этом случае будет создан пустой массив, эквивалентный литералу [].
Вызвать конструктор с единственным числовым аргументом, определяющим длину массива:
В этом случае будет создан пустой массив указанной длины. Такая форма вызова конструктора Array() может использоваться для предварительного распределения памяти под массив, если заранее известно количество его элементов. Обратите внимание, что при этом в массиве не сохраняется никаких значений.
Явно указать в вызове конструктора значения первых двух или более элементов массива или один нечисловой элемент:
В этом случае аргументы конструктора становятся значениями элементов нового массива. Использование литералов массивов практически всегда проще, чем подобное применение конструктора Array().
Чтение и запись элементов массива
Доступ к элементам массива осуществляется с помощью оператора []. Слева от скобок должна присутствовать ссылка на массив. Внутри скобок должно находиться произвольное выражение, возвращающее неотрицательное целое значение. Этот синтаксис пригоден как для чтения, так и для записи значения элемента массива. Следовательно, допустимы все приведенные далее JavaScript-инструкции:
Напомню, что массивы являются специализированной разновидностью объектов. Квадратные скобки, используемые для доступа к элементам массива, действуют точно так же, как квадратные скобки, используемые для доступа к свойствам объекта. Интерпретатор JavaScript преобразует указанные в скобках числовые индексы в строки - индекс 1 превращается в строку "1" - а затем использует строки как имена свойств.
В преобразовании числовых индексов в строки нет ничего особенного: то же самое можно проделывать с обычными объектами:
Особенность массивов состоит в том, что при использовании имен свойств, которые являются неотрицательными целыми числами, массивы автоматически определяют значение свойства length. Например, выше был создан массив arr с единственным элементом. Затем были присвоены значения его элементам с индексами 1, 2 и 3. В результате этих операций значение свойства length массива изменилось и стало равным 4.
Следует четко отличать индексы в массиве от имен свойств объектов. Все индексы являются именами свойств, но только свойства с именами, представленными целыми числами являются индексами. Все массивы являются объектами, и вы можете добавлять к ним свойства с любыми именами. Однако если вы затрагиваете свойства, которые являются индексами массива, массивы реагируют на это, обновляя значение свойства length при необходимости.
Обратите внимание, что в качестве индексов массивов допускается использовать отрицательные и не целые числа. В этом случае числа преобразуются в строки, которые используются как имена свойств.
Добавление и удаление элементов массива
Мы уже видели, что самый простой способ добавить элементы в массив заключается в том, чтобы присвоить значения новым индексам. Для добавления одного или более элементов в конец массива можно также использовать метод push():
Добавить элемент в конец массива можно также, присвоив значение элементу arr[arr.length]. Для вставки элемента в начало массива можно использовать метод unshift(), при этом существующие элементы в массиве смещаются в позиции с более высокими индексами.
Удалять элементы массива можно с помощью оператора delete, как обычные свойства объектов:
Удаление элемента напоминает (но несколько отличается) присваивание значения undefined этому элементу. Обратите внимание, что применение оператора delete к элементу массива не изменяет значение свойства length и не сдвигает вниз элементы с более высокими индексами, чтобы заполнить пустоту, оставшуюся после удаления элемента.
Кроме того имеется возможность удалять элементы в конце массива простым присваиванием нового значения свойству length. Массивы имеют метод pop() (противоположный методу push()), который уменьшает длину массива на 1 и возвращает значение удаленного элемента. Также имеется метод shift() (противоположный методу unshift()), который удаляет элемент в начале массива. В отличие от оператора delete, метод shift() сдвигает все элементы вниз на позицию ниже их текущих индексов.
Наконец существует многоцелевой метод splice(), позволяющий вставлять, удалять и замещать элементы массивов. Он изменяет значение свойства length и сдвигает элементы массива с более низкими или высокими индексами по мере необходимости. Все эти методы мы разберем чуть позже.
Многомерные массивы
Например, предположим, что переменная matrix - это массив массивов чисел. Каждый элемент matrix[x] - это массив чисел. Для доступа к определенному числу в массиве можно использовать выражение matrix[x][y]. Ниже приводится конкретный пример, где двумерный массив используется в качестве таблицы умножения:
Методы класса Array
Стандарт ECMAScript 3 определяет в составе Array.prototype множество удобных функций для работы с массивами, которые доступны как методы любого массива. Эти методы будут представлены в следующих подразделах.
Метод join()
Метод Array.join() преобразует все элементы массива в строки, объединяет их и возвращает получившуюся строку. В необязательном аргументе методу можно передать строку, которая будет использоваться для отделения элементов в строке результата. Если строка-разделитель не указана, используется запятая. Например, следующий фрагмент дает в результате строку "1,2,3":
Метод reverse()
Метод Array.reverse() меняет порядок следования элементов в массиве на обратный и возвращает переупорядоченный массив. Перестановка выполняется непосредственно в исходном массиве, т.е. этот метод не создает новый массив с переупорядоченными элементами, а переупорядочивает их в уже существующем массиве. Например, следующий фрагмент, где используются методы reverse() и join(), дает в результате строку "3,2,1":
Метод sort()
Метод Array.sort() сортирует элементы в исходном массиве и возвращает отсортированный массив. Если метод sort() вызывается без аргументов, сортировка выполняется в алфавитном порядке (для сравнения элементы временно преобразуются в строки, если это необходимо). Неопределенные элементы переносятся в конец массива.
Для сортировки в каком-либо ином порядке, отличном от алфавитного, методу sort() можно передать функцию сравнения в качестве аргумента. Эта функция устанавливает, какой из двух ее аргументов должен следовать раньше в отсортированном списке. Если первый аргумент должен предшествовать второму, функция сравнения должна возвращать отрицательное число. Если первый аргумент должен следовать за вторым в отсортированном массиве, то функция должна возвращать число больше нуля. А если два значения эквивалентны (т.е. порядок их следования не важен), функция сравнения должна возвращать 0:
Обратите внимание, насколько удобно использовать в этом фрагменте неименованную функцию. Функция сравнения используется только здесь, поэтому нет необходимости давать ей имя.
Метод concat()
Метод Array.concat() создает и возвращает новый массив, содержащий элементы исходного массива, для которого был вызван метод concat(), и значения всех аргументов, переданных методу concat(). Если какой-либо из этих аргументов сам является массивом, его элементы добавляются в возвращаемый массив. Следует, однако, отметить, что рекурсивного превращения массива из массивов в одномерный массив не происходит. Метод concat() не изменяет исходный массив. Ниже приводится несколько примеров:
Метод slice()
Метод Array.slice() возвращает фрагмент, или подмассив, указанного массива. Два аргумента метода определяют начало и конец возвращаемого фрагмента. Возвращаемый массив содержит элемент, номер которого указан в первом аргументе, плюс все последующие элементы, вплоть до (но не включая) элемента, номер которого указан во втором аргументе.
Если указан только один аргумент, возвращаемый массив содержит все элементы от начальной позиции до конца массива. Если какой-либо из аргументов имеет отрицательное значение, он определяет номер элемента относительно конца массива. Так, аргументу -1 соответствует последний элемент массива, а аргументу -3 - третий элемент массива с конца. Вот несколько примеров:
Метод splice()
Метод Array.splice() - это универсальный метод, выполняющий вставку или удаление элементов массива. В отличие от методов slice() и concat(), метод splice() изменяет исходный массив, относительно которого он был вызван. Обратите внимание, что методы splice() и slice() имеют очень похожие имена, но выполняют совершенно разные операции.
Метод splice() может удалять элементы из массива, вставлять новые элементы или выполнять обе операции одновременно. Элементы массива при необходимости смещаются, чтобы после вставки или удаления образовывалась непрерывная последовательность.
Первый аргумент метода splice() определяет позицию в массиве, начиная с которой будет выполняться вставка и/или удаление. Второй аргумент определяет количество элементов, которые должны быть удалены (вырезаны) из массива. Если второй аргумент опущен, удаляются все элементы массива от указанного до конца массива. Метод splice() возвращает массив удаленных элементов или (если ни один из элементов не был удален) пустой массив.
Первые два аргумента метода splice() определяют элементы массива, подлежащие удалению. За этими аргументами может следовать любое количество дополнительных аргументов, определяющих элементы, которые будут вставлены в массив, начиная с позиции, указанной в первом аргументе.
Методы push() и pop()
Методы push() и pop() позволяют работать с массивами как со стеками. Метод push() добавляет один или несколько новых элементов в конец массива и возвращает его новую длину. Метод pop() выполняет обратную операцию - удаляет последний элемент массива, уменьшает длину массива и возвращает удаленное им значение. Обратите внимание, что оба эти метода изменяют исходный массив, а не создают его модифицированную копию.
Методы unshift() и shift()
Методы unshift() и shift() ведут себя почти так же, как push() и pop(), за исключением того, что они вставляют и удаляют элементы в начале массива, а не в конце. Метод unshift() смещает существующие элементы в сторону больших индексов для освобождения места, добавляет элемент или элементы в начало массива и возвращает новую длину массива. Метод shift() удаляет и возвращает первый элемент массива, смещая все последующие элементы на одну позицию вниз, чтобы занять место, освободившееся в начале массива.
Массив – это специальная структура данных, которая предназначена для хранения упорядоченных коллекций значений.
Массивы очень полезны и довольно часто используются в коде, т.к. позволяют нам хранить несколько значений в одной переменной.
Например, вместо того чтобы использовать 5 переменных можно объявить одну со всеми этими значениями:
Каждое значение в массиве имеет свой порядковый номер (индекс). Значения называются элементами. Первый элемент массива имеет индекс 0, второй – 1, третий – 2 и т.д.
На следующем рисунке показан массив, состоящий из 5 элементов: 123, 7, 50, -9, 24.
При этом необязательно, чтобы все элементы массива имели один и тот же тип данных. Элементами могут быть любые значения – даже другие массивы. Это позволяет создавать сложные структуры данных, например, такие как массивы объектов или массивы массивов.
Объявление массива
Создание массива в JavaScript можно выполнить двумя способами: с помощью литерала и конструктора Array() .
Пример создания пустого массива:
Метод создания массива с помощью литерала (квадратных скобок) более предпочтителен и в большинстве случаев лучше использовать именно его.
При объявлении массива в нём можно сразу создать элементы. Для этого внутрь скобок необходимо поместить элементы, отделив их друг от друга запятой:
Внимание! Если конструктору Array() передать один аргумент, который является числом, то он создаст массив с указанным количеством элементов. Значения элементов при этом будут неопределёнными (пустыми):
При создании массивов в конец разрешается вставлять необязательную завершающую запятую:
Доступ к элементам
Получение доступа к элементу массива выполняется через квадратные скобки, внутрь которых нужно поместить индекс.
Так как индексы нумеруются с 0, то для получение первого, второго и третьего элемента нужно использовать индексы 0, 1 и 2.
При попытке получить доступ к несуществующему элементу возвращается undefined :
Чтобы изменить элемент, ему нужно просто присвоить новое значение:
Сейчас в переменной $colors три элемента. Для добавления нового элемента в массив, можно просто присвоить нужное значение следующему индексу:
Если при добавлении элемента случайно пропустить индекс, то в массиве появится неопределенный элемент:
Определить количество элементов в массиве можно с помощью свойства length :
Зная количество, получить последний элемент можно так:
Пример массива, элементы которого содержат различные типы данных:
В качестве элементов массива можно использовать выражения:
Массивы – это объекты?
Массивы в JavaScript не являются каким-то определённым типом данных. Это объекты, а точнее их определённый вид ( Array ).
Например, получим с помощью оператора typeof тип данных:
А так как массивы являются объектами, то при его копировании, передаётся не он сам, а ссылка на него:
Для копирования массива можно воспользоваться следующими способами:
Конструктором массивов является Array :
Проверить содержит ли переменная массив можно следующим образом:
Перебор массива
Перебор элементов можно выполнить различными способами.
Один из первых способов – это использовать цикл for :
Второй способ – метод forEach :
Третий способ – цикл цикл for..of :
Если нужно с индексами:
Поиск элемента в массиве
Найти элемент в массиве можно с помощью метода indexOf() :
В качестве результата он возвращает индекс первого найденного элемента.
Если элемент не найден, то indexOf() возвращает -1 . Это можно использовать, например, чтобы проверить существует ли элемент в массиве:
Метод indexOf() позволяет искать элементы не только с начала, но и с определённого индекса. Для этого ему нужно его указать в качестве второго аргумента:
Метод lastIndexOf() выполняет то же самое что indexOf() , только осуществляет это с конца:
Начиная с версии ECMAScript 7 появился новый метод includes() .
Он позволяет проверить содержит ли массив указанный элемент:
Он похож на indexOf() , но в отличие от него возвращает true или false .
С использованием второго аргумента:
При отрицательных значениях from поиск выполняется начиная с array.length + from .
В отличие от indexOf() , в котором используется строгое равенство (Strict Equality Comparison), в includes() используется алгоритм равенства SameValueZero. Это значит, что вы можете, например, определить, содержит ли массив NaN :
Также в отличие от indexOf() , includes() не пропускает отсутствующие элементы:
Удаление элементов массива
Удаление элемента массива с помощью delete делает его неопределённым (пустым). Длина массива при этом не изменяется.
Если нужно конкретно удалить элемент из массива, то можно воспользоваться методом splice .
Пример удаления элемента массива по индексу:
С помощью filter() :
Добавление и удаление элементов
В JavaScript для добавления и удаления элементов имеются следующие методы:
- push() – для добавления одного или нескольких элементов в конец массива;
- unshift() – для добавления одного или нескольких элементов в начало массива;
- pop() – для удаления последнего элемента;
- shift() – для удаления первого элемента.
Пример использования методов:
Функции для работы с массивами (методы объекта Array)
Объект Array содержит следующие методы (функции) для работы с массивами:
slice - копирование участка массива
Метод slice предназначен для копирования участка массива. При этом он не изменяет исходный массив, а возвращает в качестве результата новый массив, состоящий из выбранных элементов.
Метод slice имеет 2 параметра:
- 1 параметр (обязательный) - предназначен для указания индекса элемента, с которого необходимо начать копировать элементы;
- 2 параметр (необязательный) - предназначен для указания индекса элемента, до которого необходимо копировать (при этом он не включается в новый массив). Если его не указать, то будут скопированы элементы до конца указанного массива.
splice - изменение содержимого массива
Метод splice предназначен для изменения содержимого массива. Он может использваться как для добавления элементов в массив, так и для их удаления.
Синтаксис метода splice :
Примеры использования метода splice.
Применения метода splice для удаления части элементов из массива.
Применение метода splice для удаления элемента из массива и добавления в него новых.
Применение метода splice только для добавления новых элементов в массив.
join - преобразование массива в строку
Метод join предназначен для соединения всех элементов массива в строку.
Синтаксис метода join :
Если в качестве separator использовать не строку, то он будет преобразован к строке.
Элементы массива, которые имеют в качестве значения null или undefined, будут приведены к пустой строке.
Преобразование строки в массив
Создание массива из строки посредством её разбивания с помощью разделителя в JavaScript осуществляется с помощью метода split() . Разделитель указывается в качестве аргумента.
Переворот массива
Перестановка элементов массива в обратном порядке осуществляется в JavaScript с помощью reverse() :
Сортировка элементов массива
Сортировка массива выполняется с помощью метода sort() . По умолчанию он сортирует массив в порядке следования символов в кодировке Unicode.
Реальная сила массивов JavaScript заключается в их встроенных свойствах и методах. Благодаря встроенным методам объекта Array, с массивами JavaScript можно делать самые разнообразные вещи без особых усилий и ресурсозатрат.
Преобразование массива в строку
JavaScript метод toString() преобразует массив в строку из значений элементов массива, разделенных запятыми.
В результате будет выведена строка "Банан, Апельсин, Яблоко, Манго".
Метод join() также объединяет все элементы массива в одну строку. Он действует как метод toString(), но при этом позволяет указать разделитель:
В результате будет выведена строка "Банан * Апельсин * Яблоко * Манго".
Удаление и добавление элементов
Когда вы работаете с массивами, вам часто приходится удалять и добавлять элементы. При помощи специальных методов это можно сделать легко и безопасно.
Метод pop() удаляет последний элемент массива:
При этом метод pop() возвращает значение удаленного элемента:
Метод push() добавляет новый элемент в конец массива:
При этом метод push() возвращает новую длину массива:
Метод shift() удаляет первый элемент массива и сдвигает оставшиеся элементы к меньшим индексам:
При этом метод shift() возвращает значение удаленного элемента:
Метод unshift() добавляет новый элемент в начало массива и передвигает другие элементы:
При этом метод unshift() возвращает новую длину массива:
Изменение значений элементов
Доступ к значениям элементов массива осуществляется по номеру индекса элемента.
Нумерация индексов начинается с 0. Индекс первого элемента массива [0], второго - [1], третьего - [2] и т. д.
Свойство length позволяет легко добавлять новые элементы в конец массива:
Стирание элементов
В связи с тем, что массивы в JavaScript являются объектами, существует еще один способ удаления элементов массива — при помощи оператора delete:
Внимание! Использование оператора delete может оставить в массиве неучитываемые "дыры" из значений undefined. Для удаления элементов массива лучше использовать метод pop() или shift().
Добавление группы элементов
Метод splice() используется для добавления в массив группы новых элементов:
Первый параметр (2) определяет позицию, куда вставляются новые элементы.
Второй параметр (0) определяет, сколько элементов должно быть удалено.
Остальные параметры ("Лимон" , "Киви") определяют вставляемые элементы.
Метод splice() также можно использовать для удаления элементов из массива. Делает он это безопасно и чисто, не оставляя в массиве "дыр":
Первый параметр (0) определяет позицию, куда вставляются новые элементы.
Второй параметр (1) определяет, сколько элементов должно быть удалено.
Остальные параметры не заданы. Новые элементы не вставляются.
Слияние массивов
Метод concat() создает новый массив путем слияния (объединения) существующих массивов.
Пример (Слияние двух массивов):
Метод concat() не изменяет существующие массивы. Он создает новый массив.
Метод concat() в параметрах может принимать любое число массивов.
Пример (Слияние трех массивов):
В качестве параметров метод concat() может принимать как переменные, так и значения.
Пример (Слияние массива со значением):
Извлечение части массива
Метод slice() позволяет извлечь (вырезать) часть массива в новый массив.
В следующем примере извлекается часть массив, начиная с элемента с индексом 1 ("Апельсин"):
Метод slice() создает новый массив. В исходном массиве никакие элементы не удаляются.
В следующем примере извлекается часть массив, начиная с элемента с индексом 3 ("Яблоко"):
Метод slice() принимает два параметра. Например, slice(1, 3). В этом случае метод slice() выбирает элементы, начиная с элемента с индексом, указанным в первом параметре, и заканчивая (но не включая) элементом с индексом, указанным во втором параметре. Если второй параметр не задан, то извлекаются все элементы до конца массива.
Автоматическое применение toString()
Если элементами массива являются примитивные значения, то JavaScript автоматически преобразует массив в строку из разделенных запятыми значений его элементов.
Читайте также: