Инструкции, ключевые слова и директивы 

function functionName(parameter0, parameter1, ...rest){ 
	// statement(s) 
} 

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

При использовании с другими параметрами объявление параметра ... (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);
}

Связанные элементы API

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

Связанные элементы API

Используется в цикле (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; // this will terminate/exit the loop 
	} 
	i++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

Связанные элементы API

case jumpTarget: statements

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

При использовании инструкции 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"); 
}

Связанные элементы API

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// class definition here
}

Определяет класс, который позволяет создавать экземпляры объектов, применяющие заданные общие методы и свойства. Например, при разработке системы отслеживания счетов можно создать класс 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 { 
	// Define property names and types 
	private var _leafType:String; 
	private var _bloomSeason:String; 
	// Following line is constructor 
	// because it has the same name as the class 
	public function Plant(param_leafType:String, param_bloomSeason:String) { 
		// Assign passed values to properties when new Plant object is created 
		_leafType = param_leafType; 
		_bloomSeason = param_bloomSeason; 
	} 
	// Create methods to return property values, because best practice 
	// recommends against directly referencing a property of a class 
	public function get leafType():String { 
		return _leafType; 
	} 
	public function get bloomSeason():String { 
		return _bloomSeason; 
	} 
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Confirm parameters were passed correctly 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

Связанные элементы API

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"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array); 

Связанные элементы API

continue [label]

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

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

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

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

Связанные элементы API

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"); 
}

Связанные элементы API

Директива 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 = ;
trace("x1 ns: " + x1.namespace());
			
scopeCheck();	

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

}

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

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

var x2:XML = ;
trace(x2.namespace());
	// http://www.w3.org/1999/XSL/Transform/

var x3:XML = ;
trace(x3.namespace());
	// http://www.example.com/namespaces/

Связанные элементы API

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
*/

Связанные элементы API

dynamic class className { // class definition here }

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

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

Атрибут 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"; // error

Связанные элементы API

if (condition) { 
	// statement(s)
} 
else {
	// statement(s)
}

Задает инструкции, которые выполняются, если условие в инструкции 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"); 
}

Связанные элементы API

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

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

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

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

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

Связанные элементы API

false

Логическое значение, представляющее false. Логическим значением становится либо true, либо false, причем значения false и true являются противоположными.

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

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

var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false

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

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

Связанные элементы API

final function methodName() { 
	// your statements here 
}
final class className {}

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

Связанные элементы API

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

Связанные элементы API

for ([init]; [condition]; [next]) { 
	// statement(s)
}

Вычисляет однократно выражение 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

Связанные элементы API

for (variableIterant:String in object){ 
	// statement(s)
} 

Выполняет итерацию через динамические свойства объекта или элементы массива и выполняет инструкцию 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
*/

Связанные элементы API

for each (variableIterant in object){ 
	// statement(s)
} 

Выполняет итерацию через элементы коллекции и выполняет инструкцию statement для каждого элемента. Инструкцию for each..in, введенную в составе расширений языка E4X, можно использовать не только для объектов 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 = 
		
			
Hello
			
Hola
			

			
Bonjour
		;
for each (var item in doc.p) {
	trace(item);
}

/*
Hello
Hola
Bonjour
*/

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 

Составляет набор инструкций, заданный пользователем для выполнения определенной задачи. Можно определить функцию в одном местоположении и вызывать ее из различных сценариев в 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); 
}

Связанные элементы API

function get property() : returnType{ 
	// your statements here 
}

Определяет получателя — метод, который может быть прочитан как свойство. Получатель — это специальная функция, которая возвращает значение свойства, объявленного при помощи ключевого слова 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 */

Связанные элементы API

if (condition) {
	// statement(s)
}

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

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

Связанные элементы API

myClass implements interface01 [, interface02 , ...] 

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

Связанные элементы API

import packageName.className 
import packageName.*

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

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

 
import flash.display.Sprite; 

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

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

import flash.display.*;

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

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

// On Frame 1 of a 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 позволяет использовать методы получателя и установщика в определениях интерфейса.

Связанные элементы API

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// your statements here 
}
[internal] class className{
	// your statements here 
}
[internal] namespace nsName

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

Связанные элементы API

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: {
	trace("a");
	break foo;
	trace("b");
}
// a

Связанные элементы API

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.

Связанные элементы API

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
*/

Связанные элементы API

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

override function name() { 
	// your statements here 
}

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

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

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

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

Связанные элементы API

package packageName {
    class someClassName { 
    } 
}

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

Связанные элементы API

class className{ 
	private var varName;
	private const kName;
	private function methodName() { 
		// your statements here 
	}
	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"; // error
  }
}

Связанные элементы API

class className{ 
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// your statements here 
	}
	protected namespace nsName;
}

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

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

Определение ключевого слова protected в ActionScript 3.0 является более ограничительным, чем определение protected в языке программирования 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
  }
}

Связанные элементы API

public var varName
public const kName
public function functionName()  { 
	// your statements here 
}
public class className {
	// your statements here 
}
public namespace nsName

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

class User { 
	public var age:Number; 
	public var fname:String; 
} // end of class User definition
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // 27 jimmy

Связанные элементы API

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

Связанные элементы API

function set property(newValue:*) : void{ 
	// your statements here 
}

Определяет установщик — метод, отображаемый в общедоступном интерфейсе как свойство. Установщик — это специальный метод, который задает значение свойства, объявленного при помощи ключевого слова 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

Связанные элементы API

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// your statements here
	} 
}

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

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

Date.parse()

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

var myDate:Date = new Date();
            myDate.parse("Jan 01 00:00:00 2006"); // error

Можно использовать 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 нельзя использовать в статическом методе.

Связанные элементы API

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

Связанные элементы API

this

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

// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of 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.

Связанные элементы API

true

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

var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

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

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }

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

Связанные элементы API

try { 
    // try block 
} finally { 
    // finally block  
} 

try { 
    // try block 
} catch(error[:ErrorType1]) {
    // catch block 
} [catch(error[:ErrorTypeN]) { 
    // catch block 
}] [finally {
    // finally block 
}]

Обрамляет блок кода, в котором может произойти ошибка, затем реагирует на ошибку. Обработка исключений, реализованная с использованием инструкций try..catch..finally, является основным механизмом обработки ошибок времени выполнения в ActionScript 3.0. Когда возникает ошибка времени выполнения, Flash Player выдает исключение, то есть 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 вызываются на всех уровнях.

Примечание. Если в блоке try имеется диспетчер событий, который вызывает обработчик событий, блок catch не перехватывает ошибку, если ее выдает обработчик событий. Любую ошибку, выданную после этого момента, можно перехватить, прослушивая LoaderInfo.uncaughtErrorEvents.

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()); 
}

Связанные элементы API

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

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

Связанные элементы API

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

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

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

my_array.length = 25; // ok 
var my_array.length = 25; // syntax error 

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

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

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

Связанные элементы API

while (condition) { 
	// statement(s)
}

Вычисляет условие и, если получено значение 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
*/

Связанные элементы API

with (object:Object) { 
	// statement(s)
}

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

Параметр 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, будет задано новое значение.

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
*/