Массивы и как их готовить! (а так же циклы)

Всем привет!

Хочу внести небольшую ясность по поводу массивов и как с ними управляться. Во-первых - что такое массив? Массив - это упорядоченный набор данных, которые имеют свой идентификатор (индекс). Примером массива может служить список имен:

1. Вася
2. Петя
3. Коля
n. Люда

То есть, каждая строчка здесь имеет свой номер и свое значение.



Примерно я думаю понятно.

Самым главным правилом во всех массивах является то, что они все начинаются с индекса (номера) 0!!! 

То есть, правильно писать:

0.Вася
1.Петя
2.Коля
n-1.Люда

Вот и все жизненное представление массивов.

В программировании массивы бывают разных видов (если это можно назвать так =):

0. Индексный массив
1. Ассоциативный массив

А эти массивы также делятся на одномерные и многомерные.

Начнем с индексных. Пример индексного массива указан выше. Его принципы – числовой порядковый номер – индекс, и значение.

 Ассоциативный массив – это массив полностью по структуре соответствует индексному – но значения каждого индекса является строчкой. На примере это будет выглядеть как-то так (немного дико, но поверьте – оч удобно):

Петров. Вася
Иванов. Петя
Сидоров. Коля
Гречишкина. Люда

На самом деле в ActionScript 2/3, механизм создания массивов что индексных что ассоциативных одинаков! То есть скрипту пофиг какого типа данные вы впихнете в индекс и в значение =)! Можно образно сказать что массив – цепочка контейнеров, с номером!

По поводу размерности массивов. Как я говорил массивы бывают одномерные и многомерные. Одномерный массив – это строка данных, имеющая одну «координату» индекс, например [1]Вася, [2]Петя, [3]Коля, [n]Люда.

Многомерный массив может иметь 2 и больше «координаты» индекса. То есть, на наглядном примере можно представить двухмерный массив как таблицу:

[1][1]Коля [1][2]Вася [1][3]Петя
[2][1]Ира [2][2]Леня [2][3]Надя
[3][1]Люда [3][2]Инна [3][3]Антон

Короче как-то так =) Ну а теперь естественно давайте поговорим о практической стороне вопроса =) В языках программирования семейства ActionScript, массив словом Array.

var ourMassiv:Array = new Array();

Строка выше, говорит компилятору что мы хотим создать массив с именем ourMassiv. В ActionScript существует одна интересная возможность – при создании массива, не указывать его размер (длину). Это я вам скажу очень удобная штука! В большинстве языков такая возможность отсутствует и по этому приходится мучатся и создавать динамические массивы в памяти… А в ActionScript все массивы являются динамическими – не нормированными!

Ладно, продолжим практику. Вот создали мы массив и нам нужно в него что-то записать. Для этого мы берем и пишем:

ourMassiv[0] = “Вася”;
ourMassiv[1] = “Петя ”;
ourMassiv[2] = “Коля ”;
ourMassiv[3] = “Люда ”;

Ничего не напоминает? Если нет –читаем еще раз все сначала.

Так же можно инициализировать ( добавить элементы в массив) при его объявлении:

var colors:Array = [“red”,”green”,”bleu”];

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

var matrix:Array = new Array();
matrix[0] = new Array();
matrix[1] = new Array();
matrix[2] = new Array();

Примерно так. После такого «объявления», с массивом можно работать так:

matrix[0][0] = “Коля”;
matrix[0][1] = “Вася”;
matrix[0][2] = “Петя ”;

matrix[1][0] = “Ира”;
matrix[1][1] = “Леня”;
matrix[1][2] = “Надя”;

matrix[2][0] = “Люда”;
matrix[2][1] = “Инна”;
matrix[2][2] = “Антон”;

Кстати, название matrix для массива в предыдущем примере выбрано не случайно, потому что двухмерный массив и является матрицей (более детальнее читайте учебник высшей математики =).

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

Все это конечно красиво и очень даже изысканно! Но нафига нам массивы, если у нас есть переменные? А массивы нам нужны для того чтобы хранить и обрабатывать в них некие данные (в количестве больше 1шт) которые имеют (необязательно) какие-то сродные свойства или назначения. Например, у нас есть некое количество чисел которое нужно пересортировать. Мы берем и помещаем их в массив, и легким движением руки их там сортируем.

Но их же много этих элементов массива скажете вы, согласен много. И здесь нам на помощь приходят циклы!

Если кто не знает, то Цикл – это механизм, помогающий что-то сделать несколько раз, то есть цикл умеет повторять!

Немного напишу о циклах, хотя они и не относятся напрямую к массивам: Циклы бывают с указанием количества итераций(повторов), условные и «пока не надоест» (не знаю как они называются точно =)

Цикл с указание количества итераций: for 

Конструкция примерно такова:

for(var i:int = 0; i<10; i++)
{
// код того что мы хотим повторять
trace(i);
}

Параметры такого цикла таковы (с лева на право):

var i:int = 0 – указываем индикатор нашего цикла, и задаем ему начальное значение и ставим точку с запятой «;».

i<10 – указываем с помощью знаков больше или меньше условие, при котором цикл будет выполнятся. То есть, пока i меньше 10 и ставим точку с запятой.

i++ - указываем действие, при котором наш индикатор цикла будет изменяться. В нашем случае это инкремент (увеличение на единицу).

Вот а если глянуть в целом на конструкцию выше, то она гласит что, при первой итерации нашей переменной-индикатору i присвоится ноль, проверится условие при котором нужно продолжать вращать, если условие выполняется, выполняем код внутри операторных скобок, увеличиваем наш индикатор на единицу, и снова все сначала. Но когда наш индикатор станет равным 10, условие для продолжения не выполнится, и наш цикл прервется! Примерно так. В данном цикле в качестве условия можно использовать:

> больше
< меньше
>= больше или равно
<= меньше или равно

Условный цикл, он же while. Данный цикл имеет две вариации, их я покажу сразу на примере конструкции:

var a:Number = 3;
while (a<=10)
{
// выполняем то что нужно повторять
a++;
}

И конструкция:

do{
//выполняем то что нужно повторять
a++;
}while(a<10)

Разница между этими конструкциями такова: первая сразу проверяет а потом делает, вторая наоборот – делает а уже потом проверяет.

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

Кстати, такая как говориться оплошность, зачастую использовалась во времена однозадачных ОС при написании программ. То есть, делаем «вечный» цикл, по типу while(true) и ставим оператор чтения номера команды (пример – DOS fdisk), юсер вводит номер команды и мы выполняем некую функцию и опять возвращаемся к списку команд и оператору чтения! Правда в таких случаях последней из списка команд была функция выхода из программы – программного прерывания цикла.

В условиях данного цикла можно применять кроме описанных выше логических операторов, оператор логического отрицания «!». То есть логическое НЕ.

!= не равно
== равно

var n:Boolean = false;
var a:Number = 35;
while(n!=true)
{
a--;
if(a=<0)
{
n = true;
}
}

А теперь самое вкусное: и «пока не надоест». Это вид цикла, очень стиль упростил нам жизнь при разборе больших неясных массивов, XML документов, дочерних объектов у нашего MovieClip-а итд, итп.

Это цикл for each. Данный вариант цикла работает только тогда когда есть что перебирать, например наш массив, созданный выше.

Выглядит это все примерно так:

var ourMassiv:Array = new Array();
ourMassiv[0] = “Вася”;
ourMassiv[1] = “Петя ”;
ourMassiv[2] = “Коля ”;
ourMassiv[3] = “Люда ”;

for each(var str:String in ourMassiv)
{
//делаем то что нужно делать с каждым выбранным элементом
trace(str);
}

Работа приведенного примера такова: в переменную-контейнер str копируем первый элемент цикла и в теле делаем с ним что захотим, при второй итерации в str копируется второй элемент цикла и так пока не надоест – то есть пока не достигнем конца нашего массива.

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

Вот это все что я хотел сказать о циклах. А теперь продолжим о массивах.

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

 Вот наверное и все что можно сказать о массивах! Благодарю за внимание! Кому что не ясно – пишите в коментарии, и мы все обсудим.