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

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

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

// элементов массива

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

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

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

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

var cities:Array = ["Toronto". "Montreal". "Vancouver". "Waterloo"]:

// массив cities в настоящий момент выглядит так: // ["Toronto". "Montreal". "Vancouver". "Waterloo"]

// Присваиваем значение первому элементу массива

citiesCO] = «London»:

// Массив cities теперь выглядит так:

// ["London". "Montreal". "Vancouver". "Waterloo"]

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

cities[3] = «Hamburg»:

// Теперь массив cities выглядит так:

// ["London". "Montreal". "Vancouver". "Hamburg"]

// Присваиваем значение третьему элементу массива cities[2] = 293.3: // Обратите внимание, что изменение типа данных // значения элемента не вызывает никаких проблем // Массив cities теперь выглядит так: // ["London". "Montreal". 293.3. "Hamburg"]

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

var i :int = 1:

// Присваиваем значение элементу с индексом i cities[i] = «Tokyo»;

// Массив cities теперь выглядит так: ["London". "Tokyo". 293.3. "Hamburg"]

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

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

массив.1ength

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

var 1ist:Array = [34. 45. 57]:

tracedist. length): // Выводит: 3

var words:Array = ["this", "that", "the other"]; trace(words.1ength); // Выводит: 3

var cards:Array = new Array(24); // Обратите внимание, что в конструктор

// класса Array передается один числовой // аргумент

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

Значение переменной массива length всегда на единицу больше индекса последнего элемента данного массива. Например, длина массива, элементы которого имеют индексы 0,1 и 2, равна 3. Длина массива, элементы которого имеют индексы 0,1,

2 и 50, равна 51. Именно 51. Несмотря на то что элементы с индексами в диапазоне от 3 до 49 являются незаполненными, они все равно учитываются при определении длины массива. Индекс последнего элемента массива всегда равен результату выражения массив. length — 1 (поскольку индексы начинаются с 0, а не с 1). Таким образом, для обращения к последнему элементу массива массив применяется следующий код:

массив[массив. length - 1]

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

С помощью переменной массива length можно создавать циклы для обхода всех элементов массива. Обход элементов массива в цикле является фундаментальной задачей программирования. Чтобы получить представление о возможностях, открывающихся при совместном использовании циклов и массивов, изучите листинг 11.1, в котором осуществляется обход элементов массива soundtracks с целью нахождения позиции элемента со значением «hip hop».

Листинг 11.1. Поиск значения в массиве

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

var soundtracks:Array = ["electronic", "hip hop".

"pop", "alternative", "classical"];

// Проверять каждый элемент, чтобы узнать, содержит ли он значение «hip hop» for (var i:int = 0; i < soundtracks.length: i++) { tracecnow examining element: " + i); if (soundtracks[i] == "hip hop") { tracecthe location of 'hip hop' is index: " + i); break;

}

}

Улучшим код листинга 11.1, превратив его в универсальный метод для поиска, который позволит искать произвольный элемент в любом массиве. Если элемент найден, то данный метод вернет позицию найденного элемента в массиве. В противном случае будет возвращено значение -1. Листинг 11.2 демонстрирует этот код.

Листинг 11.2. Универсальная функция для поиска элемента в массиве

public function searchArray (theArray:Array. searchElement:0bject):int { // Проверять каждый элемент, чтобы определить, совпадает ли // его значение со значением параметра searchElement for (var i:int = 0: i < thearray.length: i++) { if (thearray[i] == searchelement) { return i;

return -1;

}

Чтобы проверить, есть ли имя «Dan» среди имен массива userNames, который представляет собой гипотетический массив с именами авторизованных пользователей, мы можем воспользоваться нашим новым методом для поиска в массиве:

if (searchArray(userNames, «Dan») == -1) {

traceCSorry, that username wasn’t found»); } else {

trace(«Wei come to the game, Dan.»);

}

~ I Метод searchArray() демонстрирует код, который необходим для выполнения обхода А элементов массива в цикле, однако этот код не предназначен для использования в ре-¦ ffo’ альной программе. Для определения индекса заданного элемента в реальной программе используйте методы indexOf() и Iastlndex0f() класса Array.

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

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

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

? Присвоить значения новому элементу, индекс которого равен значению длины массива или больше его.

? Увеличить значение переменной массива length.

? Вызвать над массивом методы push( ), unshift ( ), splice ( ) или concat ( ).

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

Непосредственное добавление новых элементов

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

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

// Добавляем четвертое значение fruits[3] = «tangerines»;

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

// Оставить элементы с индексами от 4 до 38 незаполненными fruits[39] = «grapes»;

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

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

Переменная length

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

// Создаем массив с тремя элементами var colors = ["green", "red", "blue"];

// Добавляем в массив 47 незаполненных элементов с индексами от 3 до 49 colors. length = 50;

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

Методы класса Array

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

Метод push()

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

массив. риьМэлемент!, элемент2… элемент);

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

// Создаем массив с двумя переменными var menultems:Array = ["home", "quit"];

// Добавляем элемент menultems. push(«products»);

// Массив menultems теперь выглядит так: ["home", "quit", "products"]

// Добавляем два новых элемента

menultems. pushC’services». «contact»);

// Теперь массив menultems выглядит так:

// ["home", "quit", "products", "services", "contact"]

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

var list:Array = [12. 23. 98]: trace(myList. push(28. 36)):

// Добавляет в массив list значения 28 и 36 и выводит 5

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

var temperature:int = 22: var sky:String = «sunny»; var weatherListing:Array = new Array( );

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

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

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

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

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

Метод unshift()

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

массив. unshi ft(элемент1, элемент2… элемента):

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

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]

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

Метод splicef)

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

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

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

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

Листинг 11.3 демонстрирует разносторонность метода splice ( ).

Листинг 11.3. Использование метода splice() класса Array

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

var months:Array = new Array(«January». «Friday».

«April». «May». «Sunday». «Monday». «July»): // С нашим массивом что-то не в порядке. Подправим его. // Во-первых, избавимся от элемента «Friday», months. spliced.1): // Массив months теперь выглядит так: // ["January". "April". "May". "Sunday". "Monday". "July"]

// Теперь добавим два месяца перед элементом «April».

// Обратите внимание, что мы ничего не удаляем (deleteCount равен 0).

months. spliced. 0. «February». «March»);

// Массив months теперь выглядит так:

// ["January". "February". "March". "April".

// "May". "Sunday". "Monday". "July"]

// Наконец, удалим элементы «Sunday» и «Monday», одновременно

// добавив элемент «June».

Months. splice(5. 2, «June»):

// Массив months теперь выглядит так:

// ["January". "February". "March". "April". "May". "June". "July"]

// Теперь, когда массив months приведен в порядок, обрежем его. // чтобы остались только названия месяцев первого квартала года. // удалив все элементы, начиная с индекса 3 (то есть «April»), months. spliceO): // Теперь массив months выглядит так: // ["January". "February". "March"]

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

var letters:Array = ["a", "b". "с", "d"]: tracedetters. spliced. 2)): // Выводит: «b. c»

// Массив letters теперь выглядит так:

// ["a", "d"]

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

Метод сопсаЦ)

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

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

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

var listl:Array = new Arraydl. 12. 13);

var list2:Array = listl. concat(14. 15); // Массив list2 теперь выглядит так:

// [11. 12. 13. 14. 15]

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

var guests:Array = ["Panda". "Dave"];

var registeredPlayers:Array = ["Gray". "Doomtrooper", "TRK9"];

var all Users:Array = registeredPlayers. concat(guests);

// Массив allUsers теперь выглядит так:

// ["Gray". "Doomtrooper". "TRK9". "Panda". "Dave"]

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

var x:Array = [1. 2. 3];

var y:Array = [[5. 6]. [7. 8]];

var z:Array = x. concat(y); // Результат: [1. 2, 3. [5. 6]. [7. 8]].

// Элементы массива у с индексами 0 и 1 // не были «выпрямлены»

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

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

? Удалить определенный элемент с помощью оператора delete.

? Уменьшить значение переменной массива length.

? Вызвать методы pop ( ), shift ( ) или splice ( ) над массивом.

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

Оператор delete

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

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

В этом коде массив — это ссылка на массив, а индекс — номер или имя элемента, которому должно быть присвоено значение undefined. Название оператора

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

var list = ["a", "b", "с"]: tracedist. length); // Выводит: 3 delete list[2];

tracedist. length); // По-прежнему отображает 3. Элемент с индексом 2 // вместо значения «с» содержит значение undefined. // но все же этот элемент существует

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

Переменная length

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

var toppings:Array = ["pepperoni". "tomatoes".

"cheese", "green pepper", "broccoli"];

toppings. length = 3;

trace(toppings); // Выводит: «pepperoni. tomatoes, cheese»

// Мы обрезали элементы с индексами 3 и 4 (последние два)

Методы класса Array

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

Метод рор()

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

массив. рор( )

Не знаю почему, но процесс «выталкивания» массива у меня всегда вызывает улыбку. Тем не менее метод pop ( ) уменьшает на единицу значение переменной массива length и возвращает значение удаляемого элемента. Например:

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

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

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

Метод shift!)

Помните метод unshi ft ( ), который применяется для добавления элемента в начало массива? Познакомьтесь с его близким другом — методом shif t ( ), который удаляет элемент с начала массива:

массив. shifti )

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

var sports:Array = ["quake", "snowboarding". "inline skating"]: trace(sports. shift( )); // Выводит: quake

// Массив sports теперь выглядит так:

// ["snowboarding". "inline skating"] trace(sports. shift( )); // Выводит: snowboarding

// Массив sports теперь выглядит так:

// ["inline skating"]

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

Метод splicef)

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

var letters:Array = ["a", "b". "с", "d". "е". "f"];

// Удаляем элементы с индексами 1. 2 и 3. оставляя ["а", "е". "f"]

letters. spliced. 3);

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

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

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

массив. toStnugi )

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