Приложение. Основы ActionScript

var x = 12, y;

trace ( y );

trace ( z );

var y = null;

var x = 1;    // число
x = "Ку-ку!"; // строка
x = false;    // логическое значение

var x:Number = 0,
    y:String = "qq",
    b:Boolean = false;

var s1:String = "qq1", s2:String = 'qq2';

var b:Boоlean = false;
b = true;
b = (a < 2);

var x:Number = 1;
x = "Ку-ку!";

_global.x = 12;

mc.x = 1;
_root.x = 12;
_parent.x = 123;

a = 4*(c + 2) + 3 / (r - 4*w) + d % 3;

no = 20;
s = "Вася " + "пошёл гулять.";
qq = "Объект" + no;

i ++; k --;

i = i + 1;  k = k  - 1;

a += 20;   b -= c - d;   c *= a + b;   d /= 2*c;   f %= 12;

a = a + 20;
b = b - (c - d);
c = c * (a + b);
d = d / (2 * c);
f = f % 12

var car = new Object();
car.v = 10;
car.year = 1998;

var obj = new Object();

obj2 = obj;

var obj2 = new Object();
for ( prop in obj ) obj2[prop] = obj[prop];

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

Массив из трех элементов можно объявить и заполнить так:

A = new Array(3);
A[0] = 12;
A[1] = 4.56;
A[2] = "Ку-ку!";

или так:

A = new Array (12, 4.56, "Ку-ку!");

или так:

A = [12, 4.56, "Ку-ку!"];

При работе с массивами, как и с другими объектами (кроме чисел, строк и логических переменных), есть один тонкий момент. Рассмотрим пример кода:

A = [1, 2, 3];
B = A;
B[1] = 99;
trace(A);

Здесь создается массив A, затем он копируется в массив B. Потом изменяется B[1] и массив A выводится в окно Output. Вроде бы массив A не должен измениться, однако мы увидим в окне Output строчку:

1,99,3

Почему же изменился массив A? Дело в том, что оператор B=A НЕ создает новый массив, а просто копирует в B адрес массива A, то есть A и B обращаются к одной области памяти. Поэтому, изменив B, мы изменили и A. Чтобы действительно создать копию массива, нужно заменить оператор B=A на код

B = new Array();
for(i=0; i<A.length; i++) B[i] = A[i];

Здесь используется встроенное свойство length объекта Array — длина массива.

Элементом массива может быт другой массив:

A = new Array();
A[0] = [1, 2, 3];
A[1] = [4, "Вася"];
A[2] = [true, "qq", 4];

В таком (двухмерном) массиве каждый элемент имеет два индекса. Например, A[1][0] имеет значение 4, а A[2][1] — это символьная строка qq.

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

• объединение массивов, в результате строится новый массив:

  C = A.concat ( B, 12 );

  в массиве C записаны все элементы массива A, затем все элементы массива B, а затем — число 12;
• добавление элементов в начало массива

  A.unshift ( 3, 4, "qq" );

  и в конец массива

  A.push ( 3, 4, "qq" );

• удаление элемента с начала массива

  x = A.shift();

  и с конца массива

  x = A.pop();

  удаленный элемент записывается в переменную x;
• перестановка элементов массива в обратном порядке:

  A.reverse();

• извлечение части массива в новый массив:

  B = A.slice ( n1, n2 );

  здесь в массив B копируются все элементы массива A с номерами от n1 до n2 включительно;
• сортировка массива

  A.sort();

  По умолчанию элементы массива сортируются по возрастанию в алфавитном порядке; если надо сортировать числа, используется форма

  A.sort ( Array.NUMERIC );

  Для сортировки по убыванию нужно указать еще параметр Array.DESCENDING:

  A.sort ( Array.NUMERIC + Array.DESCENDING );

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

  A = [12, 328, 731];
  A.sort ( cmpFun );
  function cmpFun(a, b) {
   return (a%10) - (b%10);
  }
  trace ( A );

  Массив будет отсортирован по возрастанию последней цифры:

  731,12,328

  потому что a%10 — это остаток от деления числа a на 10 или его последняя цифра.

Условные операторы используются для выбора одного из двух вариантов. Полная форма оператора:

if ( условие ) {
  ... // блок if
} else {
  ... // блок else
}

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

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

if ( условие ) {
  ... // блок if
}

Если внутри фигурных скобок стоит всего один оператор, скобки можно не ставить.

Простейшие условия — это отношения

• <, <=, >, >= — меньше, меньше или равно, больше, больше или равно;
• == равно;
• != не равно.

Например,

if ( x < 0 ) {
  trace ( "x отрицательный" );
} else {
  if ( x == 0 ) {
    trace ( "x равен 0" );
  } else {
    trace ( "x положительный" );
  }
}

Здесь используется вложенный условный оператор (один внутри другого).

Сложные условия образуются из простых (отношений) с помощью логических операций:

• ! — «не» (отрицание, обратное условие);
• && — «и» (одновременное выполнение условий);
• || — «или» (требуется выполнение хотя бы одного из условий).

Операции выполняются в следующем порядке:

• действия в скобках;
• операция «не»;
• отношения;
• операция «и»;
• операция «или».

Этот порядок называется приоритетом (старшинством) логических операций. Например

a = 1; b = 2; c = 3;
if ( a < b  &&  a < c )
  trace ( "a - наименьшее" );
if ( b > a  ||  b > c )
  trace ( "b - не наименьшее" );

Оба условных оператора здесь сработают и в окно Output будут выведены оба сообщения.

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

Цикл с известным числом шагов (или цикл с переменной) имеет вид

for ( начальные значения; условие; изменения )  {
  ...  // тело цикла
}

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

В цикле выполняются все операторы, расположенные внутри фигурных скобок (в теле цикла). Если там всего один оператор, скобки можно не ставить. Цикл работает до тех пор, пока условие в заголовке цикла не станет ложным.

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

В цикле

for ( i=0; i<10; i++ )
  trace ( i );

в окно Output выводятся в столбик числа от 0 до 9 включительно. Действительно:

• при входе в цикл выполняется оператор i=0;
• в конце каждого шага цикла переменная i увеличивается на 1 (оператор i++);
• цикл выполняется пока i<10, то есть, закончится при i=10 (это значение не будет выведено).

Переменная i в таком цикле называется переменной цикла.

Цикл с переменной часто используют для обработки массивов, при этом i обозначает номер элемента:

A = [1, 2, 3];
for ( i=0; i<A.length; i++ )
  A[i] *= 2;

Этот цикл умножает все элементы массива A на 2.

Цикл с условием начинается ключевым словом while, после которого в скобках записывают условие продолжения работы цикла:

while ( условие ) {
  ...
}

Цикл заканчивается, когда условие становится ложным. Например:

i = 0;
while ( i < 10 ) {
  trace ( i );
  i ++;
}

Этот цикл, так же, как и в предыдущем примере, выводит числа от 0 до 9.

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

i = 0;
while ( i < 10 ) {
  trace ( i ); // зацикливание!!!
}

Проверка условия стоит в начале цикла (цикл с предусловием), поэтому он ни разу не выполняется, если условие неверно при входе в цикл.

Если в теле цикла стоит один оператор, фигурные скобки можно не ставить.

Цикл с постусловием отличается тем, что проверка условия выполняется после очередного шага:

do {
  ...
}
while ( условие );

Такой цикл всегда выполняется хотя бы один раз.

Особый вид цикла используется для перечисления всех свойств объекта:

for ( var переменная in объект ) {
  ...
}

В этом цикле переменная «проходит» все свойства объекта, ее значение на каждом шаге — название очередного свойства. Например, цикл:

var obj = new Object();
obj.x = 10;
obj.y = 20;
for ( var prop in obj ) {
   trace ( prop + " = " + obj[prop]);
}

выведет в окно Output названия свойств, x и y, и их значения:

x = 10
y = 20

Для изменения порядка выполнения цикла используются два оператора:

• break — досрочный выход из цикла;
• continue — переход в конец цикла.

Например, цикл

for ( i=0; i<10; i++ ) {
  trace ( i );
  if ( i >= 3 ) break;
}

выполнится только 4 раза.

Другой цикл

for ( i=0; i<10; i++ ) {
  if ( i >= 3 ) continue;
  trace ( i );
}

выполнится 10 раз, но в окно Output будут выведены только числа 0, 1 и 2.

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

• не нужно несколько раз писать одинаковый код, рискуя ошибиться при переписывании;
• сокращается длина программы;
• при отладке изменения нужно вносить только в одно место.

Функции объявляются с помощью слова function:

function qq() {
  ...
}

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

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

function qq ( x ) { ... }
function ww ( x:Number, s:String ) { ... }

Функция qq принимает один параметр, его тип может быть любой. Функция ww принимает два параметра, причем их типы жестко заданы: первый — число, второй — символьная строка.

Функция может возвращать результат (число, строку, логическое значение и т.д.) с помощью оператора return. Например:

function Sum ( x, y ) {
  var s = x + y;
  return s; // или return x + y;
}

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

w = Sum ( 2, 3 );
trace ( w );

Функции, так же, как и переменные, бывают трех типов:

• функции временной шкалы (функции клипа), которые связаны с клипом и могут рассматриваться как его методы;
• глобальные функции, которые можно использовать без указания адреса из любого места в программе;
• локальные функции, которые объявляются внутри другой функции.

Чаще всего используют функции клипов. Например, если в одном из кадров главной временной шкалы объявлена функция

function qq () { ... }

с другой временной шкалы (из обработчика другого клипа) она вызывается как _root.qq().

Ту же функцию можно объявить по-другому:

qq = function() { ... }

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

qq = function () { trace(1); }
qq();
qq = newFunc;
qq();
function newFunc () { trace ( 2 ); }

Если в первый раз при выполнении оператора qq() вызывается первая (безымянная) функция, то второй раз — функция newFunc. Заметим, что после присваивания qq=newFunc к первой функции уже никак не обратиться — ее адрес потерян.

Глобальные функции объявляются с помощью слова _global:

_global.qq = function ( x ) { ... }

Эту функцию можно вызывать просто как qq() из любого места программы, в том числе из обработчиков событий клипов.

Локальные функции объявляются внутри другой функции и известны только там. В примере

trace(b);
a();
function a() {
  function b() {}
  trace(b);
}

функция b — локальная для функции a, поэтому первый вызов trace(b) даст результат undefined (не определено), а второй (изнутри функции a) — [type Function], то есть, найдена функция с таким именем.

Обработчики событий — это специальные методы кнопок и клипов. Например, вместо определения обработчика события on(release) можно записать адрес нужной функции в свойство onRelease кнопки или клипа.

Пусть на текущем монтажном столе есть кнопка с именем btn (имя кнопки задается в левой части на панели Properties). Разберем такой код:

btn.onRelease = function () {
   trace("q");
   btn.onRelease = second;
}
function second() {
   trace("qq");
   btn.onRelease = null;
}

Вначале обработчик события кнопки — это безымянная функция, которая выводит на экран букву q и, кроме этого, меняет обработчик события на адрес функции second.

При втором щелчке вызывается функция second, которая выводит две буквы q и уничтожает обработчик, записывая в него null. На последующие щелчки кнопка не будет реагировать.