Массивы. Добавление и удаление элементов массива

1
2
3
4
5
6
7
8

27
28
29
30

Разберем подробнее каждый вид.

При работе с ассоциативными массивами очень легко как добавлять элементы, так и удалять. Так как данный скриптовый язык не типизирован и в нем нет множества строгих правил, создавать элементы объекта можно несколькими способами: перечислить их сразу, проинициализировать после создания объекта, а также создавать по ходу кода.

Сейчас я хочу показать примеры реализации таких механизмов. В первой программе я создал объект patient , а после перечислил его элементы. Как видите, для patient. param я сделал вложенный объект, который обладает своими собственными значениями.

var patient = new Object(); patient.firstName ="Инна" patient.age =34, patient.param ={ height:169 , weight: 55, disease: "no" } alert(patient.firstName) // выведет "Инна" alert(patient.param.disease) // выведет no

Если появится необходимость добавить еще один параметр к уже существующим, например, фамилию, то это делается следующим образом. К презентованному выше коду допишите строки:

patient.surname = «Луценко»

alert (patient.surname)

Вот так легко коллекция пополняется новыми свойствами. При желании изменить какое-либо значение, его нужно просто присвоить выбранному ключу:

patient.firstName ="Катя"

Для объектов также предусмотрена операция удаления ненужных свойств при помощи команды delete:

delete patient.surname

На них еще иногда говорят «массивы с числовыми индексами». Если сравнивать их с предыдущим вариантом, то здесь ключи представлены в виде чисел, а вот значения могут быть абсолютно любыми. Занесение коллекции в такой объект может быть осуществлено не по порядку.

Так, один элемент можно вписать в ячейку с индексом «0», а следующий – с индексом «4». Промежуточные ячейки памяти будут пустовать и выдавать «undefined», если к ним обратиться.

В качестве примера я написал небольшое приложение, в котором создан массив товаров.

var goods = ["Говядина","Макароны","Твердый сыр","Специи"]; alert(goods); alert(goods); goods = "Томаты" alert(goods);

Я специально показал вам, как вывести весь список покупок и как выбрать один элемент. К тому же я затронул свойство length , о котором конкретно расскажу позже. А пока дам небольшое пояснение.

goods = «Томаты»

На этом окончу свое повествование. Вступайте в группу моих подписчиков и приглашайте друзей. А я вам желаю терпения и удачи в обучении!

Пока-пока!

С уважением, Роман Чуешов

Прочитано: 155 раз

Массивы

Массив - это упорядоченная коллекция значений. Значения в массиве называются элементами, и каждый элемент характеризуется числовой позицией в массиве, которая называется индексом. Массивы в языке 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

Стандарт ECMAScript 3 определяет в составе Array.prototype множество удобных функций для работы с массивами, которые доступны как методы любого массива. Эти методы будут представлены в следующих подразделах.

Метод Array.join() преобразует все элементы массива в строки, объединяет их и возвращает получившуюся строку. В необязательном аргументе методу можно передать строку, которая будет использоваться для отделения элементов в строке результата. Если строка-разделитель не указана, используется запятая. Например, следующий фрагмент дает в результате строку "1,2,3":

Var arr = ; arr.join(); // "1,2,3" arr.join("-"); // "1-2-3"

Метод Array.reverse() меняет порядок следования элементов в массиве на обратный и возвращает переупорядоченный массив. Перестановка выполняется непосредственно в исходном массиве, т.е. этот метод не создает новый массив с переупорядоченными элементами, а переупорядочивает их в уже существующем массиве. Например, следующий фрагмент, где используются методы reverse() и join(), дает в результате строку "3,2,1":

Var arr = ; arr.reverse().join(); // "3,2,1"

Метод 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});

Обратите внимание, насколько удобно использовать в этом фрагменте неименованную функцию. Функция сравнения используется только здесь, поэтому нет необходимости давать ей имя.

Метод Array.concat() создает и возвращает новый массив, содержащий элементы исходного массива, для которого был вызван метод concat(), и значения всех аргументов, переданных методу concat(). Если какой-либо из этих аргументов сам является массивом, его элементы добавляются в возвращаемый массив. Следует, однако, отметить, что рекурсивного превращения массива из массивов в одномерный массив не происходит. Метод concat() не изменяет исходный массив. Ниже приводится несколько примеров:

Var arr = ; arr.concat(4, 5); // Вернет arr.concat(); // Вернет arr.concat(,) // Вернет arr.concat(4, ]) // Вернет ]

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

Если указан только один аргумент, возвращаемый массив содержит все элементы от начальной позиции до конца массива. Если какой-либо из аргументов имеет отрицательное значение, он определяет номер элемента относительно конца массива. Так, аргументу -1 соответствует последний элемент массива, а аргументу -3 - третий элемент массива с конца. Вот несколько примеров:

Var arr = ; arr.slice(0,3); // Вернет arr.slice(3); // Вернет arr.slice(1,-1); // Вернет arr.slice(-3,-2); // Вернет

Метод 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() выполняет обратную операцию - удаляет последний элемент массива, уменьшает длину массива и возвращает удаленное им значение. Обратите внимание, что оба эти метода изменяют исходный массив, а не создают его модифицированную копию.

Методы unshift() и shift() ведут себя почти так же, как push() и pop(), за исключением того, что они вставляют и удаляют элементы в начале массива, а не в конце. Метод unshift() смещает существующие элементы в сторону больших индексов для освобождения места, добавляет элемент или элементы в начало массива и возвращает новую длину массива. Метод shift() удаляет и возвращает первый элемент массива, смещая все последующие элементы на одну позицию вниз, чтобы занять место, освободившееся в начале массива.

Каждый день разработчики имеют дело с массивами. Будучи упорядоченной коллекцией, важным свойством массива для создания запроса является Array.prototype.length .

В JavaScript length не всегда указывает на количество существующих элементов (для разреженных массивов ). Поэтому давайте разберемся с этим свойством.

Длина массива представляется без знаковым 32-битным целым числом, значение которого больше максимального индекса. С определенными типами массивов это свойство ведет себя по-разному.

Давайте перечислим их: плотный массив — его элементы имеют смежные индексы, начиная с 0 . Например: –плотный массив, поскольку индексы являются смежными: 0 , 1 и 2 .

Разреженный массив — его элементы не имеют смежных индексов, начиная с 0 . Например: – разреженный массив, так как индексы элементов не являются смежными: 0 , 2 и 3 .

Обычно JavaScript array length используют для определения количества элементов. Это корректно для плотного типа коллекции:

var fruits = ["апельсин", "яблоко", "банан"]; //fruits – плотный массив fruits.length // выводит 3, реальное количество элементов fruits.push("манго"); fruits.length // выводит 4, так как был добавлен еще один элемент var empty = ; empty.length // выводит 0, пустой массив

Посмотреть пример

Плотный массив не имеет пробелов, и количество элементов соответствует максимальному индексу плюс единица. В максимальный индекс 3 у элемента «8» , при этом размер массива 3 + 1 = 4 .

В разреженном массиве arr length JavaScript больше максимального индекса, но он не указывает на реальное количество элементов. При выполнении запроса length будет больше, чем количество элементов. Это происходит из-за пробелов в массиве:

var animals = ["кошка", "собака", "обезьяна"]; // animals -разреженный массив animals.length // выводит 4, но реальное количество элементов 3 var words = ["hello"]; words = "welcome"; //максимальный индекс 6. words – разреженный массив words.length //выводит 7, опирается на максимальный индекс

При добавлении или удалении элементов length изменяет только максимальный индекс. Любые изменения массива, которые не влияют на индекс с максимальным значением, не изменяют length . Например, при использовании delete :

var colors = ["синий", "красный", "желтый", "белый", "черный"]; colors.length // выводит 5 delete colors; // удаляем первый элемент "синий". // Массив становится разреженным colors.length // по-прежнему выводит 5, потому что максимальный индекс 4 // не изменен

Посмотреть пример

В предыдущих примерах свойство length предназначалось только для чтения. Но JavaScript length позволяет изменить и это свойство.

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

Когда новое значение length меньше или равно максимальному индексу, любые элементы, индекс которых больше или равен новому размеру, удаляются. Полезный сценарий для удаления элементов из конца массива:

var numbers = ; numbers.length = 3; // изменение длины массива numbers // выводит , элементы 7 и 8 удалены

При использовании значения большего, чем максимальный индекс, массив станет разреженным:

var osTypes = ["OS X", "Linux", "Windows"]; osTypes.length = 5; // Создание разреженного массива. Элементы с индексами 3 и 4 // отсутствуют osTypes // выводит ["OS X", "Linux", "Windows", ]

Посмотреть пример

Length можно присвоить нечисловой тип данных. JavaScript преобразует примитив в число. Если результат преобразования равен NaN или числу меньше 0 , то выдается ошибка Uncaught RangeError: Invalid array length («недопустимая длина массива »):

var numbers = ; numbers.length = "2"; // "2" преобразуется в число 2 numbers.length = "not-number"; // выдает ошибку Uncaught RangeError: Invalid array length numbers.length = -2; // выдает Uncaught RangeError: Invalid array length

Изменение свойства JavaScript array length , удаление элементов с помощью delete , добавление элементов с новым индексом является источником проблем: так создаются разреженные массивы. И как результат получаем противоречивое значение length .

JavaScript предлагает более безопасные альтернативы.

Для добавления элементов в конец массива используют Array.prototype.push() , а для удаления последнего элемента — pop() . Чтобы вставить элемент в начало, используется unshift() . Для удаления первого элемента — shift() .

Для осуществления более сложных вставок, удалений или замен используйте достаточно мощный метод splice() :

var companies = ["Apple", "Dell"]; companies.push("ASUS"); // Вставляет элемент в конец массива companies // prints ["Apple", "Dell", "ASUS"] companies.pop(); // Выводит"ASUS". Удаляет последний элемент массива companies // выводит ["Apple", "Dell"] companies.shift(); // Выводит "Apple". Удаляет первый элемент массива companies // Выводит ["Dell"] companies.splice(1, 0, "Microsoft", "HP"); // Добавляет 2 компании companies // Выводит ["Dell", "Microsoft", "HP"] companies.length // Выводит 3. Массив плотный

Посмотреть пример

Иногда массив может быть разреженным. Поэтому не безопасно полагаться на свойство JavaScript length для определения количества элементов. Лучше используйте вспомогательную функцию, которая обрабатывает недостающие элементы:

/** * Количество элементов в разреженном массиве * @param {Array} collection * @return {number} */ function count(collection) { var totalCount = 0; for (var index = 0; index < collection.length; index++) { if (index in collection) { totalCount++; } } return totalCount; }

Оператор in определяет, содержится ли свойство в указанном объекте. Он отлично подходит для проверки существования элемента по определенному индексу.

JavaScript length — это свойство со сложным поведением. Оно работает без сюрпризов, но лучше принять меры предосторожности при работе с разреженными массивами и изменением его значения.