JavaScript - Массивы. Переупорядочивание элементов массива в обратном порядке - reverse
21.06.2017 at 12:17
Для вычисления на javascript размера массива объектов используется свойство массива length.
Var arr = ["first", "second"]; console.log(arr.length); // 2
Массивы в javascript могут иметь пропуски в индексах. Например
Var arr = ; arr = "first"; arr = "second";
Свойство length возвращает максимальный индекс массива + 1. Т.е. в приведенном примере length = 5.
Вычисление на javascript количества элементов в массиве
Array.prototype.count = function(){ var result = 0; for(var i = 0; i < this.length; i++) if (this[i] != undefined) result++; return result; }
Пример использования
Var arr = ; arr = "first"; arr = "second"; console.log(arr.count()); //2
Так же в свойство length можно присваивать значение. Это позволяет уменьшить длину существующего массива.
Var arr = ["first", "second", "third"]; arr.length = 2; console.log(arr); // ["first", "second"]
Вычисление на javascript размера массива в байтах
Массивы являются обычными объектами, так что вычисление размера массива в байтах ничем не отличается от вычисления размера любого другого объекта. К сожалению, javascript не предоставляет API для вычисления размера, так что придется считать самостоятельно. Делается это следующим образом: обходим все свойства объекта, если свойство примитивного типа — добавляем к общему результату размер экземпляра этого типа, если в свойстве лежит объект — рекурсивно считаем его размер.
Function sizeOf(obj) { var bytes = 0; if(obj !== null && obj !== undefined) { switch(typeof obj) { case "number": bytes += 8; break; case "string": bytes += obj.length * 2; break; case "boolean": bytes += 4; break; case "object": for(var key in obj) { bytes += sizeOf(obj); } break; } } return bytes; };
Метод не точный и имеющий множество проблем — например есть вероятность уйти в бесконечный цикл.
Последнее обновление: 26.03.2018
Объект Array представляет массив и предоставляет ряд свойств и методов, с помощью которых мы можем управлять массивом.
Инициализация массива
Можно создать пустой массив, используя квадратные скобки или конструктор Array:
Var users = new Array(); var people = ; console.log(users); // Array console.log(people); // Array
Можно сразу же инициализировать массив некоторым количеством элементов:
Var users = new Array("Tom", "Bill", "Alice"); var people = ["Sam", "John", "Kate"]; console.log(users); // ["Tom", "Bill", "Alice"] console.log(people); // ["Sam", "John", "Kate"]
Можно определить массив и по ходу определять в него новые элементы:
Var users = new Array(); users = "Tom"; users = "Kate"; console.log(users); // "Tom" console.log(users); // undefined
При этом не важно, что по умолчанию массив создается с нулевой длиной. С помощью индексов мы можем подставить на конкретный индекс в массиве тот или иной элемент.
length
Чтобы узнать длину массива, используется свойство length :
Var fruit = new Array();
fruit = "яблоки";
fruit = "груши";
fruit = "сливы";
document.write("В массиве fruit " + fruit.length + " элемента:
");
for(var i=0; i < fruit.length; i++)
document.write(fruit[i] + "
");
По факту длиной массива будет индекс последнего элемента с добавлением единицы. Например:
Var users = new Array(); // в массиве 0 элементов
users = "Tom";
users = "Kate";
users = "Sam";
for(var i=0; i Вывод браузера: Tom
Kate
undefined
undefined
Sam
Несмотря на то, что для индексов 2 и 3 мы не добавляли элементов, но длиной массива в данном случае будет число 5. Просто элементы с индексами 2 и 3
будут иметь значение undefined . Копирование массива может быть поверхностным или неглубоким (shallow copy) и глубоким (deep copy). При неглубоком копировании достаточно присвоить переменной значение другой переменной, которая хранит массив: Var users = ["Tom", "Sam", "Bill"];
console.log(users); // ["Tom", "Sam", "Bill"]
var people = users; // неглубокое копирование
people = "Mike"; // изменяем второй элемент
console.log(users); // ["Tom", "Mike", "Bill"]
В данном случае переменная people после копирования будет указывать на тот же массив, что и переменная users. Поэтому при изменении элементов в people,
изменятся элементы и в users, так как фактически это один и тот же массив. Такое поведение не всегда является желательным. Например, мы хотим, чтобы после копирования переменные указывали на отдельные массивы. И в этом случае
можно использовать глубокое копирование с помощью метода slice()
: Var users = ["Tom", "Sam", "Bill"];
console.log(users); // ["Tom", "Sam", "Bill"]
var people = users.slice(); // глубокое копирование
people = "Mike"; // изменяем второй элемент
console.log(users); // ["Tom", "Sam", "Bill"]
console.log(people); // ["Tom", "Mike", "Bill"]
В данном случае после копирования переменные будут указывать на разные массивы, и мы сможем изменять их отдельно друг от друга. Также метод slice() позволяет скопировать часть массива: Var users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
var people = users.slice(1, 4);
console.log(people); // ["Sam", "Bill", "Alice"]
В метод slice() передается начальный и конечный индексы, которые используются для выборки значений из массива.
То есть в данном случае выборка в новый массив идет начиная с 1 индекса по индекс 4 не включая. И поскольку индексация массивов
начинается с нуля, то в новом массиве окажутся второй, третий и четвертый элемент. Метод push() добавляет элемент в конец массива: Var fruit = ;
fruit.push("яблоки");
fruit.push("груши");
fruit.push("сливы");
fruit.push("вишня","абрикос Метод pop() удаляет последний элемент из массива: Var fruit = ["яблоки", "груши", "сливы"];
var lastFruit = fruit.pop(); // извлекаем из массива последний элемент
document.write(lastFruit + " Вывод браузера: Сливы
В массиве fruit 2 элемента:
яблоки
груши
Метод shift() извлекает и удаляет первый элемент из массива: Var fruit = ["яблоки", "груши", "сливы"];
var firstFruit = fruit.shift();
document.write(firstFruit + " Вывод браузера: Яблоки
В массиве fruit 2 элемента:
груши
сливы
Метод unshift() добавляет новый элемент в начало массива: Var fruit = ["яблоки", "груши", "сливы"];
fruit.unshift("абрикосы");
document.write(fruit);
Вывод браузера: Абрикосы,яблоки,груши,сливы
Метод splice() удаляет элементы с определенного индекса. Например, удаление элементов с третьего индекса: Var users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
var deleted = users.splice(3);
console.log(deleted); // [ "Alice", "Kate" ]
console.log(users); // [ "Tom", "Sam", "Bill" ]
Метод slice возвращает удаленные элементы. В данном случае удаление идет с начала массива. Если передать отрицательный индекс, то удаление будет производиться с конца массива.
Например, удалим последний элемент: Var users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
var deleted = users.splice(-1);
console.log(deleted); // [ "Kate" ]
console.log(users); // [ "Tom", "Sam", "Bill", "Alice" ]
Дополнительная версия метода позволяет задать конечный индекс для удаления.
Например, удалим с первого по третий индекс: Var users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
var deleted = users.splice(1,3);
console.log(deleted); // [ "Sam", "Bill", "Alice" ]
console.log(users); // [ "Tom", "Kate" ]
Еще одна версия метода splice позволяет вставить вместо удаляемых элементов новые элементы: Var users = ["Tom", "Sam", "Bill", "Alice", "Kate"];
var deleted = users.splice(1,3, "Ann", "Bob");
console.log(deleted); // [ "Sam", "Bill", "Alice" ]
console.log(users); // [ "Tom", "Ann", "Bob", "Kate" ]
В данном случае удаляем три элемента с 1-й по 3-й индексы и вместо них вставляем два элемента. Метод concat() служит для объединения массивов: Var fruit = ["яблоки", "груши", "сливы"];
var vegetables = ["помидоры", "огурцы", "картофель"];
var products = fruit.concat(vegetables);
for(var i=0; i < products.length; i++)
document.write(products[i] + " При этом необязательно объединять только однотипные массивы. Можно и разнотипные: Var fruit = ["яблоки", "груши", "сливы"];
var prices = ;
var products = fruit.concat(prices);
Метод join() объединяет все элементы массива в одну строку: Var fruit = ["яблоки", "груши", "сливы", "абрикосы", "персики"];
var fruitString = fruit.join(", ");
document.write(fruitString);
В метод join() передается разделитель между элементами массива. В данном случае в качестве разделителя будет использоваться
запятая и пробел (", "). Метод sort() сортирует массив по возрастанию: Var fruit = ["яблоки", "груши", "сливы", "абрикосы", "персики"];
fruit.sort();
for(var i=0; i < fruit.length; i++)
document.write(fruit[i] + " Вывод в браузере: Абрикосы
груши
персики
сливы
яблоки
Метод reverse() переворачивает массив задом наперед: Var fruit = ["яблоки", "груши", "сливы", "абрикосы", "персики"];
fruit.reverse();
for(var i=0; i < fruit.length; i++)
document.write(fruit[i] + " Вывод в браузере: Персики
абрикосы
сливы
груши
яблоки
В сочетании с методом sort() можно отсортировать массив по убыванию: Var fruit = ["яблоки", "груши", "сливы", "абрикосы", "персики"];
fruit.sort().reverse();
for(var i=0; i < fruit.length; i++)
document.write(fruit[i] + " Вывод в браузере: Яблоки
сливы
персики
груши
абрикосы
Методы indexOf()
и lastIndexOf()
возвращают индекс первого и последнего включения
элемента в массиве. Например: 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()
проверяет, все ли элементы соответствуют определенному условию: Var numbers = [ 1, -12, 8, -4, 25, 42 ];
function condition(value, index, array) {
var result = false;
if (value > 0) {
result = true;
}
return result;
};
var passed = numbers.every(condition);
document.write(passed); // false
В метод every() в качестве параметра передается функция, представляющая условие. Эта функция принимает три параметра: Function condition(value, index, array) {
}
Параметр value
представляет текущий перебираемый элемент массива, параметр index
представляет индекс этого элемента, а параметр array
передает ссылку на массив. В этой функции мы можем проверить переданное значение элемента на соответствие какому-нибудь условию. Например, в данном примере
мы проверяем каждый элемент массива, больше ли он нуля. Если больше, то возвращаем значение true , то есть элемент соответствует условию.
Если меньше, то возвращаем false - элемент не соответствует условию. В итоге, когда происходит вызов метода numbers.every(condition) он перебирает все элементы массива numbers и по очереди передает их
в функцию condition . Если эта функция возвращает значение true для всех элементов, то и метод every()
возвращает true . Если хотя бы один элемент не соответствует условию, то метод every() возвращает значение false . Метод some() похож на метод every() , только он проверяет, соответствует ли хотя бы один элемент условию. И в этом случае метод
some() возвращает true . Если элементов, соответствующих условию, в массиве нет, то возвращается значение
false: Var numbers = [ 1, -12, 8, -4, 25, 42 ];
function condition(value, index, array) {
var result = false;
if (value === 8) {
result = true;
}
return result;
};
var passed = numbers.some(condition); // true
Метод filter() , как some() и every() , принимает функцию условия.
Но при этом возвращает массив тех элементов, которые соответствуют этому условию: Var numbers = [ 1, -12, 8, -4, 25, 42 ];
function condition(value, index, array) {
var result = false;
if (value > 0) {
result = true;
}
return result;
};
var filteredNumbers = numbers.filter(condition);
for(var i=0; i < filteredNumbers.length; i++)
document.write(filteredNumbers[i] + " Вывод в браузере: 1
8
25
42
Методы forEach()
и map()
осуществляют перебор элементов и выполняют с ними определенный операции.
Например, для вычисления квадратов чисел в массиве можно использовать следующий код: Var numbers = [ 1, 2, 3, 4, 5, 6];
for(var i = 0; i Но с помощью метода forEach() можно упростить эту конструкцию: Var numbers = [ 1, 2, 3, 4, 5, 6];
function square(value, index, array) {
var result = value * value;
document.write("Квадрат числа " + value + " равен " + result + " Метод 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 И как вы поняли из той статьи, в переменную можно сохранить только одно значение. Сколько бы мы пытались больше одного значения в переменной мы не запишем
. Допустим, мы объявим некую переменную z, и присвоим ей значение 8.
И если мы где-то ниже в коде, этой же переменной зададим другое значение, допустим 3, то старое значение пропадёт и вместо неё запишется новое. И вот для того чтобы в переменной смогли записать больше одного значения, и нужно использовать такой тип данных как массив. Массив
позволяет записать в переменную сразу неограниченное количество значений, любых типов. Раньше в JavaScript массив объявлялся таким образом: Var arr = new Array (7, 8, "k", "v", 3.2, 4);
Времена изменились, и сейчас массив объявляется другим образом
, более сокращённо. Элементы перечисляются также через запятую, но уже внутри простых квадратных скобок. Var arr = [ 7, 8, "k", "v", 3.2, 4 ];
Теперь в переменную arr находится одномерный массив данных
, разных типов. Каждый элемент из массива имеет свой индекс. Учтите, что данный индекс начинается с нуля
. С его помощью указывается позиция элемента в массиве. Структура массива
выглядит так: Для того чтобы обратится к какому-то элементу из массива нужно написать имя массива, и в квадратных скобках указать индекс элемента которого хотим получить. Для примера выведем на экран элемент, у которого индекс равен 2, то есть букву "k". Document.write(" Выводим элемент массива arr, у которого индекс равен 2:" + arr + "Копирование массива. slice()
push()
");
document.write(fruit); // яблоки,груши,сливы,вишня,абрикос
pop()
");
document.write("В массиве fruit " + fruit.length + " элемента:
");
for(var i=0; i shift()
");
document.write("В массиве fruit " + fruit.length + " элемента:
");
for(var i=0; i unshift()
Удаление элемента по индексу. splice()
concat()
");
join()
sort()
");
reverse()
");
");
Поиск индекса элемента
every()
some()
filter()
");
forEach() и map()
");
};
numbers.forEach(square);
А что если мы хотим посмотреть все элементы массива . Если там мало элементов, то можно обратиться к каждому по отдельности, как в примере, то есть arr, arr, arr.
Но, если в массиве находится 100 элементов, то такой вариант не катит. Здесь уже необходимо использовать .
Перед тем как перейти к перебору массива, хочу познакомить Вас со свойством length . Это универсальное свойство, которая позволяет узнать длину массива , то есть общее количество элементов в массиве. Также с её помощью можно узнать и длину строки.
Для интереса узнаем, какая длина имеет массив arr.
Document.write("
Количество элементов в массиве arr =" + arr.length + "
); // Результат: 6Теперь для того что бы вывести сразу все элементы, необходимо перебрать весь массив, с помощью цикла .
For(var i = 0; i < arr.length; i++){ document.write("
Элемент массива arr, с индексом " + i + " равен:" + arr[i] + "
"); }Открываем эту страницу в браузере и видим такую картину:
Для тренировки, попробуйте перебрать массив "arr" и с помощью остальных циклов, while и do-while.
Существует ещё один простой и короткий вариант перебора маленького массива . Он заключается в том, что каждый элемент массива можно посмотреть с помощью метода alert. Сначала пишем название самого массива, или же можно указать сразу список элементов в квадратных скобках. Потом пишем функцию forEach и в качестве параметра пишем метод alert, без скобок.
Arr.forEach(alert);
Теперь если откроем страницу в браузере, то увидим поочерёдно каждого элемента массива.
Заполнение массива с помощью цикла
Для примера, в некий массив, запишем результаты таблицы умножения, от 1 до 10.
Сначала необходимо объявить пустой массив, которого и будем заполнять. Потом необходимо объявить переменную и присвоить ей сразу значение 0. Эта переменная будет в качестве индекса для объявляемого массива. И следующим шагом будет само заполнение массива с помощью такого приёма как цикл в цикл.
//Объявляем пустой массив var new_arr = ; // Переменная в качестве индекса для массива new_arr var k = 0; for(var i = 1; i
Если мы откроем эту страницу в браузере, то увидим такой результат:
Сначала переменная i равна единичке. И вот эта единичка умножается со всеми значениями переменной j. После того как прошлись 10 раз по второму циклу возвращаемся к первому циклу и инкрементируем переменную i на единицу. Теперь i равно двойке. Опять идём ко второму циклу и умножаем значение 2 на все значения переменной j(от 1 до 10). В результате получается второй ряд: 2 4 6 8 … 20. И так происходит пока, переменная i не станет равно 11. Как только она примет такое значение, то мы выходим из цикла.
Посчитаем сумму всех элементов из массива
У нас есть массив new_arr в котором хранится 100 чисел (целая таблица умножения). Теперь давайте посчитаем сумму всех этих элементов.
//Создаем переменную для суммы var summ = 0; for(var i = 0; i < new_arr.length; i++){ summ += new_arr[i]; } document.write("
Сумма элементов массива new_arr равна: " + summ + "
"); //Результат 3025Вот и все о чем я хотел Вам рассказать в этой статье. Теперь Вы знаете, как создавать массив, как его заполнять и как с ним работать.
На практике массивы встречаются довольно часто, так как они очень важны в программировании, поэтому Вы должны их знать на отлично .
Массивы
Массив - это упорядоченная коллекция значений. Значения в массиве называются элементами, и каждый элемент характеризуется числовой позицией в массиве, которая называется индексом. Массивы в языке JavaScript являются нетипизированными: элементы массива могут иметь любой тип, причем разные элементы одного и того же массива могут иметь разные типы. Элементы массива могут даже быть объектами или другими массивами, что позволяет создавать сложные структуры данных, такие как массивы объектов и массивы массивов.
Отсчет индексов массивов в языке JavaScript начинается с нуля и для них используются 32-битные целые числа - первый элемент массива имеет индекс 0. Массивы в JavaScript являются динамическими: они могут увеличиваться и уменьшаться в размерах по мере необходимости; нет необходимости объявлять фиксированные размеры массивов при их создании или повторно распределять память при изменении их размеров.
Массивы в языке JavaScript - это специализированная форма объектов, а индексы массивов означают чуть больше, чем просто имена свойств, которые по совпадению являются целыми числами.
Создание массивов
Легче всего создать массив с помощью литерала, который представляет собой простой список разделенных запятыми элементов массива в квадратных скобках. Значения в литерале массива не обязательно должны быть константами - это могут быть любые выражения, в том числе и литералы объектов:
Var empty = ; // Пустой массив var numbers = ; // Массив с пятью числовыми элементами var misc = [ 1.1, true, "a", ]; // 3 элемента разных типов + завершающая запятая var base = 1024; var table = ; // Массив с переменными var arrObj = [, ]; // 2 массива внутри, содержащие объекты
Синтаксис литералов массивов позволяет вставлять необязательную завершающую запятую, т.е. литерал [,] соответствует массиву с двумя элементами, а не с тремя.
Другой способ создания массива состоит в вызове конструктора Array() . Вызвать конструктор можно тремя разными способами:
Вызвать конструктор без аргументов:
Var arr = new Array();
В этом случае будет создан пустой массив, эквивалентный литералу .
Вызвать конструктор с единственным числовым аргументом, определяющим длину массива:
Var arr = new Array(10);
В этом случае будет создан пустой массив указанной длины. Такая форма вызова конструктора Array() может использоваться для предварительного распределения памяти под массив, если заранее известно количество его элементов. Обратите внимание, что при этом в массиве не сохраняется никаких значений.
Явно указать в вызове конструктора значения первых двух или более элементов массива или один нечисловой элемент:
Var arr = new Array(5, 4, 3, 2, 1, "тест");
В этом случае аргументы конструктора становятся значениями элементов нового массива. Использование литералов массивов практически всегда проще, чем подобное применение конструктора Array().
Чтение и запись элементов массива
Доступ к элементам массива осуществляется с помощью оператора . Слева от скобок должна присутствовать ссылка на массив. Внутри скобок должно находиться произвольное выражение, возвращающее неотрицательное целое значение. Этот синтаксис пригоден как для чтения, так и для записи значения элемента массива. Следовательно, допустимы все приведенные далее JavaScript-инструкции:
// Создать массив с одним элементом var arr = ["world"]; // Прочитать элемент 0 var value = arr; // Записать значение в элемент 1 arr = 3.14; // Записать значение в элемент 2 i = 2; arr[i] = 3; // Записать значение в элемент 3 arr = "привет"; // Прочитать элементы 0 и 2, записать значение в элемент 3 arr] = arr;
Напомню, что массивы являются специализированной разновидностью объектов. Квадратные скобки, используемые для доступа к элементам массива, действуют точно так же, как квадратные скобки, используемые для доступа к свойствам объекта. Интерпретатор JavaScript преобразует указанные в скобках числовые индексы в строки - индекс 1 превращается в строку "1" - а затем использует строки как имена свойств.
В преобразовании числовых индексов в строки нет ничего особенного: то же самое можно проделывать с обычными объектами:
Var obj = {}; // Создать простой объект obj = "one"; // Индексировать его целыми числами
Особенность массивов состоит в том, что при использовании имен свойств, которые являются неотрицательными целыми числами, массивы автоматически определяют значение свойства length . Например, выше был создан массив arr с единственным элементом. Затем были присвоены значения его элементам с индексами 1, 2 и 3. В результате этих операций значение свойства length массива изменилось и стало равным 4.
Следует четко отличать индексы в массиве от имен свойств объектов. Все индексы являются именами свойств, но только свойства с именами, представленными целыми числами являются индексами. Все массивы являются объектами, и вы можете добавлять к ним свойства с любыми именами. Однако если вы затрагиваете свойства, которые являются индексами массива, массивы реагируют на это, обновляя значение свойства length при необходимости.
Обратите внимание, что в качестве индексов массивов допускается использовать отрицательные и не целые числа. В этом случае числа преобразуются в строки, которые используются как имена свойств.
Добавление и удаление элементов массива
Мы уже видели, что самый простой способ добавить элементы в массив заключается в том, чтобы присвоить значения новым индексам. Для добавления одного или более элементов в конец массива можно также использовать метод push() :
Var arr = ; // Создать пустой массив arr.push("zero"); // Добавить значение в конец arr.push("one",2); // Добавить еще два значения
Добавить элемент в конец массива можно также, присвоив значение элементу arr. Для вставки элемента в начало массива можно использовать метод unshift() , при этом существующие элементы в массиве смещаются в позиции с более высокими индексами.
Удалять элементы массива можно с помощью оператора delete, как обычные свойства объектов:
Var arr = ; delete arr; 2 in arr; // false, индекс 2 в массиве не определен arr.length; // 3: оператор delete не изменяет свойство length массива
Удаление элемента напоминает (но несколько отличается) присваивание значения undefined этому элементу. Обратите внимание, что применение оператора delete к элементу массива не изменяет значение свойства length и не сдвигает вниз элементы с более высокими индексами, чтобы заполнить пустоту, оставшуюся после удаления элемента.
Кроме того имеется возможность удалять элементы в конце массива простым присваиванием нового значения свойству length. Массивы имеют метод pop() (противоположный методу push()), который уменьшает длину массива на 1 и возвращает значение удаленного элемента. Также имеется метод shift() (противоположный методу unshift()), который удаляет элемент в начале массива. В отличие от оператора delete, метод shift() сдвигает все элементы вниз на позицию ниже их текущих индексов.
Наконец существует многоцелевой метод splice() , позволяющий вставлять, удалять и замещать элементы массивов. Он изменяет значение свойства length и сдвигает элементы массива с более низкими или высокими индексами по мере необходимости. Все эти методы мы разберем чуть позже.
Многомерные массивы
JavaScript не поддерживает «настоящие» многомерные массивы, но позволяет неплохо имитировать их при помощи массивов из массивов. Для доступа к элементу данных в массиве массивов достаточно дважды использовать оператор .
Например, предположим, что переменная matrix - это массив массивов чисел. Каждый элемент matrix[x] - это массив чисел. Для доступа к определенному числу в массиве можно использовать выражение matrix[x][y]. Ниже приводится конкретный пример, где двумерный массив используется в качестве таблицы умножения:
// Создать многомерный массив var table = new Array(10); // В таблице 10 строк for(var i = 0; i
Методы класса Array
Стандарт ECMAScript 3 определяет в составе Array.prototype множество удобных функций для работы с массивами, которые доступны как методы любого массива. Эти методы будут представлены в следующих подразделах.
Метод join()
Метод Array.join() преобразует все элементы массива в строки, объединяет их и возвращает получившуюся строку. В необязательном аргументе методу можно передать строку, которая будет использоваться для отделения элементов в строке результата. Если строка-разделитель не указана, используется запятая. Например, следующий фрагмент дает в результате строку "1,2,3":
Var arr = ; arr.join(); // "1,2,3" arr.join("-"); // "1-2-3"
Метод reverse()
Метод Array.reverse() меняет порядок следования элементов в массиве на обратный и возвращает переупорядоченный массив. Перестановка выполняется непосредственно в исходном массиве, т.е. этот метод не создает новый массив с переупорядоченными элементами, а переупорядочивает их в уже существующем массиве. Например, следующий фрагмент, где используются методы reverse() и join(), дает в результате строку "3,2,1":
Var arr = ; arr.reverse().join(); // "3,2,1"
Метод sort()
Метод Array.sort() сортирует элементы в исходном массиве и возвращает отсортированный массив. Если метод sort() вызывается без аргументов, сортировка выполняется в алфавитном порядке (для сравнения элементы временно преобразуются в строки, если это необходимо). Неопределенные элементы переносятся в конец массива.
Для сортировки в каком-либо ином порядке, отличном от алфавитного, методу sort() можно передать функцию сравнения в качестве аргумента. Эта функция устанавливает, какой из двух ее аргументов должен следовать раньше в отсортированном списке. Если первый аргумент должен предшествовать второму, функция сравнения должна возвращать отрицательное число. Если первый аргумент должен следовать за вторым в отсортированном массиве, то функция должна возвращать число больше нуля. А если два значения эквивалентны (т.е. порядок их следования не важен), функция сравнения должна возвращать 0:
Var arr = ; arr.sort(); // Алфавитный порядок: 1111, 222, 33, 4 arr.sort(function(a,b) { // Числовой порядок: 4, 33, 222, 1111 return a-b; // Возвращает значение 0 // в зависимости от порядка сортировки a и b }); // Сортируем в обратном направлении, от большего к меньшему arr.sort(function(a,b) {return b-a});
Обратите внимание, насколько удобно использовать в этом фрагменте неименованную функцию. Функция сравнения используется только здесь, поэтому нет необходимости давать ей имя.
Метод concat()
Метод Array.concat() создает и возвращает новый массив, содержащий элементы исходного массива, для которого был вызван метод concat(), и значения всех аргументов, переданных методу concat(). Если какой-либо из этих аргументов сам является массивом, его элементы добавляются в возвращаемый массив. Следует, однако, отметить, что рекурсивного превращения массива из массивов в одномерный массив не происходит. Метод concat() не изменяет исходный массив. Ниже приводится несколько примеров:
Var arr = ; arr.concat(4, 5); // Вернет arr.concat(); // Вернет arr.concat(,) // Вернет arr.concat(4, ]) // Вернет ]
Метод slice()
Метод Array.slice() возвращает фрагмент, или подмассив, указанного массива. Два аргумента метода определяют начало и конец возвращаемого фрагмента. Возвращаемый массив содержит элемент, номер которого указан в первом аргументе, плюс все последующие элементы, вплоть до (но не включая) элемента, номер которого указан во втором аргументе.
Если указан только один аргумент, возвращаемый массив содержит все элементы от начальной позиции до конца массива. Если какой-либо из аргументов имеет отрицательное значение, он определяет номер элемента относительно конца массива. Так, аргументу -1 соответствует последний элемент массива, а аргументу -3 - третий элемент массива с конца. Вот несколько примеров:
Var arr = ; arr.slice(0,3); // Вернет arr.slice(3); // Вернет arr.slice(1,-1); // Вернет arr.slice(-3,-2); // Вернет
Метод splice()
Метод Array.splice() - это универсальный метод, выполняющий вставку или удаление элементов массива. В отличие от методов slice() и concat(), метод splice() изменяет исходный массив, относительно которого он был вызван. Обратите внимание, что методы splice() и slice() имеют очень похожие имена, но выполняют совершенно разные операции.
Метод splice() может удалять элементы из массива, вставлять новые элементы или выполнять обе операции одновременно. Элементы массива при необходимости смещаются, чтобы после вставки или удаления образовывалась непрерывная последовательность.
Первый аргумент метода splice() определяет позицию в массиве, начиная с которой будет выполняться вставка и/или удаление. Второй аргумент определяет количество элементов, которые должны быть удалены (вырезаны) из массива. Если второй аргумент опущен, удаляются все элементы массива от указанного до конца массива. Метод splice() возвращает массив удаленных элементов или (если ни один из элементов не был удален) пустой массив.
Первые два аргумента метода splice() определяют элементы массива, подлежащие удалению. За этими аргументами может следовать любое количество дополнительных аргументов, определяющих элементы, которые будут вставлены в массив, начиная с позиции, указанной в первом аргументе.
Var arr = ; arr.splice(4); // Вернет , arr = arr.splice(1,2); // Вернет , arr = arr.splice(1,1); // Вернет ; arr = arr = ; arr.splice(2,0,"a","b"); // Вернет ; arr =
Методы push() и pop()
Методы push() и pop() позволяют работать с массивами как со стеками. Метод push() добавляет один или несколько новых элементов в конец массива и возвращает его новую длину. Метод pop() выполняет обратную операцию - удаляет последний элемент массива, уменьшает длину массива и возвращает удаленное им значение. Обратите внимание, что оба эти метода изменяют исходный массив, а не создают его модифицированную копию.
Методы unshift() и shift()
Методы unshift() и shift() ведут себя почти так же, как push() и pop(), за исключением того, что они вставляют и удаляют элементы в начале массива, а не в конце. Метод unshift() смещает существующие элементы в сторону больших индексов для освобождения места, добавляет элемент или элементы в начало массива и возвращает новую длину массива. Метод shift() удаляет и возвращает первый элемент массива, смещая все последующие элементы на одну позицию вниз, чтобы занять место, освободившееся в начале массива.
На этом уроке мы познакомимся с массивами, научимся их создавать, выполнять операции над их элементами, а также рассмотрим основные методы и свойства, доступные при работе с ними.
Что такое массив в JavaScript?
Массив – это упорядоченная коллекция значений . Значения в этой коллекции называются элементами . Каждый элемент в массиве имеет свой порядковый номер (число), который называется индексом . Индексы нумеруются с 0.
На следующем рисунке приведён числовой массив, состоящий из 5 элементов. Элементы данного массива содержат следующие данные: 123 (индекс 0), 7 (индекс 1), 50 (индекс 2), -9 (индекс 3), 24 (индекс 4).
Создание (объявление) массива
Создание массивов в JavaScript обычно осуществляется с помощью литерала массива .
Литерал массива представляет собой квадратные скобки, внутрь которых помещается список элементов, разделённых между собой с помощью запятой.
Например:
Var empty = ; // пустой массив var numbers = ; // числовой массив var arr = ; // массив, содержащий различные типы данных
Значения в массиве JavaScript не обязательно должны иметь одинаковый тип. Т.е. в одном массиве могут находиться значения различных типов данных.
Обращение к определённому элементу массива выполняется по его индексу. Данная операция ещё называется операцией индексации.
Например:
// создадим массив, состоящий из 3 элементов var smartphoneColors = ["Black", "White", "Grey"]; // выведем в консоль браузера значения элементов массива smartphoneColors с индексами 0 и 2 console.log("Значение элемента массива smartphoneColors с индексом 0: " + smartphoneColors); // "Значение элемента массива smartphoneColors с индексом 0: Black" console.log("Значение элемента массива smartphoneColors с индексом 2: " + smartphoneColors); // "Значение элемента массива smartphoneColors с индексом 0: Grey" // изменим значение элемента массива smartphoneColors с индексом 1 на "Red" smartphoneColors = "Red"; // ["Black", "Red", "Grey"] // установим элементу массива smartphoneColors с индексом 3 значение "Blue" smartphoneColors = "Blue"; // ["Black", "Red", "Grey", "Blue"]
В качестве значений элементов массива можно использовать не только статические значения, но и выражения:
Var lengthA = 7, widthA = 5; var point = ;
В качестве значений элементов массива могут использоваться объекты.
Var points = [ {x1: 5, y1: 3}, {x1: 7, y1: 10}, {x1: 12; y1: 0} ]; // массив, состоящий из 3 объектов
Другой способ создания массива состоит в вызове функции-конструктора Array .
Вызов функции-конструктора без аргументов используется для создания пустого массива.
Var empty = new Array(); // пустой массив
Данный способ создания массива, эквивалентен литералу .
Если функции-конструктору в качестве аргумента указать число, то она создаст массив, который будет состоять из указанного числа элементов. Причем все эти элементы будут иметь в качестве значения undefined.
Var arr = new Array(5); // массив, состоящий из 5 элементов (значения элементов равны undefined)
Если функции-конструктору в скобках передать несколько значений или одно не числовое значение, то она создаст массив из переданных ей аргументов.
В отличие от многих других языков программирования массивы в JavaScript автоматически меняют свой размер, т.е. они изначально являются динамическими. Таким массивам не надо задавать какие-либо размеры. Ещё одной отличительной чертой массивов JavaScript является то, что в разных элементах одного и того же массива могут содержаться различные типы данных.
Свойство length (длина массива)
Определение длины массива (количества элементов) осуществляется с помощью свойства length .
//создадим массив путём перечисления значений элементов в функции Array var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //переменной lengthArray присвоим длину массива volumeHDDs var lengthArray = volumeHDDs.length;
Как получить первый элемент массива
Получение значения первого элемента массива осуществляется с помощью указания в квадратных скобках этого массива числа 0:
//создание массива, состоящего из 3 элементов var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //получение значения первого элемента массива var firstValue = volumeHDDs;
Как получить последний элемент массива
Получение значения последнего элемента массива осуществляется с помощью указания в квадратных скобках этого массива выражения имя_массива.length-1:
//создание массива, состоящего из 3 элементов var volumeHDDs = new Array("500Gb","1Tb","2Tb"); //получение значения последнего элемента массива var lastValue = volumeHDDs;
Перебор массива
Перебор элементов массива осуществляется с помощью цикла for .
Например, переберём все элементы массива и выведем их значения в консоль браузера (F12):
//создание массива nameStudents, состоящего из 4 элементов var nameStudents = new Array("Петя","Вася","Коля","Максим"); //перебор элементов массива от 0 до длины массива-1 for (var i=0; i <= nameStudents.length-1; i++) { console.log(i+1 + " элемент массива = " + nameStudents[i]); }
Для чего предназначен оператор delete
Оператор delete используется не для удаления элемента из массива, а для присваиванию данному элементу массива значение undefined .
Var namePlanets = new Array ("Венера","Меркурий","Земля","Марс"); delete namePlanets; for (var i=0; i <= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }
Функции для работы с массивами (методы объекта Array)
Объект Array содержит следующие методы (функции) для работы с массивами:
- shift
- unshift
- slice
- splice
- split
- reverse
Метод push (добавление элемента в конец массива)
Метод push предназначен для добавления элемента в конец массива. Значение этого элемента указывается в качестве параметра данного метода. В качестве результата метод push возвращает количество элементов в массиве с учётом добавленного.
Var namePlanets = ["Венера", "Меркурий", "Земля", "Марс"]; namePlanets.push("Юпитер"); // 5 console.log(namePlanets); // ["Венера", "Меркурий", "Земля", "Марс", "Юпитер"]
Метод pop (удаление последнего элемента из массива)
Метод pop предназначен для удаления последнего элемента из массива. У данного метода нет параметров. В качестве результата он возвращает значение последнего (удалённого) элемента массива.
Var namePlanets = ["Венера", "Меркурий", "Земля", "Марс"]; namePlanets.pop(); // "Марс" console.log(namePlanets); // ["Венера", "Меркурий", "Земля"]
Метод shift (удаление первого элемента из массива)
Метод shift предназначен для удаления первого элемента из массива, т.е. элемента, имеющего индекс 0. Все остальные элементы массива смещаются к началу, т.е. у каждого из них индекс уменьшается на 1. Данный метод в качестве результата возвращает значение удалённого элемента.
Var namePlanets = ["Венера", "Меркурий", "Земля", "Марс"]; namePlanets.shift(); // "Венера" console.log(namePlanets); // ["Меркурий", "Земля", "Марс"]
Метод unshift (добавление элемента в начало массива)
Метод unshift предназначен для добавления элемента в начало массива (перед другими элементами). Значение этого элемента указывается в качестве параметра данного метода. В качестве результата данный метод возвращает количество элементов в массиве с учётом добавленного.
Var namePlanets = ["Меркурий", "Земля", "Марс", "Юпитер"]; namePlanets.unshift("Венера"); // 5 console.log(namePlanets); // ["Венера", "Меркурий", "Земля", "Марс", "Юпитер"]
Метод slice (копирование участка массива)
Метод slice предназначен для копирования участка массива. При этом он не изменяет исходный массив, а возвращает в качестве результата новый массив, состоящий из выбранных элементов.
Метод slice имеет 2 параметра:
- 1 параметр (обязательный) - предназначен для указания индекса элемента, с которого необходимо начать копировать элементы;
- 2 параметр (необязательный) - предназначен для указания индекса элемента, до которого необходимо копировать (при этом он не включается в новый массив). Если его не указать, то будут скопированы элементы до конца указанного массива.
Метод splice (изменение содержимого массива)
Метод splice предназначен для изменения содержимого массива. Он может использваться как для добавления элементов в массив, так и для их удаления.
Синтаксис метода splice :
Array.splice(startIndex, deleteCount [, element1[, element2[, ...]]]); /* startIndex (обязательный) - стартовый индекс элемента, с которого нужно начать изменение массива. Если в качестве startIndex указать число, большее длины массива, то стартовый индекс будет установлен на конец массива. Если в качестве startIndex указать отрицательное число, то отсчет стартового элемента будет вестись с конца. deleteCount (обязательный) - число, показывающее какое количество элементов необходимо удалить из массива. Если элементы не нужно удалять из массива, то deleteCount необходимо установить 0. После этого нужно указать как минимум один новый элемент, который нужно добавить в массив. Если в качестве deleteCount указать число, которое будет превышать количество оставшихся элементов в массиве, начиная с startIndex, то в этом случае они всё равно будут удалены (т.е. все элементы до конца массива, начиная со стартового индекса) element1, element2, ... (необязательные) - элементы которые нужно добавить в массив. */
Примеры использования метода splice.
Применения метода splice для удаления части элементов из массива.
Var namePlanets = ["Венера", "Меркурий", "Земля", "Марс"]; namePlanets.splice(2, 2); //["Земля", "Марс"] console.log(namePlanets); // ["Венера", "Меркурий"]
Применение метода splice для удаления элемента из массива и добавления в него новых.
Var namePlanets = ["Венера", "Меркурий", "Земля", "Марс"]; namePlanets.splice(1, 1, "Уран", "Нептун", "Сатурн"); // ["Меркурий"] console.log(namePlanets); // ["Венера", "Уран", "Нептун", "Сатурн", "Земля", "Марс"]
Применение метода splice только для добавления новых элементов в массив.
Var namePlanets = ["Юпитер", "Сатурн", "Уран"]; namePlanets.splice(0, 0, "Венера", "Меркурий", "Земля", "Марс"); // console.log(namePlanets); // ["Венера", "Меркурий", "Земля", "Марс", "Юпитер", "Сатурн", "Уран"]
Метод join (преобразование массива в строку)
Метод join предназначен для соединения всех элементов массива в строку.
Синтаксис метода join :
Array.join(); /* separator (необязательный) - разделитель, который используется в качестве соединительной строки между каждым элементом массива. Если данный параметр не указать, то в качестве соединительной строки будет использоваться ",". Если в качестве параметра указать пустую строку, то элементы массивы в возвращаемой строке между собой ничем разделены не будут */
Var berries = ["Виноград", "Виноград", "Смородина", "Шиповник"]; var berriesStr1 = berries.join(); // "Виноград,Виноград,Смородина,Шиповник" var berriesStr2 = berries.join(""); // "ВиноградВиноградСмородинаШиповник" var berriesStr3 = berries.join(", "); // "Виноград, Виноград, Смородина, Шиповник" var berriesStr4 = berries.join(" + "); // "Виноград + Виноград + Смородина + Шиповник"
Если в качестве separator использовать не строку, то он будет преобразован к строке.
Var berries = ["Виноград", "Виноград", "Смородина", "Шиповник"]; var berriesStr1 = berries.join(false); // "ВиноградfalseВиноградfalseСмородинаfalseШиповник" var berriesStr2 = berries.join(4/2); // "Виноград2Виноград2Смородина2Шиповник" Элементы массива, которые имеют в качестве значения null или undefined, будут приведены к пустой строке. var arr = ; var arrStr = arr.join(", "); // "0, 5, -4"
Преобразование строки в массив - split
Метод split предназначен для преобразования строки в массив. Данный метод имеет один параметр, в качестве которого вы можете указать строку, на основании которой данная строчка будет разбита на массив строк.
Var strElementComputers = "Системный блок, Монитор, Клавиатура, Мышь, Колонки, Принтер"; var elementComputers = strElementComputers.split(", "); console.log("Количество элементов в массиве: " + elementComputers.length); for (var i=0; i <= elementComputers.length-1; i++) { console.log(i + " элемент массива = " + elementComputers[i]); }
Переупорядочивание элементов массива в обратном порядке - reverse
Метод reverse предназначен для переупорядочивания элементов массива в обратном порядке.
Var namePlanets = new Array ("Венера","Меркурий","Земля","Марс"); namePlanets.reverse(); console.log("Количество элементов в массиве: " + namePlanets.length); for (var i=0; i <= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }
Сортировка элементов массива - sort
Метод sort предназначен для сортировки элементов массива. По умолчанию данный метод сортирует массив как строки.
Var namePlanets = new Array ("Венера","Меркурий","Земля","Марс"); namePlanets.sort(); console.log("Количество элементов в массиве: " + namePlanets.length); for (var i=0; i <= namePlanets.length-1; i++) { console.log(i + " элемент массива = " + namePlanets[i]); }
