| *** Содержание *** |
Массив - это объект, содержащий большое количество связанных друг с другом данных. Это намного проще и удобнее, чем создавать огромное количество переменных с различными именами: у массива только одно имя, а доступ к элементам осуществляется по индексу (порядковому номеру). Например, вместо того, что бы писать код типа
1 var a = 10;
2 var b = 20;
3 var c = 30;
можно написать
1 var NameArray = [10, 20, 30]; // здесь и далее NameArray - это имя массива!
В результате мы получим массив - список, где каждому элементу присвоен свой порядковый номер, называемый индексом:
| Массив NameArray | |||
| Индекс | 0 | 1 | 2 |
| Значение | 10 | 20 | 30 |
Отсчёт порядковых номеров элементов массива (индексов) начинается с нуля, а не с единицы!
При указании значений, если возникает необходимость присвоить элементу значение undefined ("не определено"), вы можете воспользоваться лишней запятой. Это значит, что если в коде при присвоении значений находится "лишняя" запятая, то очередному элементу (с индексом) присваивается указанное значение:
1 var NameArray = [10, 20, , 30];
В данном примере список элементов будет следующий: 10, 20, undefined, 30, т.е. элементов будет уже четыре.
Для того, что бы получить информацию о количестве элементов в массиве используется выражение
1 var NameArray = [10, 20, 30];
2 d = NameArray.length;
при этом переменная d получит значение 3, т.е. в массиве находится три элемента.
Так же можно создать массив при помощи метода Array.of(); при этом в скобках передаются все элементы:
1 var NameArray = Array.of(10, 20, 30);
В результате переменная NameArray получит массив [10, 20, 30].
Присвоение значения конкретному элементу
Что бы присвоить значение конкретному элементу при помощи индекса, необходимо воспользоваться выражением
1 NameArray[1] = 20
В этом случае значение второго по счёту элемента будет переписано на указанное значение.
Получение значения элемента массива
Получить значение элемента массива можно при помощи индекса, т.е. его порядкового номера:
1 var NameArray = [10, 20, 30];
2 var Y = NameArray[1];
В данном примере переменная Y получит значение 20.
Добавление элемента в массив
Что бы добавить элемент в конец массива используется метод push:
1 NameArray.push(40);
В результате в массиве будет уже четыре элемента: 10, 20, 30 и 40.
Что бы добавить элемент в начало массива используется метод unshift:
1 NameArray.unshift(0);
В результате в начало массива будет добавлен новый элемент: 0, 10, 20, 30, 40.
Удаление элементов массива
Что бы удалить первый элемент массива используется метод shift:
1 NameArray.shift();
Этот метод позволяет не только удалить первый элемент, но и вернуть его значение:
1 var s = NameArray.shift();
В данном примере переменная s получает значение удалённого элемента.
Что бы удалить последний элемент массива используется метод pop:
1 NameArray.pop();
Этот метод позволяет не только удалить последний элемент, но и вернуть его значение:
1 var s = NameArray.pop();
В данном примере переменная s получает значение удалённого элемента.
Для удаления определённого элемента или нескольких элементов подряд по индексу используется метод splice:
1 NameArray.splice(i,1);
где i - это позиция (индекс) элемента, а 1 - это количество удаляемых элементов. Если это число больше единицы, то будут удалены несколько элементов, следующих подряд, начиная с указанного индекса. Так же можно получить значения удаляемых документов:
1 var s = NameArray.splice(i,1);
В данном примере переменная s так же получает значение удалённого элемента.
Удаление элементов массива со вставлением новых
Метод позволяет не только удалять элементы, но и одновременно вставлять новые. Для этого в скобках к индексу и количеству удаляемых элементов добавляется третье значение:
1 var NameArray = [10, 20, 30, 40, 50];
2 var s = NameArray.splice(2,1, 70);
В данном примере будет удалён один элемент, находящийся на позиции 2 в массиве и вместо него на ту же позицию будет подставлен элемент со значением 70, т.е. теперь массив будет выглядеть так: 10, 20, 70, 40, 50.
Если будет указано количество удаляемых элементов больше единицы, то будут удалены элементы, начиная с указанного индекса, а подставляемое значение будет установлено на ту позицию, которая указана:
1 var NameArray = [10, 20, 30, 40, 50];
2 var s = NameArray.splice(2,2, 70);
В данном примере будут удалены два элемента, следующие друг за другом начиная с позиции 2, т.е. это будут элементы 30 и 40; вместо первого удаляемого элемента будет подставлено значение 70, в результате чего получится массив 10, 20, 70, 50. Обратите внимание, что в этом случае позиция элемента 50 изменяется: теперь она стала 3 вместо 4.
Если при удалении будут подставляться несколько значений, то они будут следовать друг за другом:
1 var NameArray = [10, 20, 30, 40, 50];
2 var s = NameArray.splice(2,1, 70, 100);
В данном примере будет удалено значение на второй позиции, и с этой же позиции начнётся подстановка новых значений, т.е. в результате будет получен массив 10, 20, 70, 100, 40, 50.
Если количество удаляемых элементов равно 0, то элементы не удаляются, а новый элемент вставляется на указанную позицию:
1 var NameArray = [10, 20, 30, 40, 50];
2 var s = NameArray.splice(2,0, 70);
В результате будет получен массив 10, 20, 70, 30, 40, 50.
В случае удаления со вставлением новых элементов, так же как и при простом удалении можно получить значения удаляемых элементов: во всех описанных примерах переменная s получает удалённые значения.
Поиск номера элемента
Для того, что бы найти индекс определённого элемента, необходимо обратиться к методу indexOf() и воспользоваться выражением
1 var i = NameArray.indexOf(30);
В результате в переменную i будет записано значение 2.
Так же может быть указан индекс, с которого нужно начинать поиск (если это нужно делать не с начала списка):
1 var i = NameArray.indexOf(30, 1);
Теперь поиск начнётся с индекса 1, а не с начала списка.
Обратите внимание на то, что при помощи метода indexOf() будет найден первый от начала индекс, в котором будет обнаружено данное значение. Если требуется найти последний индекс элемента с указанным значением, необходимо использовать похожий метод lastIndexOf(), который так же производит поиск, но с конца списка (в обратную сторону). Синтаксис при этом не меняется: в скобках сначала указывается искомое значение, затем (при необходимости) - индекс, с которого будет начинаться поиск; не забудьте, что поиск происходит в обратном направлении (т.е. к началу массива).
Если значение не будет найдено в массиве, то в результате будет выдано значение -1.
Свойство Lenght
Это свойство либо возвращает длину массива, т.е. количество элементов, находящихся в нём, либо устанавливает эту длину.
1 L = NameArray.length;
В этом примере переменная L получит значение, равное количеству элементов в массиве.
Если необходимо установить точную длину массива, то можно воспользоваться этим свойством, применив следующее выражение:
1 NameArray.length = 100;
Это выражение устанавливает длину массива в 100 элементов; если до этого их было больше, то массив будет обрезан.
Обратите внимание: большинство методов учитывает значение length! Например, методы push и unshift помимо добавления элементов в массив возвращают новое значение length:
1 L = NameArray.push(40);
В этом примере переменная L получила значение, равное количеству элементов в массиве.
Объединение массивов
Иногда может возникнуть необходимость объединить массивы; это позволяет сделать функция apply():
1 var a = [10, 20, 30];
2 var b = [40, 50];
3 NameArray.push.apply(a, b);
В приведённом примере два массива a и b сливаются в один общий с названием NameArray; при этом в массиве сначала следуют элементы массива a, затем массива b.
Заполнение элементов массива одним значением
При необходимости вы можете автоматически заполнить определённые ячейки массива одним значением; для этого используется метод fill():
1 NameArray.fill(a, b, c);
В скобках должны быть указаны соответствующие значения:
- a - значение, которым должен быть заполнен массив;
- b - индекс, с которого необходимо начинать заполнение. Если индекс не указан, заполнение будет начинаться с начала списка;
- c - индекс, на котором заполнение должно быть закончено. Если индекс не указан, заполнение будет продолжаться до конца массива.
Примеры:
1 NameArray.fill(100);
В данном случае весь массив будет заполнен числом 100.
1 NameArray.fill(100, 3);
Массив будет заполнен числом 100 начиная с индекса 3 и до конца.
1 NameArray.fill(100, 3, 10);
Массив будет заполнен числом 100 начиная с индекса 3 и до индекса 10 (т.е. с 3 по 9).
Обращение порядка следования элементов
Иногда возникает необходимость перевернуть список, т.е. сделать так, что бы элементы шли в обратном порядке. Это можно сделать при помощи метода reverse():
1 NameArray.reverse();
Теперь массив [10, 20, 30, 40] будет выглядеть как [40, 30, 20, 10].
Сортировка элементов массива
Элементы массива можно отсортировать в определённом порядке; по умолчанию этот порядок определяется кодом Unicode. Для сортировки используется метод sort():
1 NameArray.sort();
При необходимости вы можете использовать для сортировки определённую функцию, прописываемую в скобках; тогда элементы будут отсортированы в соответствии с возвращаемым ей значением. Например, что бы расставить по порядку все элементы массива NameArray с числами [20, 50, 30, 10, 40], нужно прописать такой код:
1 NameArray.sort(function(a, b) {
2 return a-b;
3 });
Результатом выполнения кода будет массив [10, 20, 30, 40, 50].
Проверка: является ли объект массивом?
Что бы проверить, является ли объект массивом, применяется метод Array.isArray():
1 Array.isArray(объект);
Если объект является массивом - будет возвращено значение true.
Соединение массивов/значений
Метод concat() позволяет создать новый массив из нескольких других массивов или из одного массива и других значений.
1 var arrayA = [10, 20,30];
2 var arrayB = [40, 50, 60];
3 var arrayC = arrayA.concat(arrayB);
Результатом выполнения кода в строке 3 будет новый архив [10, 20,30, 40, 50, 60].
Если соединяемых архивов несколько, то их нужно указать в скобках метода через запятую. Так же можно соединять архив со значениями:
1 var arrayA = [10, 20,30];
2 var arrayB = arrayA.concat(arrayA, 40, 50, 60);
В результате вы так же получите новый архив [10, 20,30, 40, 50, 60].
Обратите внимание: в любом случае соединяемые архивы не изменяются!
Проверка массива на содержание определённого элемента
Для проверки содержания определённого элемента (значения) в массиве используется метод includes().
1 var NameArray = [10, 20,30];
2 var b = NameArray.includes(30);
В результате выполнения данного кода переменная b получит значение true; соответственно, если значения, указанного в скобках, в массиве не окажется, эта переменная получит значение false.
Так же вы можете указать, с какой позиции (индекса) начинать проверку. Для этого укажите это значение перед закрывающей скобкой:
2 var b = NameArray.includes(30, 1);
В этом случае число 1 указывает, что начинать проверку следует с индекса 1.
Представление элементов массива в виде одной строки
При необходимости вы можете получить список всех элементов массива в виде единой строки; при этом вы можете указать, как эти элементы должны быть разделены или наоборот, записаны вместе. Для выполнения данной задачи используется метод join(разделитель), где в качестве разделителя могут быть использованы какие либо символы в виде текста (запятая, тире, плюс, а так же пробел или запятая и пробел); так как это текст, соответственно, он должен находиться в кавычках. Если вы хотите, что бы между элементами не было ничего, то необходимо указать двое кавычек подряд, без пробела; если же в качестве разделителя не указано ничего, то список будет выведен в виде значений, разделённых запятой, но без пробелов.
1 var b = NameArray.join(", ");
В данном примере элементы массива NameArray будут представлены в виде строки, после чего строка будет присвоена переменной b; при этом элементы будут разделены запятой и пробелом: 20, 30, 40, 50, 60 и т.д.
Так же для этой цели можно использовать метод toString(), однако возможностей у данного метода намного меньше: он выведет строку со значениями, разделёнными запятой без пробелов (аналогично предыдущему методу без указанного разделителя).
Создание копии всего массива или его части
Для создании копии какой-либо части массива используется метод slice(a, b). Значение a, указанное в скобках, определяет индекс, с которого начинается создание копии, значение b указывает индекс, на котором копирование заканчивается, при этом элемент, указанный под этим индексом, в новый массив не входит. Если значение b не указывается, массив будет скопирован от индекса a и до конца.
1 var NameArray = [10, 20, 30, 40, 50, 60];
2 var b = NameArray.slice(1, 4);
В указанном примере переменная b получит массив [20, 30, 40]; значение с индексом 4 [50] в новый массив не войдёт.
Методы обхода
Эти методы, как видно из названия, обрабатывают по очереди все элементы массива при помощи функции, принимаемой в качестве аргумента. Эти методы будут рассмотрены позже в главе "JavaScript. Функции".
Создание массива из строки
При помощи JavaScript вы можете легко разобрать слово или текст по буквам; при этом создаётся массив, в котором все буквы будут следовать друг за другом. Это очень удобно! Например, вы можете в каком-либо слове заменить букву, применив соответствующие методы. Для выполнения данной операции используется метод from().
1 var NameArray = Array.from("текст")
В результате будет образован новый массив NameArray ["т", "е", "к", "с", "т"].
Другие варианты использования метода будут рассмотрены в следующих главах, так как в этих вариантах будут задействованы функции.
Обзор изменений в массивах
При помощи метода Array.observe() вы можете получать информацию обо всех изменениях, произошедших в массиве; эта информация предоставляется в виде новых массивов с полученными данными. Так как в этом методе используется функция, данный метод будет рассмотрен позже.
Массив из результатов сопоставления регулярного выражения
Так как данный массив создаётся на основе результатов сопоставления регулярного выражения, более подробно эта тема будет разобрана в главе "JavaScript. Регулярные выражения".
