actionscript 3 arrays

— 1 —

uroki-flash-as3.ru | «Все о массивах в ActionScript 3.0»

— 2 —


Все о массивах в ActionScript 3.0

Практическое руководство с примерами

ОГЛАВЛЕНИЕ

Что такое массив ................................................................................................................ 5

Структура массива ............................................................................................................. 5

Элементы массива ......................................................................................................... 5

Индексирование элементов массива ............................................................................ 6

Размер массива .............................................................................................................. 6

Создание массивов ............................................................................................................ 6

Создание литерала массива ......................................................................................... 6

Создание массива с помощью оператора new ............................................................ 7

Обращение к элементам массива .................................................................................... 8

Получение значений элементов .................................................................................... 8

Присвоение значения элементу .................................................................................. 10

Определение размера массива .................................................................................. 11

Добавление элементов в массив .................................................................................... 13

Прямое добавление новых элементов в массив ....................................................... 13

Добавление элементов с помощью свойства length .................................................. 14

Добавление новых элементов с помощью методов класса Array ............................ 14

Метод push() .............................................................................................................. 15

Проталкивание, выталкивание и стеки ................................................................... 16

Метод unshift() ........................................................................................................... 16

Метод splice() ............................................................................................................ 17

Метод concat() ........................................................................................................... 19

— 3 —


Удаление элементов из массива .................................................................................... 20

Удаление элементов с помощью оператора delete ................................................... 20

Удаление элементов с помощью свойства length ...................................................... 21

Метод pop()................................................................................................................ 21

Метод shift() ............................................................................................................... 22

Метод splice() ............................................................................................................ 22

Проверка содержимого массива с помощью метода toString() .................................... 23

Многомерные массивы .................................................................................................... 24

Итоги ................................................................................................................................. 25

— 4 —


В этой книге мы подробно рассмотрим массивы и работу с ними в ActionScript 3.0.

Массив — это такой тип данных, в котором информация представлена в виде упорядоченного набора или списка. В массиве, как переменной, может храниться любое количество единиц информации, что позволяет объединять их в группы для удобства последующей работы с ними.

У класса Array (массив) есть методы и свойства, которые позволяют работать с этим набором данных:

редактировать его; осуществлять в нем поиск; сортировать; проводить операции над группой данных, как целым.

Массивы присутствуют во всех языках программирования и ActionScript 3.0 здесь не исключение.

От других переменных в AS3 таких, как строка (String), число (Number), булевый тип данных (Boolean) массивы отличаются своей сложной конструкцией. Они способны хранить в себе информацию с различными типами данных.

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

— 5 —


Что такое массив

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

// две одиночных строки "карандаши" "ручки"

// одиночный массив, содержащий две строки ["линейки", "циркули"]

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

["апельсины", 4, "яблоки", 10, "морковь", 1];

Не смотря на то, что массив может хранить в себе множество различных значений важно отметить, что он сам является единичным значением данных.

// Создание переменной и присвоение ей типа данных Array var product:Array = ["духи Chanel № 5", 2];

// Передача массива функции display(product);

Структура массива

Значения, хранящиеся в массиве, называются элементами. Каждому из них присваивается уникальная числовая позиция — индекс, который и используется для обращения к элементам.

Элементы массива Как и в случае с обычной переменной, каждому элементу массива может быть присвоено любое значение. Наполненный массив подобен коллекции переменных с

— 6 —


именами, данными в определенном порядке, но вместо того, чтобы у каждого значения было другое имя, каждому элементу массива присвоен свой номер (у первого элемента — это 0, а не 1). Для того чтобы управлять значениями элементов в массиве мы обращаемся к ним, используя этот номер.

Индексирование элементов массива Позиция элемента в массиве называется индексом. Мы используем индекс элемента для назначения или получения значения элемента, а также для других целей. Например, некоторые методы (функции) управления массивами используют индексы элементов для того, чтобы сделать из них выборку определенной группы, а затем использовать ее в последующих вычислениях.

Кроме того можно вставлять и удалять элементы в начало, конец и даже середину массива. Массив может содержать и пустые элементы. Например, элементы в позициях 2 и 5 хранят определенные значения, а индексы 0, 1, 3 и 4 пусты. В программировании такие массивы называются разреженными.

Размер массива В разные моменты своего существования в массиве может храниться разное количество элементов (как заполненных, так и пустых). Количество элементов в массиве называется его длиной (length), о которой мы поговорим чуть ниже в этой главе.

Создание массивов

Для создания нового массива можно использовать либо литеральную (буквальную, прямую) его запись, либо оператор new (т.е. new Array()).

Создание литерала массива В литерале массива квадратные скобки символизируют начало и конец массива. Внутри квадратных скобок значения элементов массива отделяются друг от друга запятой. Вот пример такой записи:

[значение1, значение2, значение3]

— 7 —


Значения определены, а затем присвоены элементам массива. Любое корректное значение теперь может использоваться. Ими могут быть переменные, литералы, вызов функций и даже другие массивы (массив, который содержит в себе другой массив, называют двумерным или, иногда, вложенным).

Вот несколько примеров:

// Простые числа [3, 9, 43];

// простые строки ["груша", "апельсин", "банан"]

// простые числа и числовое выражение [8, 1, 4 - 2]

// переменные и простые строки [firstName, lastName, "мужчина", "холост"]

// строка и вложенный массив ["подростковый возраст", [12, 13, 14, 15]]

Создание массива с помощью оператора new Для создания массива с помощью оператора new используется следующий синтаксис:

new Array(аргументы)

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

new Array("ложка", "тарелка", "чашка")

При передаче конструктору массива единственного аргумента в виде числа, он создает массив из пустых элементов, количество которых равно числу, переданному конструктору (создавать литерал такого массива немного утомительно, согласитесь). Например, следующий код создает массив с 24-мя пустыми элементами:

new Array(24)

Аргументами, которые передаются конструктору массива, могут быть любые корректные выражения, включая сложные. Например, следующий код создает массив, в котором первый элемент равен 13, а второй 48:

— 8 —


var x:int = 12;

var y:int = 4;

var numbers:Array = new Array(x + 1, x * y);

Для сравнения приведу код, создающий такие же массивы, что и в предыдущей части, но использующий оператор new, т.е. не литерал массива:

new Array(3, 9, 43)

new Array("груша", "апельсин", "банан")

new Array(8, 1, 4-2)

new Array(firstName, lastName, "мужчина", "холост")

new Array("подростковый возраст", new Array(12, 13, 14, 15))

Обращение к элементам массива

После создания массива мы, практически, всегда желаем получить или изменить значения элементов массива. Для этого мы используем оператор доступа к массиву — [ ] (квадратные скобки).

Получение значений элементов Для доступа к одиночному значению элемента, мы записываем имя массива, за которым следует индекс элемента в квадратных скобках:

имяМассива[индексЭлемента]

В предыдущем коде имяМассива указывает на массив, к которому мы обращаемся (обычно это переменная с типом данных Array), а индексЭлемента — это целое число (integer), определяющее индекс элемента. Индекс первого элемента в массиве равен 0, а последнего — на единицу меньше длины массива. Обращаясь к элементу, индекс которого больше чем индекс последнего корректного элемента массива заставит ActionScript вернуть значение undefined потому, что указанный индекс находится за пределами границ массива.

— 9 —


Давайте попробуем получить значения некоторых элементов массива. Нижеследующий код создает литерал массива и присваивает ему имя переменной trees:

var trees:Array = ["береза", "клен", "дуб", "кедр"];

Следующий код присваивает переменной firstTree значение первого элемента ("береза") массива trees:

var firstTree:String = trees[0];

Следующий код присваивает переменной favoriteTree значение третьего элемента ("дуб") массива trees (помните, что поскольку индексы начинаются с 0, то элемент с индексом 2 будет в массиве третьим по счету!)

var favoriteTree:String = trees[2];

А вот теперь интересный момент. Поскольку мы можем указывать индекс элемента в виде любого выражения, результат которого есть число, то для указания индекса элемента мы можем использовать переменные или арифметические выражения точно так же, как мы используем простые числа. Например, следующий код присваивает переменной lastTree значение четвертого элемента ("кедр") массива trees:

var i = 3;

var lastTree:String = trees[i];

Мы можем даже использовать выражения, результирующее значение которых соответствует индексам массива. Например, следующий код присваивает переменной randomTree (случайное дерево) значение случайно выбранного элемента из массива trees, вычисляя случайное число между 0 и 3.

var randomTree:String = trees[Math.floor(Math.random( ) * 4)];

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

var ages:Array = [12, 4, 90];

// сумма значений массива var totalAge:Number = ages[0] + ages[1] + ages[2];

— 10 —


Суммирование значений элементов массива вручную, конечно не является образцом оптимизированного кода. Чуть позже я вам покажу гораздо более удобный способ последовательного обращения к элементам массива.

Присвоение значения элементу Для присвоения значения элементу используйте запись имяМассива[номерЭлемента] в качестве операнда в левой части выражения присвоения. В качестве примера рассмотрим следующий код:

// создаем массив var cities:Array = ["Москва", "Санкт-Петербург", "Вязьма", "Калининград"];

// наш массив выглядит так: // ["Москва", "Санкт-Петербург", "Вязьма", "Калининград"]

// присвойте новое значение первому элементу массива cities[0] = "Курск";

// а теперь наш массив содержит следующие элементы: // ["Курск", "Санкт-Петербург", "Вязьма", "Калининград"]

// присвойте новое значение четвертому элементу cities[3] = "Урюпинск";

// и наш массив изменится на // ["Курск", "Санкт-Петербург", "Вязьма", "Урюпинск"]

// присвойте новое значение третьему элементу cities[2] = 3.14; // при этом тип данных элемента изменился, но это не проблема!

// в итоге наш массив выглядит так: // ["Курск", "Санкт-Петербург", 3.14, "Урюпинск"]

Заметьте, что при выборе элемента массива мы можем использовать любые числовые выражения с неотрицательным результатом для определения индекса:

var i:int = 1;

// присваиваем значение элементу i cities[i] = "Владивосток";

// итоговый массив ["Курск", "Владивосток", 3.14, "Урюпинск"]

— 11 —


Определение размера массива У всех массивов есть свойство, которое называется length (длина). Оно показывает количество элементов в массиве, включая те, которые были определены как undefined. Для получения значения свойства length используется оператор . (точка). Записывается это так:

имяМассива.length

Еще несколько примеров:

var nums:Array = [34, 45, 57];

trace(nums.length); // выводит: 3

var words:Array = ["буква", "слово", "фраза"];

trace(words.length); // выводит: 3

var cards:Array = new Array(52); // заметьте, что мы передали единственный числовой аргумент // конструктору массива

trace(cards.length); // выводит: 52

Длина массива всегда на 1 больше, чем индекс его последнего элемента. Например, длина массива с индексами элементов 0, 1 и 2 равна 3. А у массива с индексами элементов 0, 1, 2 и 30 длина равна 31. Почему 31? Несмотря на то, что индексы от 3 до 29 отсутствуют, они все равно учитываются при определении длины массива. Индекс последнего элемента всегда равен имяМассива.length – 1 (потому, что начало отсчета индексов в массиве всегда начинается с 0, как вы уже знаете из предыдущего материала). Чтобы получить значение последнего элемента массива используйте следующий код:

имяМассива[имяМассива.length – 1]

Если мы добавляем элементы в массив или удаляем их, то переменная length автоматически обновляется, отражая эти изменения.

Кроме того, мы можем добавлять элементы в конец массива и удалять их, изменяя значение свойства length. Свойство length класса String (строка) немного отличается: его значение мы можем только получать, но не изменять, т.е. оно только для чтения (readonly). Уменьшая значение свойства length, мы в результате сокращаем количество элементов, которые он содержит.

— 12 —


Используя свойство length, мы можем создать цикл, который будет последовательно обращаться ко всем элементам массива. Подобный прием встречается настолько часто в программировании, что его можно назвать фундаментальным. Для того чтобы увидеть возможности, которые дает комбинирование циклов и массивов, давайте рассмотрим пример, иллюстрирующий принцип поиска определенной мелодии со значением «хип-хоп» в массиве.

// создаем массив var soundtracks:Array = ["электронная", "рэп", "поп", "альтернативная", "классическая"];

// проверка каждого элемента на наличие слова «рэп» for (var i:int = 0; i < soundtracks.length; i++) {

trace("Проверяемый элемент: " + i);

if (soundtracks[i] == "рэп") {

trace("Индекс элемента «рэп»: " + i);

break;

}

}

Давайте сделаем предыдущий код более абстрактным, т.е. превратим его в общий метод, позволяющий искать любой элемент в любом массиве. Если элемент будет найден, то он будет возвращать его индекс, а если такой элемент отсутствует, то -1.

public function searchArray(myArray:Array, searchElement:Object):int {

// проверка каждого элемента на содержание searchElement for (var i:int = 0; i < myArray.length; i++) {

if (myArray[i] == searchElement) {

return i;

}

}

return -1;

}

— 13 —


А вот пример практического использования нашего метода поиска. В нем мы проверяем, есть ли в списке (массив userNames) пользователь под именем "Петр". Этот массив гипотетический и создан лишь для примера:

if (searchArray(userNames, "Петр") == -1) {

trace("Извините, пользователь с таким именем не найден.");

} else {

trace("Добро пожаловать в игру, Петр..");

}

Метод searchArray() демонстрирует код, реализующий последовательный проход по всем элементам массива, но не предназначенный для использования в реальных программах. Для решения такой задачи (получение индекса элемента) лучше пользоваться методами indexOf() и lastIndexOf(), которые есть у класса Array.

Далее вы узнаете о том, как управлять массивами, включая методы, которые принадлежат классу Array.

Добавление элементов в массив

Для добавления элементов в массив используются следующие способы:

присвойте значение новому элементу, индекс которого равен длине массива или больше его;

увеличьте значение свойства массива length; вызовите один из методов: push(), unshift(), splice() или concat().

Давайте рассмотрим более детально перечисленные способы.

Прямое добавление новых элементов в массив Чтобы добавить в массив новый элемент с определенным индексом просто присвойте значение этому элементу. Например:

// Создаем массив и добавляем в него три значения var birds:Array = ["воробей", "ворона", "сорока"];

— 14 —


// Добавляем четвертое значение birds[3] = "галка";

Размещать новый элемент сразу за последним элементом массива не обязательно. Если мы помещаем новый элемент более чем на один элемент после конца массива, то ActionScript автоматически создает элементы со значениями underfined для промежуточных индексов:

// Оставить индексы с 4 по 15 незаполненными birds[16] = "соловей";

trace(birds[13]); // Выводит: undefined

Если элемент уже существует, то его значение будет заменено новым. Если указанный элемент не существует, то он будет добавлен в массив.

Добавление элементов с помощью свойства length Чтобы расширить массив, не присваивая значений новым элементам, можно просто увеличить значение переменной length, а ActionScript добавит необходимое количество элементов для достижения указанной длины:

// Создаем массив с тремя элементами var breeds = ["овчарка", "колли", "бультерьер"];

// Добавляем в массив 9 незаполненных элементов от 3 до 11 breeds.length = 12;

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

Добавление новых элементов с помощью методов класса Array Для выполнения более сложных операций по добавлению элементов можно использовать методы класса Array.

— 15 —


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

имяМассива.push(элемент1, элемент2, ... элементn);

В предыдущем коде имяМассива — это ссылка на объект класса Array, а элемент1, элемент2 ... элементn — это список элементов, разделенных запятыми, которые добавляются в конец массива и представляют новые элементы. Вот несколько примеров:

// Создаем массив с двумя элементами var menuItems:Array = ["Главная", "Контакты"];

// Добавляем элемент menuItems.push("Товары"); // menuItems становится ["Главная", "Контакты", "Товары"]

// Добавляем еще два элемента menuItems.push("Услуги", "О нас");

// menuItems становится: // ["Главная", "Контакты", "Товары", "Услуги", "О нас"]

Метод push() возвращает новую длину измененного массива (т.е. значение переменной length):

var myList:Array = [12, 23, 98];

trace(myList.push(28, 36)); // Добавляет 28 и 36 к списку и выводит: 5

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

var temperature:int = 22;

var sky:String = "солнечно";

var weatherListing:Array = new Array();

— 16 —


// Добавляем 22 и "сонечно" в массив weatherListing.push(temperature, sky);

Проталкивание, выталкивание и стеки Метод push() берет свое название из концепции программирования, которая называется стеком. Стек может рассматриваться как вертикальный массив, аналогичный стопке тарелок. Если вы часто посещаете кафетерии или рестораны с буфетами, вам должны быть знакомы пружинные подставки, которые удерживают тарелки для клиентов. Когда появляются чистые тарелки, они буквально проталкиваются на вершину стека, при этом те тарелки, которые уже находились в подставке, опускаются ниже. Когда клиент выталкивает тарелку с вершины стека, он забирает тарелку, которая была добавлена в стек самой последней. Этот тип стека называется «последним пришел — первым вышел» (last-in-first-out — LIFO) и обычно применяется для реализации, например, списков предыстории. Например, если вы нажмете кнопку «Назад» в своем браузере, то откроется предыдущая просмотренная страница. Если снова нажать кнопку «Назад», то откроется страница, которая просматривалась перед предыдущей, и т. д. Такое поведение достигается путем проталкивания URL-адреса каждой просматриваемой страницы в стек и последующего выталкивания адреса из стека при нажатии кнопки «Назад».

Примеры LIFO-стеков можно найти и в реальной жизни. Человек, последним сдавший багаж при посадке на самолет, после приземления самолета обычно по-лучает свой багаж первым, поскольку разгрузка багажа осуществляется в порядке, обратном погрузке. Пассажир, сдавший свой багаж первым, после приземления самолета будет вынуждена простоять у ленты багажного транспортера дольше всех.

Стек типа «первым пришел — первым вышел» (first-in-first-out — FIFO) является более «справедливым». В основе его функционирования лежит обслуживание в порядке поступления. Примером FIFO-стека является очередь в банке. FIFO-стек работает не с последним элементом массива, а с первым. После этого первый элемент массива удаляется, а все оставшиеся элементы «продвигаются» точно так же, как продвигается очередь, когда человек, стоявший перед вами, «удаляется» (то есть либо он покинул очередь после того, как был обслужен, либо он решил покинуть очередь раньше времени, устав от ожидания). Таким образом, слово «проталкивать» обычно применяется в отношении LIFO-стека, тогда как слово «добавлять» применяется в отношении FIFO-стека. В любом случае элементы добавляются в «конец» стека. Разница заключается в том, какой конец массива хранит элемент для следующей операции.

Метод unshift() Метод unshift() во многом похож на метод push(), однако он добавляет один или несколько элементов в начало массива, смещая существующие элементы для

— 17 —


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

имяМассива.unshift(элемент1, злемент2, ... элементn);

В приведенном коде имяМассива — это ссылка на объект класса Array, а элемент1, элемент2. . . элементn — список элементов, разделенных запятыми, которые добавляются в начало массива и представляют новые элементы. Обратите внимание, что элементы добавляются в том порядке, в котором они передаются в метод. Рассмотрим несколько примеров:

var versions:Array = new Array();

versions[0] = 6;

versions.unshift(5); // Массив versions выглядит так: [5,6]

versions.unshift(2,3,4); // Массив versions выглядит так: [2,3,4,5,6]

Метод unshift(), как и метод push(), возвращает длину увеличенного массива.

Метод splice() Метод splice() позволяет добавлять в массив или удалять из него элементы. Этот метод обычно применяется для вставки элементов в середину массива (при этом элементы, находящиеся после точки вставки, перенумеровываются, чтобы освободить пространство для добавляемых элементов) или для удаления элементов из середины массива (при этом перенумеровываются элементы, находящиеся после удаляемых элементов, для ликвидации образовавшегося промежутка). Если обе задачи выполняются одновременно за один вызов метода splice(), то некоторые элементы массива фактически заменяются новыми элементами (хотя количество добавляемых и удаляемых элементов может не совпадать). Метод splice() имеет следующий обобщенный вид:

имяМассива.spliсе(начальныйИндекс, количествоУдаляемыхЭлементов, элемент1, элемент2. .. элементn);

В предыдущем коде имяМассива — это ссылка на объект класса Array; начальныйИндекс — число, определяющее индекс, начиная с которого будут выполняться удаление и необязательное добавление элементов (помните, что индексом первого элемента является 0); количествоУдаляемыхЭлементов — необязательный аргумент, который определяет количество удаляемых элементов

— 18 —


(включая элемент с индексом начальныйИндекс). Если аргумент количествоУдаляемыхЭлементов опущен, то все элементы, расположенные после элемента с индексом начальныйИндекс, включая сам элемент с данным индексом, будут удалены. Необязательные параметры элемент1, элемент2. . . элементn — объекты, добавляемые в массив в качестве элементов, начиная с индекса начальныйИндекс.

Вот несколько примеров практического использования метода splice() класса Array:

// Создание массива var months:Array = new Array("Январь", "Пятница", "Апрель", "Май", "Воскресенье", "Понедельник", "Июль");

// Очевидно, что наш массив несколько неоднороден. Давайте его // поправим. Во-первых, избавимся от элемента "Пятница" months.splice(1,1);

// Массив months теперь выглядит так: // ["Январь", "Апрель", "Май", "Воскресенье", "Понедельник", // "Июль"]

// Теперь добавим два месяца перед элементом "Апрель". // Обратите внимание, что мы ничего не удаляем. months.splice(1, 0, "Февраль", "Март");

// Массив months теперь выглядит так: // ["Январь", "Февраль", "Март", "Апрель", "Май", "Воскресенье", // "Понедельник", "Июль"]

// Наконец, удалим элементы "Воскресенье" и "Понедельник", // одновременно добавив элемент "Июнь" months.splice(5, 2, "Июнь");

// Массив months теперь выглядит так: // ["Январь", "Февраль", "Март", "Апрель", "Май", "Июнь", "Июль"]

// Теперь, когда массив months приведен в порядок, обрежем его. // чтобы остались только названия месяцев первого квартала года. // Удалим все элементы, начиная с индекса 3 (то есть "Апрель") months.splice(3);

// Теперь массив months выглядит так: ["Январь", "Февраль", // "Март"]

— 19 —


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

var letters:Array = ["a", "б", "в", "г"];

trace(letters.splice(1, 2)); // Выводит: "б, в" // Теперь массив letters выглядит так ["a", "г"]

Если никакие элементы не удалялись, то метод splice() возвращает пустой массив (т.е. массив без элементов).

Метод concat() Метод concat() объединяет два или более массива в один новый массив и возвращает его. У этого метода следующий вид:

исходныйМассив.concat(списокЭлементов)

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

var list1:Array = new Array(11, 12, 13);

var list2:Array = list1.concat(14, 15); // list2 теперь выглядит так: [11, 12, 13, 14, 15]

В следующем примере метод concat() используется для объединения двух массивов:

var flowers:Array = ["ромашка", "фиалка"];

var trees:Array = ["береза", "рябина", "тополь"];

var plants:Array = trees.concat(flowers); // plants теперь выглядит так: ["береза", "рябина", "тополь", // "ромашка", "фиалка"];

Обратите внимание на то, что при добавлении массива flowers к массиву plants метод concat() разбил массив flowers на составляющие, или, иначе говоря, «выпрямил его». Иными словами, каждый элемент массива flowers был добавлен к массиву plants по отдельности. Тем не менее, метод concat() не выпрямляет вложенные массивы (элементы, которые сами являются массивами внутри основного массива), как показано в следующем коде:

— 20 —


var numbers1:Array = [1, 2, 3];

var numbers2:Array = [[5, 6], [7, 8]];

var sum:Array = numbers1.concat(numbers2); // результат выглядит так: [1, 2, 3, [5, 6], [7, 8]]. // Элементы с индексами 0 и 1 массива numbers2 не были // "выпрямлены"

Удаление элементов из массива

Для удаления элементов из массива можно воспользоваться одним из следующих способов:

Удалить определенный элемент с помощью оператора delete Уменьшить значение переменной массива length Вызвать методы pop(), shift() или splice()

Давайте рассмотрим подробнее перечисленные способы.

Удаление элементов с помощью оператора delete Оператор delete присваивает элементу массива значение underfined, используя следующий синтаксис:

delete имяМассива[индекс]

В этом коде имяМассива — это ссылка на массив, а индекс — номер или имя элемента, которому должно быть присвоено значение underfined. Название оператора delete, может ввести в заблуждение. Этот оператор не удаляет нумерованный элемент из массива, а просто присваивает указанному элементу значение underfined. Таким образом, операция delete анологична присваиванию значения underfined элементу массива. В этом легко удостовериться, сравнив значения переменной массива length до и после удаления одного из его элементов:

var list = ["a", "б", "в"];

trace(list.length); // Выводит: 3

delete list[2];

— 21 —


trace(list.length); // Все равно выводит 3, т.к. элемент с индексом 2 undefined вместо // "в", но все равно существует

Чтобы удалить элементы, на самом деле, используйте метод splice() (для удаления элементов из середины массива) или методы shift() и pop() (для удаления элементов из начала или конца массива соответственно).

Удаление элементов с помощью свойства length Чтобы удалить элементы в конце массива, т.е. обрезать массив, можно присвоить свойству массива length значение меньше, чем ее текущее значение:

var sports:Array = ["футбол", "хоккей", "баскетбол", "регби", "керлинг"];

sports.length = 3;

trace(sports); // Выводит: "футбол,хоккей,баскетбол" // Элементы 3 и 4 были удалены (два последних)

Удаление элементов с помощью методов класса Array

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

Метод pop() Метод pop() является полной противоположностью метода push(): он удаляет последний элемент массива. Синтаксис метода pop() очень прост:

имяМассива.pop()

Метод pop() уменьшает на единицу значение свойства массива length и возвращает значение удаляемого элемента. Например:

var numbers:Array = [56, 57, 58];

trace(numbers.pop()); // Выводит: 58 (значение удаленного элемента) // Теперь массив numbers выглядит так [56, 57]

— 22 —


Как омечалось ранее метод pop() часто используется совместно с методом push() для выполнения операций над LIFO-стеком.

Метод shift() Помните метод unshift(), который применяется для добавления элемента в начало массива? Познакомьтесь с его «двойником» — методом shift(), который удаляет элемент из начала массива:

имяМассива.shift()

Как и pop() метод shift() возвращает значение удаляемого элемента. Все оставшиеся элементы в том же порядке сдвигаются к началу массива. Например:

var sports:Array = ["гребля", "плавание", "водное поло"];

trace(sports.shift()); // Выводит: гребля // Теперь массив sports выглядит так ["плавание", "водное поло"]

trace(sports.shift()); // Выводит: плавание

// А теперь остался только один элемент ["водное поло"]

Поскольку метод shift() действительно удаляет элемент, то он оказывается более полезным для удаления первого элемента из массива, чем оператор delete.

Метод splice() Ранее мы уже познакомились с методом splice() и узнали, как с его помощью можно удалять и добавлять элементы в массив. Поскольку метод splice() был рассмотрен достаточно подробно, то мы не будем пересматривать его в этом разделе. Тем не менее, для более полной информации следующий код продемонстрирует возможности метода splice() по удалению элементов:

var letters:Array = ["a", "b", "c", "d", "e", "f"]; // Удаляем элементы с индексами 1, 2 и 3, оставляя ["a", "e", "f"]

— 23 —


letters.splice(1, 3);

// Удаляем все элементы, начиная с индекса 1, оставив только ["a"] letters.splice(1);

Проверка содержимого массива с помощью метода toString()

Метод toString(), принадлежащий любому объекту в ActionScript 3.0, возвращает его строковое представление. В случае с объектом класса Array метод toString() возвращает список элементов массива, преобразованных в строки и разделенных запятыми. Метод toString() можно вызвать явно, как показано в следующем коде:

имяМассива.toString()

Обычно метод toString() не вызывается явно. Вместо этого он вызывается автоматически всякий раз, когда массив имяМассива используется в строковом контексте. Например, выражение trace(имяМассива) отобразит список значений элементов массива, разделенных запятыми. Выражение trace(имяМассива) эквивалентно выражению trace(имяМассива.toString()).

Метод toString()бывает часто полезен при отладке, когда необходимо получить быструю, неформатированную информацию об элементах, содержащихся в массиве. Например:

var names= ["Илья", "Кирилл", "Светлана"];

trace("В массиве names находятся следующие имена: " + names);

Необходимо отметить, что метод join() предоставляет более широкие возможности по форматированию информации, чем toString(). Более подробные сведения можно получить в справочнике по языку ActionScript корпорации Adobe.

— 24 —


Многомерные массивы

До сих пор мы рассматривали только одномерные массивы, которые аналогичны одной строке или одному столбцу в электронной таблице. Что же делать в том случае, если мы захотим создать эквивалент электронной таблицы с несколькими строками и столбцами? Нам понадобится второе измерение. Язык ActionScript в прямом виде поддерживает только одномерные массивы, однако мы можем имитировать многомерный массив, создав массивы внутри массивов. Другими словами, мы можем создавать массивы, элементами которых являются другие массивы (иногда называемые вложенными).

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

Рассмотрим, как работает двумерный массив, на практическом примере. Пред-положим, мы обрабатываем заказ на три товара, каждый из которых имеет коли-чество и цену. Мы хотим имитировать электронную таблицу с тремя строками (по одной строке для каждого товара) и двумя столбцами (один столбец для количества, другой — для цены). Мы создаем отдельный массив для каждой строки, при этом каждый элемент строки представляет значение в соответствующем столбце:

var row1:Array = [6, 2.99]; // Количество 6, цена 2.99



Затем мы помещаем созданные строки в массив-контейнер с именем spreadsheet:

var spreadsheet:Array = [row1, row2, row3];

Теперь мы можем найти общую сумму заказа, перемножив значения количества и цены для каждой строки и сложив получившиеся произведения. Для обращения к элементам двумерного массива используются два индекса (один индекс обозначает строку, другой — столбец). Выражение spreadsheet [0], например, представляет первую строку массива, состоящего из двух столбцов. Таким образом, чтобы обратиться ко второму столбцу первой строки массива spreadsheet, мы используем выражение spreadsheet [0] [1] (оно вернет значение 2,99). Общая стоимость товаров, содержащихся в массиве spreadsheet, вычисляется следующим образом:

— 25 —


// Создаем переменную для хранения общей суммы заказа var total:Number;

// Теперь определяем стоимость заказа. Для каждой строки // перемножаем значения столбцов, а полученное произведение // прибавляем к значению переменной total

for (var i:int = 0; i < spreadsheet.length; i++) {

total += spreadsheet[i][0] * spreadsheet[i][1];

}

trace(total); // Выводит: 117.89

Итоги

Эта книга дает общее представление о массивах. Предложенная информация не является исчерпывающей.

Класс Array обладает множеством полезных методов для переупорядочивания и сортировки элементов массива, фильтрации элементов, преобразования элементов в строки и извлечения массивов из других массивов. Более детальное описание класса Array можно найти в справочнике по языку ActionScript 3.0 корпорации Adobe.

http://help.adobe.com/ru_RU/FlashPlatform/reference/actionscript/3/Array.html

Если у вас остались вопросы или вы хотите высказать свои пожелания по улучшению содержания данного пособия или просто оставить отзыв, то присылайте их по адресу [email protected].

Успехов в изучении ActionScript 3.0 и Flash!

http://help.adobe.com/ru_RU/FlashPlatform/reference/actionscript/3/Array.html

mailto:[email protected]

actionscript 3 arrays

Documents

array var product