function functionName(parameter0, parameter1, ...rest){ 
	// инструкция(и) 
} 

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

При использовании с другими параметрами объявление параметра ... (rest) должно быть последним. Массив параметра ... (rest) заполняется, только если число аргументов, переданных функции, превышает число других параметров.

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

Использование данного параметра делает объект arguments недоступным. Хотя параметр ... (rest) обеспечивает ту же функциональность, что и массив arguments и свойство arguments.length, он не обеспечивает функциональность, схожую с функциональностью arguments.callee. Убедитесь, что использовать arguments.callee не требуется, перед тем, как использовать параметр ... (rest).

package {
    import flash.display.MovieClip;
    
    public class RestParamExample extends MovieClip {
        public function RestParamExample() {
            traceParams(100, 130, "two"); // 100,130,two
            trace(average(4, 7, 13));     // 8
        }
    }
}


function traceParams(... rest) {
     trace(rest);
 }
 
function average(... args) : Number{
    var sum:Number = 0;
    for (var i:uint = 0; i < args.length; i++) {
        sum += args[i];
    }
    return (sum / args.length);
}

См. также

Определяет методы и те свойства базовых классов ActionScript, которые являются фиксированными свойствами, а не свойствами прототипа. При установке параметра компилятора "-as3" на значение true (что является установкой по умолчанию в Flex Builder 2) пространство имен AS3 автоматически открывается для всех базовых классов. Это значит, что экземпляр базового класса будет использовать фиксированные свойства и методы вместо версий этих свойств и методов, прикрепленных к объекту-прототипу этого класса. Использование фиксированных свойств обычно обеспечивает лучшую производительность, но в ущерб обратной совместимости со спецификацией языка ECMAScript редакции 3 (ECMA-262).

См. также

Используется в цикле (for, for..in, for each..in, do..while или while) или в блоке инструкций, связанных с определенным блоком внутри инструкции switch. При использовании в цикле инструкция break предписывает Flash пропустить оставшуюся часть тела цикла, остановить процесс организации циклов и выполнить инструкцию, следующую за инструкцией цикла. При использовании в инструкции switch инструкция break предписывает Flash пропустить оставшиеся инструкции в блоке case и перейти к первой инструкции, следующей за закрывающей инструкцией switch.

Во вложенных циклах инструкция break только пропускает оставшуюся часть выполняемого цикла, не останавливая выполнение всей серии вложенных циклов. Для выхода из всей серии вложенных циклов используйте label или try..catch..finally.

Инструкция break может иметь дополнительную метку, которая должна совпадать с меткой внешней инструкции. Использование метки, не совпадающей с меткой внешней инструкции, является синтаксической ошибкой. Помеченные инструкции break можно использовать для выхода из нескольких уровней вложенных инструкций цикла, инструкций switch или инструкций block. Для примера см. описание инструкции label.

var i:int = 0;
while (true) { 
    trace(i); 
    if (i >= 10) { 
        break; // это завершит цикл 
    } 
    i++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

См. также

case jumpTarget: statements

Определяет цель перехода для инструкции switch. Если параметр jumpTarget приравнивается параметру expression инструкции switch при помощи оператора строгого равенства (===), проигрыватель Flash Player выполняет инструкции в параметре statements до появления инструкции break или до окончания инструкции switch.

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

Примечание. Всегда заканчивайте параметр statements инструкцией break. Если не включить инструкцию break в параметр statements, продолжится выполнение следующей инструкции case вместо выхода из инструкции switch.

var thisMonth:int = new Date().getMonth(); 
switch (thisMonth) { 
    case 0 : 
        trace("January"); 
        break; 
    case 1 : 
        trace("February"); 
        break; 
    case 5 : 
    case 6 : 
    case 7 : 
        trace("Some summer month"); 
        break; 
    case 8 : 
        trace("September"); 
        break; 
    default : 
        trace("some other month"); 
}

См. также

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// определение класса
}

Определяет класс, который позволяет создавать экземпляры объектов, применяющие заданные общие методы и свойства. Например, при разработке системы отслеживания счетов можно создать класс Invoice, определяющий все методы и свойства, используемые каждым счетом. Затем при помощи команды new Invoice() можно создать объекты Invoice.

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

Имя внешне видимого класса должно совпадать с именем исходного файла ActionScript, содержащего этот класс. Имя исходного файла должно состоять из имени класса с расширением файла .as. Например, если класс имеет имя Student, файлу, определяющему этот класс, необходимо присвоить имя Student.as.

Определения классов вкладывать нельзя; т. е. нельзя определить дополнительные классы в определении другого класса.

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

Для указания на то, что объекты могут добавлять динамические свойства и получать к ним доступ во время выполнения, вставьте перед инструкцией класса ключевое слово dynamic. Для объявления того, что класс реализует интерфейс, используйте ключевое слово implements. Для создания подклассов класса используйте ключевое слово extends. (Класс может расширить только один класс, но реализовывать несколько интерфейсов.) Ключевые слова implements и extends можно использовать в одной инструкции. Следующие примеры иллюстрируют типичное использование ключевых слов implements и extends:

class C implements Interface_i, Interface_j // OK 
class C extends Class_d implements Interface_i, Interface_j // OK 
class C extends Class_d, Class_e // not OK 

// Filename Plant.as 
package {
  public class Plant { 
    // Определите имена и типы свойств 
    private var _leafType:String; 
    private var _bloomSeason:String; 
    // Следующая строка представляет собой конструктор 
    // так как его имя совпадает с именем класса 
    public function Plant(param_leafType:String, param_bloomSeason:String) { 
        // Присвойте передаваемые значения свойствам при создании нового объекта Plant 
        _leafType = param_leafType; 
        _bloomSeason = param_bloomSeason; 
    } 
    // Для возврата значений свойств создавайте методы, так как 
    // прямые ссылки на свойство класса не рекомендуются 
    public function get leafType():String { 
        return _leafType; 
    } 
    public function get bloomSeason():String { 
        return _bloomSeason; 
    } 
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Подтвердите правильную передачу параметров 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

См. также

const identifier = value 

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

Константу можно строго типизировать, вставив двоеточие (:), за которым следует тип данных.

const MIN_AGE:int = 21;
MIN_AGE = 18; // error

const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); // операции с массивом допустимы
product_array = ["Other"];  // присваивание является ошибкой
trace(product_array); 

См. также

continue [label]

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

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

var i:int = 0; 
while (i < 10) { 
    if (i % 3 == 0) { 
        i++; 
        continue; 
    } 
    trace(i); 
    i++; 
}

В цикле for инструкция continue также используется для пропуска оставшейся части тела цикла. В следующем примере, если i % 3 равно 0, инструкция trace(i) пропускается:

 
for (var i:int = 0; i < 10; i++) { 
    if (i % 3 == 0) { 
        continue; 
    } 
    trace(i); 
}

См. также

default: statements 

Определяет условие по умолчанию для инструкции switch. Инструкции выполняются, если параметр expression инструкции switch не приравнивается (при помощи операции строго равенства [===]) ни к одному из параметров expression, следующих за ключевыми словами case в данной инструкции switch.

Для инструкции switch не требуется инструкция условия default. Инструкция условия default не обязательно должна быть последней в списке. При использовании инструкции default за пределами инструкции switch выдается ошибка и сценарий не компилируется.

var dayOfWeek:int = new Date().getDay(); 
switch (dayOfWeek) { 
    case 1 : 
        trace("Monday"); 
        break; 
    case 2 : 
        trace("Tuesday"); 
        break; 
    case 3 : 
        trace("Wednesday"); 
        break; 
    case 4 : 
        trace("Thursday"); 
        break; 
    case 5 : 
        trace("Friday"); 
        break; 
    default : 
        trace("Weekend"); 
}

См. также

Директива default xml namespace задает пространство имен по умолчанию для объектов XML.

Если default xml namespace не задана, пространством имен по умолчанию будет пространство имен без имени (в качестве URI будет задана пустая строка). Областью видимости default xml namespace является блок функций, как и в случае с областью видимости переменной.

var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
        
var x1:XML = <test1 />;
trace("x1 ns: " + x1.namespace());
            
scopeCheck();    

var x2:XML = <test2 />;
trace("x2 ns: " + x2.namespace());
        
function scopeCheck(): void {
    
    var x3:XML = <test3 />;
    trace("x3 ns: " + x3.namespace());
                
    var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
    default xml namespace = nsDefault2;
            
    var x4:XML = <test4 />;
    trace("x4 ns: " + x4.namespace());

}

Результатом trace() в данном случае является следующее:

x1 ns: http://www.example.com/namespaces/
x3 ns: 
x4 ns: http://schemas.xmlsoap.org/soap/envelope/
x2 ns: http://www.example.com/namespaces/

var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
            
var x1:XML = <test1 />;

trace(x1.namespace());
    // http://www.example.com/namespaces/

var x2:XML = <test2 xmlns = "http://www.w3.org/1999/XSL/Transform/" />;
trace(x2.namespace());
    // http://www.w3.org/1999/XSL/Transform/

var x3:XML = <test3 xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" />;
trace(x3.namespace());
    // http://www.example.com/namespaces/

См. также

do { statement(s) } while (condition)

Работает аналогично циклу while за исключением того, что инструкции выполняются однократно перед начальным вычислением условия. Впоследствии инструкции выполняются, только если условие принимает значение true.

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

Если условие всегда принимает значение true, цикл do..while становится бесконечным. При создании бесконечного цикла возникают проблемы с проигрывателем Flash Player, которые ведут к появлению предупреждающего сообщения или сбою в работе проигрывателя. По возможности используйте цикл for, если известно количество раз выполнения цикла. Хотя циклы for легко читаются и поддаются отладке, они не могут заменять циклы do..while во всех случаях.

var myVar:Number = 0; 
do { 
    trace(myVar); 
    myVar++; 
} 
while (myVar < 5); 
/*
0 
1 
2 
3 
4
*/

См. также

dynamic class className { // определение класса указывается здесь }

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

Если класс защищен (не является динамическим), то при попытке определить или задать свойства класса возникает ошибка. Если компилятор работает в строгом режиме и вы указали тип данных при создании экземпляров, то при попытках добавить свойства в защищенные объекты возникнет ошибка компилятора; в противном случае - ошибка этапа выполнения.

Атрибут dynamic не наследуется подклассами. При расширении динамического класса подкласс становится динамическим, только если он объявлен с атрибутом dynamic.

package {

    dynamic class Expando  {
    }
    
    class Sealed {
    }
}

var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // ошибка

См. также

if (condition) { 
	// инструкция(и)
} 
else {
	// инструкция(и)
}

Задает инструкции, которые выполняются, если условие в инструкции if возвращает значение false. Фигурные скобки ({}), в которых заключены инструкции для выполнения инструкцией else, не требуются при выполнении только одной инструкции.

if (age_txt.text>=18) { 
    trace("welcome, user"); 
} 
else { 
    trace("sorry, junior"); 
    userObject.minor = true; 
    userObject.accessAllowed = false;
}

if (age_txt.text>18) { 
    trace("welcome, user");
} 
else trace("sorry, junior");

if (score_txt.text>90) { 
    trace("A"); 
} 
else if (score_txt.text>75) { 
    trace("B"); 
} 
else if (score_txt.text>60) { 
    trace("C"); 
} 
else { 
    trace("F"); 
}

См. также

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

Определяет класс, который является подклассом другого класса. Подкласс наследует все методы, свойства, функции и т. д., определенные для суперкласса. Классы с пометкой final не могут быть расширены.

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

В следующем примере показано содержимое файла с именем Vehicle.as, который определяет класс Vehicle.

package {
    class Vehicle { 
        var numDoors:Number; 
        var color:String; 
        public function Vehicle(param_numDoors:Number = 2, param_color:String = null) { 
            numDoors = param_numDoors; 
            color = param_color; 
        } 
        public function start():void { 
            trace("[Vehicle] start"); 
        } 
        public function stop():void { 
            trace("[Vehicle] stop"); 
        } 
        public function reverse():void { 
            trace("[Vehicle] reverse"); 
        } 
    }    
}

package {

    public class Car extends Vehicle { 
        var fullSizeSpare:Boolean; 
        public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
            numDoors = param_numDoors; 
            color = param_color; 
            fullSizeSpare = param_fullSizeSpare; 
        } 
        public function activateCarAlarm():void { 
            trace("[Car] activateCarAlarm"); 
        } 
        public override function stop():void { 
            trace("[Car] stop with antilock brakes"); 
        } 
    }
}

var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // [Vehicle] start 
myNewCar.stop(); // [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm

Подкласс класса Vehicle можно также записать с использованием инструкции super, которую подкласс может использовать для доступа к конструктору суперкласса. В следующем примере показан третий файл ActionScript, с именем Truck.as, расположенный в том же каталоге. Класс Truck использует инструкцию super в конструкторе и в переопределенном методе reverse().

package {
    class Truck extends Vehicle {
        var numWheels:Number;
        public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
            super(param_numDoors, param_color); 
            numWheels = param_numWheels; 
        } 
        public override function reverse():void { 
            beep();
            super.reverse();
        } 
        public function beep():void { 
            trace("[Truck] make beeping sound"); 
        } 
    }
}

var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // [Vehicle] stop

См. также

false

Значение типа Boolean, представляющее false. Значением типа Boolean является либо true, либо false; противоположностью false является true.

Если при автоматическом преобразовании типов данных значение false преобразуется в число, оно становится 0; при преобразовании значения false в строку, оно принимает вид "false".

Примечание. Строка "false" преобразуется в логическое значение true.

var bool1:Boolean = Boolean(false);

// преобразует в число 0
trace(1 + bool1); // выводит 1

// преобразует в строку
trace("String: " + bool1); // выводит String: false

В следующем примере показано, что строка "false" преобразуется в логическое значение true:

trace(Boolean("false")); // true

if ("false") {
    trace("condition expression evaluated to true");
}
else {
    trace("condition expression evaluated to false");
}
// condition expression evaluated to true

См. также

final function methodName() { 
	// ваши инструкции здесь 
}
final class className {}

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

См. также

Определяет методы класса Proxy. Методы класса Proxy находятся в собственном пространстве имен во избежание конфликтов имен в случаях, когда подкласс Proxy содержит методы экземпляра с именами, которые совпадают с именами методов класса Proxy.

См. также

for ([init]; [condition]; [next]) { 
	// инструкция(и)
}

Вычисляет однократно выражение init (инициализация), затем запускает циклическую последовательность. Циклическая последовательность начинается с вычисления выражения condition. Если выражение condition принимает значение true, выполняется инструкция statement и вычисляется выражение next. Циклическая последовательность затем начинается снова с вычисления выражения condition.

Фигурные скобки ({}), в которых заключен блок инструкций для выполнения инструкцией for, не требуются при выполнении только одной инструкции.

var my_array:Array = new Array(); 
for (var i:Number = 0; i < 10; i++) { 
    my_array[i] = (i + 5) * 10;  
} 
trace(my_array); // 50,60,70,80,90,100,110,120,130,140 

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) { 
    sum += i; 
} 
trace(sum); // 5050

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
    sum += i; 
trace(sum); // 5050

См. также

for (variableIterant:String in object){ 
	// инструкция(и)
} 

Выполняет итерацию через динамические свойства объекта или элементы массива и выполняет инструкцию statement для каждого свойства или элемента. Свойства объекта не хранятся в определенном порядке, поэтому могут отображаться в произвольной последовательности. Фиксированные свойства, например переменные и методы, определенные в классе, не перечисляются в инструкции for..in. Для получения списка фиксированных свойств используйте функцию describeType(), которая находится в пакете flash.utils.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var prop in myObject) { 
    trace("myObject."+prop+" = "+myObject[prop]); 
} 
/*
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var name in myObject) { 
    if (typeof (myObject[name]) == "string") { 
        trace("I have a string property named "+name); 
    } 
}
/*
I have a string property named city
I have a string property named firstName
*/

См. также

for each (variableIterant in object){ 
	// инструкция(и)
} 

Выполняет итерацию через элементы коллекции и выполняет инструкцию statement для каждого элемента. Будучи введенной как часть расширений языка E4X, инструкцию for each..in можно использовать не только для объектов XML, а также для объектов и массивов. Инструкция for each..in выполняет итерацию только через динамические, а не фиксированные, свойства объекта. Фиксированным является свойство, являющееся частью определения класса. Для использования инструкции for each..in с экземпляром класса, определенного пользователем, необходимо объявить класс с атрибутом dynamic.

В отличие от инструкции for..in, инструкция for each..in выполняет итерацию через значения свойств объекта, а не их имена.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
    trace(item); 
} 
/*
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
    trace(item); 
/*
one
two
three
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
    if (item is String) {  
        trace("I have a string property with value " + item); 
    } 
}

/*
I have a string property with value Tara
I have a string property with value San Francisco
*/

var doc:XML = 
        <body>
            <p>Hello</p>
            <p>Hola</p>
            <hr />
            <p>Bonjour</p>
        </body>;
for each (var item in doc.p) {
    trace(item);
}

/*
Hello
Hola
Bonjour
*/

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// инструкция(и) 
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// инструкция(и) 
} 

Составляет набор инструкций, заданный пользователем для выполнения определенной задачи. Можно определить функцию в одном местоположении и вызывать ее из различных сценариев в SWF-файле. При определении функции можно также задать для нее параметры. Параметры являются местозаполнителями для значений, которыми оперирует функция. При каждом вызове функции ей можно передавать различные параметры, т. е. использовать функцию в различных ситуациях.

Используйте инструкцию return в блоке statement(s) функции для того, чтобы функция сгенерировала, или возвратила, значение.

Применение 1: Ключевое слово function можно использовать для определения функции с заданным именем, параметрами и инструкциями. При вызове функции сценарием выполняются инструкции, заложенные в определении функции. Допускается опережающая ссылка; в рамках одного сценария функцию можно объявить после ее вызова. Последующее определение функции заменяет любое предыдущее определение этой функции. Этот синтаксис можно использовать там, где разрешается выполнение инструкции.

Применение 2: Инструкцию function можно также использовать для создания анонимной функции и возврата ссылки на нее. Этот синтаксис используется в выражениях и особенно полезен для установки методов объектов.

Для дополнительной функциональности в определении функции можно использовать объект arguments. Объект arguments обычно используется для создания функции, принимающей различное число параметров, и для создания рекурсивной анонимной функции.

function sqr(xNum:Number) { 
    return Math.pow(xNum, 2); 
} 
var yNum:Number = sqr(3); 
trace(yNum); // 9

var yNum:Number = sqr(3); 
trace(yNum); // 9 
function sqr(xNum:Number) { 
    return Math.pow(xNum, 2); 
}

См. также

function get property() : returnType{ 
	// ваши инструкции здесь 
}

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

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

Еще одним преимуществом получателей является то, что они могут переопределяться в подклассах, а свойства, объявленные при помощи ключевого слова var или const, не могут.

Получатель может использоваться совместно с установщиком для создания свойства чтения-записи. Для создания свойства только для чтения создайте получатель без соответствующего установщика. Для создания свойства только для записи создайте установщик без соответствующего получателя.

package {
    public class Team { 
        var teamName:String; 
        var teamCode:String; 
        var teamPlayers:Array = new Array(); 
        public function Team(param_name:String, param_code:String) { 
            teamName = param_name; 
            teamCode = param_code; 
        } 
        public function get name():String { 
            return teamName; 
        } 
        public function set name(param_name:String):void { 
            teamName = param_name; 
        }
    } 
}

var giants:Team = new Team("San Fran", "SFO"); 
trace(giants.name); 
giants.name = "San Francisco"; 
trace(giants.name); 
/*
San Fran San Francisco */

При трассировке giants.name метод получателя используется для возврата значения свойства.

См. также

if (condition) {
	// инструкция(и)
}

Вычисляет условие, по которому определяется следующая инструкция для выполнения. Если условие принимает значение true, проигрыватель Flash Player выполняет следующие за условием инструкции в фигурных скобках ({}). Если условие принимает значение false, проигрыватель Flash Player пропускает инструкции в фигурных скобках и выполняет инструкции, следующие за фигурными скобками. Используйте инструкцию if в сочетании с инструкцией else для создания логики ветвления в сценариях.

Фигурные скобки ({}), в которых заключены инструкции для выполнения инструкцией if, не требуются при выполнении только одной инструкции.

См. также

myClass implements interface01 [, interface02 , ...] 

Указывает на то, что класс реализует один или несколько интерфейсов. Если класс реализует интерфейс, в нем должны быть определены все методы, объявленные в интерфейсе. Любой экземпляр класса, реализующий интерфейс, относится к типу данных, определенному интерфейсом. В результате оператор is возвращает true, когда экземпляр класса является первым операндом, а интерфейс - вторым; более того, действует преобразование в тип данных и из типа данных, определенного интерфейсом.

Примечание. Для использования этого ключевого слова необходимо указать ActionScript 2.0 и Flash Player 6 или выше на вкладке Flash в диалоговом окне "Настройки публикации" FLA-файла. Это ключевое слово поддерживается только при его использовании во внешних файлах сценария, а не в сценариях, написанных на панели "Действия".

См. также

import packageName.className 
import packageName.*

Делает внешне определенные классы и пакеты доступными для пользовательского кода. Например, для использования в сценарии класса flash.display.Sprite необходимо его импортировать. Данное требование является отличием от предыдущих версий ActionScript, в которых директива import была необязательной.

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

 
import flash.display.Sprite; 

// только имя класса
var mySprite:Sprite = new Sprite();

// полное имя класса
var mySprite:flash.display.Sprite = new flash.display.Sprite();

Если необходимо получить доступ к нескольким классам в пакете, их все можно импортировать в одной инструкции, как показано в следующем примере:

import flash.display.*;

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

Если импортированный класс не использовать в сценарии, он не будет экспортирован как часть SWF-файла. Это значит, что можно импортировать большие пакеты, не заботясь о размере SWF-файла; байт-код, связанный с классом, включается в SWF-файл, только если этот класс действительно используется. Недостатком импортирования классов, которые не понадобятся, является повышение вероятности конфликта имен.

// В Кадре 1 файла FLA: 
import adobe.example.*; 
var myFoo:foo = new foo();

include "[path]filename.as"

Включает содержимое заданного файла, как если бы команды в файле были частью вызывающего сценария. Директива include вызывается во время компиляции. Следовательно, при внесении изменений в файл необходимо его сохранить и повторно скомпилировать SWF-файлы, в которых он используется.

 interface InterfaceName [extends InterfaceName ] {}

Определяет интерфейс. Интерфейсы - это типы данных, которые определяют набор методов; эти методы должны определяться любым классом, реализующим интерфейс.

Интерфейс подобен классу, но имеет следующие важные отличия:

• Интерфейсы содержат только объявления методов, а не их реализацию. Другими словами, каждый класс, реализующий интерфейс, должен обеспечить реализацию каждого метода, объявленного в интерфейсе.
• Определения методов интерфейса не могут иметь таких атрибутов, как public или private, но реализованные методы должны быть отмечены как public в определении класса, реализующего интерфейс.
• Несколько интерфейсов могут быть унаследованы интерфейсом, при помощи инструкции extends, или классом, при помощи инструкции implements.

В отличие от ActionScript 2.0, ActionScript 3.0 позволяет использовать методы получателя и установщика в определениях интерфейса.

См. также

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// ваши инструкции здесь 
}
[internal] class className{
	// ваши инструкции здесь 
}
[internal] namespace nsName

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

См. также

label: statement
label: {
    statements
}

Связывает инструкцию с идентификатором, ссылка на который может указываться при помощи инструкции break или continue. Во вложенных циклах инструкция break или continue, которая не ссылается на метку, может пропустить только оставшуюся часть выполняемого на тот момент цикла, а не всю серию циклов. Однако если инструкция, которая определяет всю серию циклов, имеет связанную метку, инструкция break или continue может пропустить всю серию циклов путем ссылки на эту метку.

Метки также позволяют выйти из блока инструкций. Нельзя вставить инструкцию break, которая не ссылается на метку, в блок инструкций, если этот блок инструкций не является частью цикла. Если блок инструкций имеет связанную метку, можно вставить инструкцию break, которая ссылается на эту метку, в блок инструкций.

outerLoop: for (var i:int = 0; i < 10; i++) {
    for (var j:int = 0; j < 10; j++) {
        if ( (i == 8) && (j == 0)) {
            break outerLoop;
        }
        trace(10 * i + j);
    }
}
/*
1
2
...
79
*/

В следующем примере показано использование метки с блоком инструкций. В следующем примере блок инструкций имеет метку foo, что позволяет инструкции break пропустить последнюю инструкцию в блоке:

foo: {
    trace("a");
    break foo;
    trace("b");
}
// a

См. также

namespace name [= uri]

Позволяет управлять видимостью определений. Предопределенные пространства имен включают в себя public, private, protected и internal.

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

• Во-первых, определите пользовательское пространство имен при помощи ключевого слова namespace. Например, код namespace version1 создает пространство имен с именем version1.
• Во-вторых, примените это пространство имен к свойству или методу путем его использования в объявлении свойства или метода. Например, код version1 myProperty:String создает свойство с именем myProperty, которое принадлежит пространству имен version1
• В-третьих, создайте ссылку на пространство имен при помощи ключевого слова use или используя пространство имен в качестве префикса идентификатора. Например, код use namespace version1; ссылается на пространство имен version1 для последующих строк кода, а код version1::myProperty ссылается на пространство имен version1 для свойства myProperty.

См. также

native function functionName();
class className { 
	native function methodName();
}

Показывает, что функция или метод реализуются проигрывателем Flash Player в собственном коде. Проигрыватель Flash Player использует ключевое слово native внутренне для объявления функций и методов в интерфейсе программирования приложений (API) ActionScript. Данное ключевое слово нельзя использовать в пользовательском коде.  

null

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

Значение null не следует путать со специальным значением undefined. При сравнении значений null и undefined при помощи оператора равенства (==) они считаются равными. Однако при сравнении значений null и undefined при помощи оператора строгого равенства (===) они не считаются равными.

var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

См. также

Определяет методы класса ObjectProxy. Методы класса ObjectProxy находятся в собственном пространстве имен во избежание конфликтов имен в случаях, когда подкласс Proxy содержит методы экземпляра с именами, которые совпадают с именами методов класса Proxy.

override function name() { 
	// ваши инструкции здесь 
}

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

Атрибут override нельзя использовать с:

• Переменными.
• Константами.
• Статическими методами.
• Методами, которые не наследуются.
• Методами, реализующими метод интерфейса.
• Наследуемыми методами, отмеченными в суперклассе как final.

Хотя невозможно переопределить свойство, объявленное при помощи var или const, схожей функциональности можно достигнуть, преобразовав свойство базового класса в получатель-установщик и переопределив методы, определенные при помощи get и set.

См. также

package packageName {
    class someClassName { 
    } 
}

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

См. также

class className{ 
	private var varName;
	private const kName;
	private function methodName() { 
		// ваши инструкции здесь 
	}
	private namespace nsName;
}

Показывает, что переменная, константа или метод доступны только для класса, который объявляет или определяет их. В отличие от ActionScript 2.0, в ActionScript 3.0 private больше не обеспечивает доступ к подклассам. Более того, private ограничивает доступ как во время компиляции, так и во время выполнения. По умолчанию переменная или функция доступны любой вызывающей программе в пределах того же пакета. Используйте это ключевое слово для ограничения доступа к переменной или функции.

Это ключевое слово можно использовать только в определениях класса, а не интерфейса. Ключевое слово private нельзя применить к классу или к другим определениям на уровне пакета.

class A { 
  private var alpha:String = "visible only inside class A"; 
  public var beta:String = "visible everywhere"; 
}
    
class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // ошибка
  }
}

Поскольку alpha является частной переменной, к ней нельзя получить доступ вне класса A, даже из подкласса B. Попытки получить доступ к этой частной переменной приведут к возникновению ошибки.

См. также

class className{ 
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// ваши инструкции здесь 
	}
	protected namespace nsName;
}

Показывает, что переменная, константа, метод или пространство имен доступны только для класса, который определяет их, и для подклассов этого класса. Определение ключевого слова protected в ActionScript 3.0 подобно определению ключевого слова private версии ActionScript 2.0 за исключением того, что protected ограничивает доступ как во время компиляции, так и во время выполнения. По умолчанию переменная или функция доступны любой вызывающей программе в пределах того же пакета. Используйте это ключевое слово для ограничения доступа к переменной или функции.

Это ключевое слово можно использовать только в определениях класса, а не интерфейса. Ключевое слово private нельзя применить к классу или к другим определениям на уровне пакета.

Определение ключевого слова protected в ActionScript 3.0 является более ограничительным, чем его определение в языке программирования Java. В ActionScript 3.0 protected разрешает доступ строго к подклассам, тогда как в Java protected разрешает доступ также к любому классу в пределах того же пакета. Например, если класс с именем Base содержит свойство, отмеченное как protected, в ActionScript 3.0 только классы, расширяющие класс Base, имеют доступ к этому защищенному свойству. В Java любой класс, который находится в том же пакете, что и класс Base, имеет доступ к защищенному свойству, даже если этот класс не является подклассом класса Base.

class A { 
  private var alpha:String = "visible only inside class A"; 
  protected var beta:String = "visible inside class A and its subclasses"; 
}
    
class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // Access attempt from subclass succeeded
  }
}

См. также

public var varName
public const kName
public function functionName()  { 
	// ваши инструкции здесь 
}
public class className {
	// ваши инструкции здесь 
}
public namespace nsName

Показывает, что класс, переменная, константа или метод доступны для любой вызывающей программы. Классы, переменные и методы являются внутренними (internal) по умолчанию, т. е. они видимы только в пределах текущего пакета. Чтобы сделать класс, переменную или метод видимыми для всех вызывающих программ, необходимо использовать атрибут public.

class User { 
    public var age:Number; 
    public var fname:String; 
} // конец определения класса User
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // 27 jimmy

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

См. также

function functionName () {
	return [expression]
}

Заставляет процесс выполнения незамедлительно вернуться к вызывающей функции. Если за инструкцией return следует выражение, выражение вычисляется, и возвращается результат.

Если определение функции содержит тип возвращаемого значения, за инструкцией return должно следовать выражение. Если тип возвращаемого значения не указан и инструкция return используется одна, возвращается значение undefined.

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

return a, b, c ;

Если необходим возврат нескольких значений, используйте вместо этого массив или объект.

function sum(a:Number, b:Number, c:Number):Number { 
    return (a + b + c); 
} 
var newValue:Number = sum(4, 32, 78); 
trace(newValue); // 114

См. также

function set property(newValue:*) : void{ 
	// ваши инструкции здесь 
}

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

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

Еще одним преимуществом установщиков является то, что они могут переопределяться в подклассах, а свойства, объявленные при помощи ключевого слова var, не могут.

Возвращаемое установщиком значение может относиться к типу void или не указываться.

Установщик может использоваться совместно с получателем для создания свойства чтения-записи. Для создания свойства только для чтения создайте получатель без соответствующего установщика. Для создания свойства только для записи создайте установщик без соответствующего получателя.

package {
    class User { 
        private var userAge:Number; 
        
        public function get age():Number {
            return userAge;
        }
        
        public function set age(x:Number):void {
            userAge = x;    
        }
    } 
} 

var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // 25

См. также

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// ваши инструкции здесь
	} 
}

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

Для доступа к статическому члену класса используйте имя класса вместо имени экземпляра. Например, класс Date имеет статический метод с именем parse(), который можно вызвать только при помощи следующего синтаксиса:

Date.parse()

Метод parse() невозможно вызвать для экземпляра класса Date. Например, следующий код выдает ошибку:

var myDate:Date = new Date();
			myDate.parse("Jan 01 00:00:00 2006"); // ошибка

Ключевое слово static можно использовать только в определениях класса, а не в определениях интерфейса.

Статические члены класса не наследуются. Невозможно сослаться на статический член класса, используя имя подкласса, что возможно в Java или C++. Однако можно сослаться на статическую переменную или статический метод в пределах класса или подкласса без использования квалификатора. См. пример ниже.

Инструкцию super или ключевое слово this нельзя использовать внутри статического метода.

class Users { 
    private static var numInstances:Number = 0; 
    function Users() { 
        numInstances++; 
    } 
    static function get instances():Number { 
        return numInstances; 
    } 
}

trace(Users.instances); 
var user1:Users = new Users(); 
trace(Users.instances); 
var user2:Users = new Users(); 
trace(Users.instances); 

class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

super([arg1, ..., argN])
super.method([arg1, ..., argN])

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

При использовании в теле метода экземпляра super может использоваться с оператором "точка" (.) для вызова суперклассовой версии метода и дополнительно передавать аргументы (arg1 ... argN) методу суперкласса. Это полезно для создания методов подкласса, которые не только обеспечивают дополнительное поведение методов суперкласса, но и вызывают методы суперкласса для реализации их исходного поведения.

Инструкцию super невозможно использовать в статическом методе.

См. также

switch (expression) {
	caseClause: 
	[defaultClause:] 
}

Приводит к передаче управления одной из нескольких инструкций в зависимости от значения выражения. Все инструкции switch должны включать в себя блок по умолчанию, который будет выполняться, если ни одна из инструкций case не соответствует выражению. Каждая инструкция case должна заканчиваться инструкцией break, что предотвращает ошибку прохода при невыполнении условия. При такой ошибке выполняется код в следующей инструкции case, даже если этот блок не соответствует проверяемому выражению.

var switchExpression:int = 3;
        
switch (switchExpression) {
    case 0:
        trace(0);
        break;
    case 1:
        trace(1);
        break;
    case 2:
        trace(2);
        break;
    default:
        trace("Not 0, 1, or 2");
}

// Not 0, 1, or 2

См. также

this

Ссылка на объект, содержащий метод. При выполнении сценария ключевое слово this ссылается на объект, содержащий сценарий. В теле метода ключевое слово this ссылается на экземпляр класса, который содержит вызываемый метод.

// неправильная версия Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// правильная версия Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}

var simpleObj:Simple = new Simple();
simpleObj.func = function() {
    trace("hello there");
}
simpleObj.callfunc();

throw expression 

Генерирует, или выбрасывает, ошибку, которая может быть обработана, или перехвачена, блоком кода catch. Если исключение не перехвачено блоком catch, строковое представление возвращенного значения отправляется на панель "Вывод". Если исключение не перехвачено блоком catch или finally, строковое представление возвращенного значения отправляется в файл журнала.

Как правило, возвращаются экземпляры класса Error или его подклассов (см. раздел "Примеры").

function checkEmail(email:String) { 
    if (email.indexOf("@") == -1) { 
        throw new Error("Invalid email address"); 
    } 
} 
checkEmail("someuser_theirdomain.com");

try { 
    checkEmail("Joe Smith"); 
} 
catch (e) { 
    trace(e); 
}
// Error: Invalid email address.

// Define Error subclass InvalidEmailError 
class InvalidEmailAddress extends Error { 
    public function InvalidEmailAddress() {
        message = "Invalid email address."; 
    }
}

import InvalidEmailAddress; 
function checkEmail(email:String) { 
    if (email.indexOf("@") == -1) { 
        throw new InvalidEmailAddress(); 
    } 
} 
try { 
    checkEmail("Joe Smith"); 
} 
catch (e) { 
    trace(e);
}
// Error: Invalid email address.

См. также

true

Значение типа Boolean, представляющее true. Значением типа Boolean является либо true, либо false; противоположностью true является false. Если при автоматическом преобразовании типов данных значение true преобразуется в число, оно становится 1; при преобразовании значения true в строку, оно принимает вид "true".

var shouldExecute:Boolean;
// ...
// здесь пишется код, который задает для shouldExecute значение true или false
// shouldExecute установлена на true в данном примере:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true также подразумевается, поэтому инструкция if могла выглядеть так:
// if (shouldExecute) {
//         trace("your statements here");
// }

Следующий пример иллюстрирует преобразование значения true в число 1 в результате автоматического преобразования типов данных:

var myNum:Number;
myNum = 1 + true;
trace(myNum); // 2

См. также

try { 
    // блок try 
} finally { 
    // блок finally  
} 

try { 
    // блок try 
} catch(error[:ErrorType1]) {
    // блок catch 
} [catch(error[:ErrorTypeN]) { 
    // блок catch 
}] [finally {
    // блок finally 
}]

Обрамляет блок кода, в котором может произойти ошибка, затем реагирует на ошибку. Обработка исключений при помощи инструкций try..catch..finally является основным механизмом обработки ошибок этапа выполнения в ActionScript 3.0. При возникновении ошибки этапа выполнения проигрыватель Flash Player выдает исключение, приостанавливает нормальный процесс выполнения и создает специальный объект типа Error. Затем проигрыватель Flash Player передает, или выбрасывает, объект ошибки первому доступному блоку catch. Если доступных блоков catch нет, исключение считается неперехваченным. Неперехваченные исключения прерывают выполнение сценария.

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

Для перехвата исключения, возвращенного проигрывателем Flash Player или пользовательским кодом, вставьте код, который может выдать исключение, в блок try. Если какой-либо код в блоке try выдаст исключение, управление передается блоку catch, при его наличии, затем блоку finally, если такой существует. Блок finally всегда выполняется, независимо от того, было ли возвращено исключение. Если код в блоке try не выдаст исключение (т. е. при нормальном выполнении блока try), код в блоке catch игнорируется, но код в блоке finally все же выполняется. Блок finally выполняется, даже если блок try завершается командой return.

За блоком try должен следовать блок catch, блок finally или и тот, и другой. Один блок try может содержать несколько блоков catch, но только один блок finally. Можно вложить столько уровней блока try, сколько нужно.

Параметр error, заданный в обработчике catch, должен быть простым идентификатором, например e, theException или x. Параметр может быть типизированным. При использовании с несколькими блоками catch типизированные параметры позволяют перехватывать различные типы объектов ошибок, возвращенных одним блоком try.

Если возвращенное исключение является объектом, совпадение типов произойдет, если возвращенный объект является подклассом указанного типа. Если возвратилась ошибка конкретного типа, выполняется блок catch, обрабатывающий соответствующие ошибки. Если возвращено исключение не указанного типа, блок catch не выполняется, и исключение автоматически передается из блока try соответствующему обработчику catch.

Если ошибка произошла в функции, которая не содержит обработчик catch, проигрыватель Flash Player завершает выполнение этой функции, а также вызывающих функций, пока не будет найден блок catch. Во время этого процесса обработчики finally вызываются на всех уровнях.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
    spr.addChild(spr);
}
catch (e:ArgumentError) {
    trace (e); // ArgumentError: Error #2024: An object may not be added as a child of itself.
}

class RecordSetException extends Error { 
    public function RecordSetException () {
        message = "Record set exception occurred."; 
    }
}

class MalformedRecord extends Error { 
    public function MalformedRecord {
        message = "Malformed record exception occurred."; 
    }
}

class RecordSet { 
    public function sortRows() { 
        var returnVal:Number = randomNum(); 
        if (returnVal == 1) { 
            throw new RecordSetException(); 
        } 
        else if (returnVal == 2) { 
            throw new MalformedRecord(); 
        } 
    }
    public function randomNum():Number { 
        return Math.round(Math.random() * 10) % 3; 
    }
}

import RecordSet; 
var myRecordSet:RecordSet = new RecordSet();
try { 
    myRecordSet.sortRows(); 
    trace("everything is fine"); 
} 
catch (e:RecordSetException) { 
    trace(e.toString()); 
} 
catch (e:MalformedRecord) { 
    trace(e.toString()); 
}

См. также

use namespace ns1[, ns2, ...nsN]

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

См. также

var variableName [= value1][...,variableNameN[=valueN]] 

Задает переменную. При объявлении переменных в функции переменные становятся локальными. Они определяются для функции и прекращают действовать в конце вызова функции.

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

Невозможно объявить переменную, которая входит в область видимости другого объекта, как локальную.

my_array.length = 25; // ОК 
var my_array.length = 25; // синтаксическая ошибка 

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

Можно объявить несколько переменных в одной инструкции, разделяя объявления запятыми (хотя такой синтаксис может быть в ухудшить ясность кода):

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); 
trace(product_array); 
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

См. также

while (condition) { 
	// инструкция(и)
}

Вычисляет условие, и если получено значение true, выполняет инструкцию или набор инструкций перед возвращением по циклу к повторному вычислению условия. Если в результате вычисления условия получено значение false, инструкции не выполняются, и цикл завершается.

Инструкция while выполняет следующую серию действий. Каждое повторение шагов с 1 по 4 называется итерацией цикла. Условие проверяется в начале каждой итерации, как показано ниже:

1. Вычисляется выражение condition.
2. Если выражение condition принимает значение true или значение, которое может быть преобразовано в логическое значение true, например число, отличное от нуля, выполняется переход к шагу 3. В противном случае завершается инструкция while, и выполнение возобновляется со следующей инструкции после цикла while.
3. Выполните блок инструкций statement(s). При появлении инструкции continue пропустите оставшиеся инструкции и перейдите к шагу 1. При появлении инструкции break завершается инструкция while, и выполнение возобновляется со следующей инструкции после цикла while.
4. Перейдите к шагу 1.

Зацикливание обычно используется для выполнения действия до тех пор, пока переменная counter меньше заданного значения. В конце каждого цикла счетчик увеличивается на единицу до тех пор, пока не будет получено заданное значение. При этом выражение condition не принимает значение true, и цикл завершается.

Фигурные скобки ({}), в которых заключены инструкции для выполнения инструкцией while, не требуются при выполнении только одной инструкции.

var i:Number = 0; 
while (i < 20) { 
    trace(i); 
    i += 3; 
}
/*
0 
3 
6 
9 
12
15 
18
*/

См. также

with (object:Object) { 
	// инструкция(и)
}

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

Параметр object становится контекстом, в котором считываются свойства, переменные и функции в параметре statement(s). Например, если object является my_array, для которого заданы свойства length и concat, эти свойства автоматически считываются как my_array.length и my_array.concat. Или если object является state.california, любые действия или инструкции в инструкции with вызываются из экземпляра california.

ActionScript начинает поиск значения идентификатора в параметре statement(s) с начала цепочки областей видимости, заданной объектом object, и выполняет поиск идентификатора на каждом уровне этой цепочки в определенном порядке.

Цепочка областей видимости, используемая в инструкции with для разрешения идентификаторов, начинается с первого элемента следующего списка и заканчивается последним элементом:

• Объект, заданный параметром object в наиболее глубоко вложенной инструкции with
• Объект, заданный параметром object в самой ближней внешней инструкции with
• Объект Activation (временный объект, создаваемый автоматически при вызове сценарием функции, содержащей локальные переменные, вызываемые функцией)
• Объект, содержащий сценарий, который выполняется в данный момент
• Объект Global (встроенные объекты, например Math и String)

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

with (someOther_mc) { 
    _x = 50; 
    _y = 100; 
    gotoAndStop(3); 
}

someOther_mc._x = 50; 
someOther_mc._y = 100; 
someOther_mc.gotoAndStop(3);

Инструкция with используется для доступа к нескольким элементам в списке цепочки областей видимости одновременно. В следующем примере встроенный объект Math помещается в начало цепочки областей видимости. Установка Math в качестве объекта по умолчанию разрешает идентификаторы cos, sin и PI в Math.cos, Math.sin и Math.PI соответственно. Идентификаторы a, x, y и r не являются методами или свойствами объекта Math, но поскольку они существуют в области активации объекта функции polar(), они разрешаются в соответствующие локальные переменные.

function polar(r:Number):void { 
    var a:Number, x:Number, y:Number; 
    with (Math) { 
        a = PI * pow(r, 2); 
        x = r * cos(PI); 
        y = r * sin(PI / 2); 
    } 
    trace("area = " + a); 
    trace("x = " + x); 
    trace("y = " + y); 
} polar(3);
/* 
area = 28.2743338823081 
x = -3 
y = 3
*/