Операторы 

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

Если одно выражение является строкой, все другие выражения преобразуются в строки и сцепляются, а не суммируются. В противном случае, если выражение не является числом, проигрыватель Flash^® Player преобразует его в число.

trace(2 + 3); // 5

trace(2.5 + 3.25); // 5.75

trace("Number " + 8 + 0); // Number 80

var oldBalance:Number = 1345.23; 
var currentBalance = deposit_txt.text + oldBalance; 
trace(currentBalance); 

var oldBalance:Number = 1345.23; 
var currentBalance:Number = Number(deposit_txt.text) + oldBalance;
trace(currentBalance);

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

Присваивает выражению expression1 значение выражения expression1 + expression2. Например, следующие две инструкции имеют одинаковый результат:

x += y; 
x = x + y; 

var x:Number = 5; 
var y:Number = 10; 
x += y; 
trace(x); // 15 

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

myArray = [a0, a1,...aN]
myArray[i] = value 
myObject[propertyName]

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

Применение 1. Массив представляет собой объект, свойства которого называются элементами, каждый из которых имеет числовой идентификатор, называемый индексом. При создании массива его элементы заключаются в квадратные скобки оператора доступа к массиву ([]). Массив может содержать элементы различных типов. Например, следующий массив с именем employee состоит из трех элементов: первый элемент является числом, а остальные два — строками (внутри кавычек):

var employee:Array = [15, "Barbara", "Jay"]; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
			
/* Select Debug > List Variables in test mode 
to see a list of the array elements.*/ 

var my_array:Array = new Array(); 
my_array[0] = 15; 
my_array[1] = "Hello"; 
my_array[2] = true; 

my_array[3] = "George"; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
trace(ticTacToe[1][2]); // 6 

var obj:Object = new Object();
obj.prop1 = "foo";
trace(obj["prop" + 1]); // foo
obj.prop2 = "bar";
for (j in obj) {
	trace(obj[j]);
} 
/* Output of for loop: 
foo
bar */

var my_array:Array = []; 
var my_array:Array = new Array(); 

В следующем примере создается массив с именем employee_array, состоящий из трех элементов, и изменяется третий элемент этого массива.

var employee_array = ["Barbara", "George", "Mary"]; 
trace(employee_array); // Barbara,George,Mary 
employee_array[2] = "Sam"; 
trace(employee_array); // Barbara,George,Sam 

var obj:Object = new Object();
obj.prop1 = "foo";
obj.prop2 = "bar";

for (var i:int = 1;i < 3;i++) {
	trace(obj["prop"+i]);
}
/* Output of for loop:
foo
bar */ 

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

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

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

public var myArray:Array = ["one", "two", "three"];
trace(myArray as Array);  // one,two,three
trace(myArray as Number); // null
trace(myArray as int);    // null

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

Присваивает значение выражения expression2 (операнд справа) переменной, элементу массива или свойству в выражении expression1. Присваивание может быть либо по значению, либо по ссылке. При присваивании по значению копируется фактическое значение выражения expression2 и сохраняется в выражении expression1. Присваивание по значению используется, когда выражение expression2 является примитивным значением, т. е. относится к типу данных Boolean, Number, int, uint или String. При присваивании по ссылке ссылка на выражение expression2 сохраняется в выражении expression1. Присваивание по ссылке обычно используется с оператором new. Оператор new создает объект в памяти, а ссылка на это местоположение в памяти присваивается переменной.

Примечание. В ActionScript 3.0 все значения (включая примитивные) являются объектами, и присваивание всегда выполняется по ссылке, но для примитивных объектов существуют специальные операторы, которые позволяют им вести себя так, как при присваивании по значению.

var z:Number = 5;

var x:String;
x = "hello";

var moonsOfJupiter:Array = new Array();
moonsOfJupiter[0] = "Callisto";

var mercury:Object = new Object();
mercury.diameter = 3030; // in miles
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // in kilometers
trace(mercury.diameter); // 4878

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

 myXML.@attributeName 

Определяет атрибуты объекта XML или XMLList. Например, myXML.@id определяет атрибуты с именем id для объекта XML myXML. Для обращения к атрибутам также можно использовать следующий синтаксис: myXML.attribute("id"), myXML["@id"] и myXML.@["id"]. Рекомендуется использовать синтаксис myXML.@id. Для возврата объекта XMLList с именами всех атрибутов используйте @*. Для возврата атрибута, имя которого совпадает с зарезервированным словом ActionScript, используйте метод attribute() вместо оператора @.

var myXML:XML = 
	<item id = "42">
		<catalogName>Presta tube</catalogName>
		<price>3.99</price>
	</item>;

trace(myXML.@id); // 42

var xml:XML =<example id='123' color='blue'/>
 var xml2:XMLList = xml.@*;
 trace(xml2 is XMLList); // true
 trace(xml2.length());  // 2
 for (var i:int = 0; i < xml2.length(); i++)
 { 
	trace(typeof(xml2[i]));    // xml
	trace(xml2[i].nodeKind()); // attribute
	trace(xml2[i].name());     // id and color
 } 

var xml:XML = <example class='123'/>
trace(xml.attribute("class"));

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

Преобразует выражения expression1 и expression2 в 32-разрядные целые числа без знака и выполняет логическую операцию AND для каждого бита целочисленных параметров. Числа с плавающей запятой преобразуются в целые числа путем отсечения всех цифр после десятичной запятой. Результатом является новое 32-разрядное целое число.

Положительное целое число преобразуется в шестнадцатеричное значение без знака величиной максимум 4294967295 или 0xFFFFFFFF. У значения, превышающего максимальную величину, при преобразовании отсекаются значащие цифры так, что значение все равно становится 32-разрядным. Отрицательное целое число преобразуется в шестнадцатеричное значение без знака шестнадцатеричное значение без знака в написании с дополнением до двух величиной минимум -2147483648 или 0x800000000. Число меньше минимальной величины преобразуется в число с дополнением до двух с большей точностью перед отсечением значащих цифр.

Результат интерпретируется как 32-разрядное число с дополнением до двух, поэтому результатом является целое число в диапазоне от -2147483648 до 2147483647.

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // 9 (or 1001 binary) 

  1101
& 1011
  ----
  1001

Далее приведены примеры преобразования возвращаемого значения:

trace(0xFFFFFFFF); // 4294967295 
trace(0xFFFFFFFF & 0xFFFFFFFF); // -1 
trace(0xFFFFFFFF & -1); // -1 
trace(4294967295 & -1); // -1 
trace(4294967295 & 4294967295); // -1 

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

Присваивает выражению expression1 значение выражения expression1 & expression2. Например, следующие два выражения идентичны:

x &= y; 
x = x & y; 

var x:Number = 15; 
var y:Number = 9; 
trace(x &= y); // 9 

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

Преобразует выражения expression1 и shiftCount в 32-разрядные целые числа и сдвигает все биты в выражении expression1 влево на число позиций, заданное целым числом, полученным в результате преобразования выражения shiftCount. Позиции битов, ставшие пустыми в результате этой операции, заменяются на 0, а биты, сдвинутые за левый край, отсекаются. Сдвиг значения влево на одну позицию эквивалентен его умножению на 2.

Число с плавающей запятой преобразуется в целое число путем отсечения всех цифр после десятичной запятой. Положительное целое число преобразуется в шестнадцатеричное значение без знака величиной максимум 4294967295 или 0xFFFFFFFF. У значения, превышающего максимальную величину, при преобразовании отсекаются значащие цифры так, что значение все равно становится 32-разрядным. Отрицательное целое число преобразуется в шестнадцатеричное значение без знака шестнадцатеричное значение без знака в написании с дополнением до двух величиной минимум -2147483648 или 0x800000000. Число меньше минимальной величины преобразуется в число с дополнением до двух с большей точностью перед отсечением значащих цифр.

Результат интерпретируется как 32-разрядное число с дополнением до двух, поэтому результатом является целое число в диапазоне от -2147483648 до 2147483647.

Если результатом является отрицательное целое число, то при попытке присвоить результат переменной типа uint произойдет ошибка этапа выполнения. Хотя в ActionScript отсутствует оператор «побитовый сдвиг влево без знака», можно достичь того же эффекта и избежать ошибки этапа выполнения при помощи uint(expression1 << shiftCount):

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

   00000000001 binary 
<<          10 decimal
--------------
   10000000000 binary equals 1024 decimal 

В следующем примере целое число 7 сдвигается на 8 битов влево:

x = 7 << 8

   00000000111 binary 
<<           8 decimal
--------------
   11100000000 binary equals 1792 decimal 

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

// 1 binary == 0001 
// 8 binary == 1000 
trace(1 << 3); // 8 

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

Выполняет операцию побитового сдвига влево (<<=) и сохраняет содержимое как результат в выражении expression1. Следующие два выражения идентичны:

A <<= B
A = (A << B)

var x:Number = 4; 
// Shift all bits one slot to the left. 
x <<= 1; 
trace(x); // 8 
// 4 decimal = 0100 binary 
// 8 decimal = 1000 binary 

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

Преобразует expression в 32-разрядное целое число со знаком, затем применяет побитовое дополнение до единицы. Т. е. каждый бит, равный 0, в результате имеет значение 1, а каждый бит, равный 1, в результате имеет значение 0. Результатом является 32-разрядное целое число со знаком. Данный оператор также называется оператором дополнения до единицы или оператором побитового дополнения.

Например, шестнадцатеричное значение 0x7777 представлено в виде такого двоичного числа:

0111011101110111

Побитовое отрицание этого шестнадцатеричного значения, ~0x7777, имеет вид такого двоичного числа:

1000100010001000

В шестнадцатеричном формате это 0x8888. Следовательно, ~0x7777 — это 0x8888.

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

Число с плавающей запятой преобразуется в целое число путем отсечения всех цифр после десятичной запятой. Положительное целое число преобразуется в шестнадцатеричное значение без знака величиной максимум 4294967295 или 0xFFFFFFFF. У значения, превышающего максимальную величину, при преобразовании отсекаются значащие цифры так, что значение все равно становится 32-разрядным. Отрицательное целое число преобразуется в шестнадцатеричное значение без знака шестнадцатеричное значение без знака в написании с дополнением до двух величиной минимум -2147483648 или 0x800000000. Число меньше минимальной величины преобразуется в число с дополнением до двух с большей точностью перед отсечением значащих цифр.

Результат интерпретируется как 32-разрядное число с дополнением до двух, поэтому результатом является целое число в диапазоне от -2147483648 до 2147483647.

var ReadOnlyFlag:int = 0x0001; // defines bit 0 as the read-only flag 
var flags:int = 0; 
trace(flags); 
/* To set the read-only flag in the flags variable, 
   the following code uses the bitwise OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* To clear the read-only flag in the flags variable, 
   first construct a mask by using bitwise NOT on ReadOnlyFlag. 
   In the mask, every bit is a 1 except for the read-only flag. 
   Then, use bitwise AND with the mask to clear the read-only flag. 
   The following code constructs the mask and performs the bitwise AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

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

Преобразует expression1 и expression2 в 32-разрядные целые числа без знака и ставит 1 в позиции каждого бита, где соответствующие биты в expression1 или expression2 являются 1.

Число с плавающей запятой преобразуется в целое число путем отсечения всех цифр после десятичной запятой. Положительное целое число преобразуется в шестнадцатеричное значение без знака величиной максимум 4294967295 или 0xFFFFFFFF. У значения, превышающего максимальную величину, при преобразовании отсекаются значащие цифры так, что значение все равно становится 32-разрядным. Отрицательное целое число преобразуется в шестнадцатеричное значение без знака шестнадцатеричное значение без знака в написании с дополнением до двух величиной минимум -2147483648 или 0x800000000. Число меньше минимальной величины преобразуется в число с дополнением до двух с большей точностью перед отсечением значащих цифр.

Результат интерпретируется как 32-разрядное число с дополнением до двух, поэтому результатом является целое число в диапазоне от -2147483648 до 2147483647.

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // returns 15 decimal (1111 binary) 

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

Присваивает выражению expression1 значение выражения expression1 | expression2. Например, следующие две инструкции идентичны:

x |= y; 
x = x | y; 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // returns 15 decimal (1111 binary) 

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

Преобразует выражения expression и shiftCount в 32-разрядные целые числа и сдвигает все биты в выражении expression вправо на число позиций, заданное целым числом, полученным в результате преобразования выражения shiftCount. Биты, сдвинутые за правый край, отсекаются. Для сохранения знака исходного выражения биты слева заменяются на 0, если самый значащий бит (крайний левый) выражения expression является 0, и на 1, если самый значащий бит является 1. Сдвиг значения вправо на одну позицию аналогичен делению на 2 и отсечению остатка.

Число с плавающей запятой преобразуется в целое число путем отсечения всех цифр после десятичной запятой. Положительное целое число преобразуется в шестнадцатеричное значение без знака величиной максимум 4294967295 или 0xFFFFFFFF. У значения, превышающего максимальную величину, при преобразовании отсекаются значащие цифры так, что значение все равно становится 32-разрядным. Отрицательное целое число преобразуется в шестнадцатеричное значение без знака шестнадцатеричное значение без знака в написании с дополнением до двух величиной минимум -2147483648 или 0x800000000. Число меньше минимальной величины преобразуется в число с дополнением до двух с большей точностью перед отсечением значащих цифр.

Результат интерпретируется как 32-разрядное число с дополнением до двух, поэтому результатом является целое число в диапазоне от -2147483648 до 2147483647.

var a:Number = 65535 >> 8; 
trace(a); // 255

    00000000000000001111111111111111 binary (65535 decimal)
>>                                 8 decimal
--------------------
    00000000000000000000000011111111 binary (255 decimal)

var a:Number = -8 >> 1;
trace(a); // -4

    11111111111111111111111111111000 binary (-8 decimal)
>>							    1 decimal
--------------------
    11111111111111111111111111111100 binary (-4 decimal)

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

Выполняет операцию побитового сдвига вправо и сохраняет результат в выражении expression.

Следующие две инструкции идентичны:

A >>= B; 
A = (A >> B);

function convertToBinary(numberToConvert:Number):String { 
	var result:String = ""; 
	for (var i = 0; i < 32; i++) { 
		// Extract least significant bit using bitwise AND. 
		var lsb:Number = numberToConvert & 1; 
		// Add this bit to the result.
		result = (lsb ? "1" : "0")+result; 
		// Shift numberToConvert right by one bit, to see next bit. 
		numberToConvert >>= 1; 
	} 
	return result; 
} 
trace(convertToBinary(479)); 
// Returns the string 00000000000000000000000111011111. 
// This string is the binary representation of the decimal number 479.

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

Аналогичен оператору побитового сдвига вправо (>>) за исключением того, что он не сохраняет знак исходного выражения, поскольку биты слева всегда заполняются нулями (0).

Число с плавающей запятой преобразуется в целое число путем отсечения всех цифр после десятичной запятой. Положительное целое число преобразуется в шестнадцатеричное значение без знака величиной максимум 4294967295 или 0xFFFFFFFF. У значения, превышающего максимальную величину, при преобразовании отсекаются значащие цифры так, что значение все равно становится 32-разрядным. Отрицательное целое число преобразуется в шестнадцатеричное значение без знака шестнадцатеричное значение без знака в написании с дополнением до двух величиной минимум -2147483648 или 0x800000000. Число меньше минимальной величины преобразуется в число с дополнением до двух с большей точностью перед отсечением значащих цифр.

Результат интерпретируется как 32-разрядное целое число без знака, поэтому результатом является целое число в диапазоне от 0 до 4294967295.

Примечание. В ActionScript отсутствует дополнительный оператор «побитовый сдвиг влево без знака», но можно достичь того же эффекта при помощи uint(expression << shiftCount).

var a:Number = -1 >>> 1; 
trace(a); // 2147483647 

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

Выполняет операцию побитового сдвига вправо без знака и сохраняет результат в выражении expression. Следующие две инструкции идентичны:

A >>>= B; 
A = (A >>> B); 

var a:Number = -1;
a >>>= 1; 
trace(a); // 2147483647 

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

Преобразует expression1 и expression2 в 32-разрядные целые числа без знака и ставит 1 в позиции каждого бита, где соответствующие биты в expression1 или expression2, но не в обоих выражениях, равны 1.

Число с плавающей запятой преобразуется в целое число путем отсечения всех цифр после десятичной запятой. Положительное целое число преобразуется в шестнадцатеричное значение без знака величиной максимум 4294967295 или 0xFFFFFFFF. У значения, превышающего максимальную величину, при преобразовании отсекаются значащие цифры так, что значение все равно становится 32-разрядным. Отрицательное целое число преобразуется в шестнадцатеричное значение без знака шестнадцатеричное значение без знака в написании с дополнением до двух величиной минимум -2147483648 или 0x800000000. Число меньше минимальной величины преобразуется в число с дополнением до двух с большей точностью перед отсечением значащих цифр.

Результат интерпретируется как 32-разрядное число с дополнением до двух, поэтому результатом является целое число в диапазоне от -2147483648 до 2147483647.

// 15 decimal = 1111 binary 
// 9 decimal = 1001 binary 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// returns 6 decimal (0110 binary) 

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

Присваивает выражению expression1 значение выражения expression1 ^ expression2. Например, следующие две инструкции идентичны:

x ^= y 
x = x ^ y 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

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

/* comment */

/* comment

   comment */

Отделяет одну или несколько строк комментариев в сценарии. Символы, расположенные между открывающим разделителем (/*) и закрывающим разделителем (*/), воспринимаются как комментарий и игнорируются компилятором ActionScript. Используйте эти разделители для идентификации комментариев, расположенных на нескольких последовательных строках; для однострочных комментариев используйте разделитель //.

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

/* records the X and Y positions of 
the ball and bat movie clips */ 
var ballX:Number = ball_mc._x; 
var ballY:Number = ball_mc._y; 
var batX:Number = bat_mc._x; 
var batY:Number = bat_mc._y; 

/* This is an attempt to nest comments. 
/* But the first closing tag will be paired 
with the first opening tag */ 
and this text will not be interpreted as a comment */ 

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

 myXML = <{tagName} {attributeName} = {attributeValue}>{content}

Вычисляет выражение, которое используется в инициализаторе XML или XMLList. Инициализатор XML или XMLList является литеральным значением, которое присваивается переменной типа XML или XMLList. Выражение, заключенное между XML-операторами { и }, может использоваться в инициализаторе XML или XMLList вместо литеральных имен или значений. Выражение можно использовать вместо tagName, attributeName, attributeValue и content.

var tagname:String = "item"; 
var attributename:String = "id"; 
var attributevalue:String = "5"; 
var content:String = "Chicken"; 
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>; 
trace(x.toXMLString()); // <item id="5">Chicken</item>

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

 myXML[expression]

Обращается к свойству или атрибуту объекта XML или XMLList. Оператор «квадратные скобки» обеспечивает доступ к именам свойств, к которым нельзя получить доступ при помощи оператора «точка» (.).

var myXML:XML = <a><foo-bar>44</foo-bar></a>;
trace(myXML["foo-bar"]);

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

Вычисляет expression1, затем expression2 и т. д. Данный оператор в основном используется с инструкцией цикла for и часто используется с оператором «круглые скобки» ().

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
	trace("i = " + i + ", j = " + j); 
} 
// output: 
// i = 0, j = 0 
// i = 1, j = 2

var v:Number = 0; 
v = 4, 5, 6; 
trace(v); // 4 

var v:Number = 0; 
v = (4, 5, 6); 
trace(v); // 6 

var v:Number = 0; 
var z:Number = 0; 
v = v + 4 , z++, v + 6; 
trace(v); // 4 
trace(z); // 1 

var v:Number = 0; 
var z:Number = 0; 
v = (v + 4, z++, v + 6); 
trace(v); // 6 
trace(z); // 1 

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

Сцепляет (объединяет) строки. Если одно выражение является строкой, все другие выражения преобразуются в строки и сцепляются.

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

var lastName:String = "Cola"; 
var instrument:String = "Drums"; 
trace(lastName + " plays " + instrument); // Cola plays Drums 

trace("Number " + 8 + 0); // Number 80

var a:String = 3 + 10 + "asdf"; 
trace(a); // 13asdf 
var b:String = "asdf" + 3 + 10; 
trace(b); // asdf310 

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

expression1 + expression2

Сцепляет (объединяет) значения XML или XMLList для образования объекта XMLList. Объект XMLList образуется, только если оба операнда являются значениями XML или XMLList.

var x1:XML = 
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>;

var x2:XML = 
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>;

var myXMLList:XMLList = x1 + x2;
	
trace(myXMLList.toXMLString()); 

Результатом инструкции trace будет следующее:

<employee id = "42">
	<firstName>Joe</firstName>
	<lastName>Smith</lastName>
</employee>
<employee id = "43">
	<firstName>Susan</firstName>
	<lastName>Jones</lastName>
</employee>
	

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

Присваивает выражению expression1 значение выражения expression1 + expression2. Например, следующие две инструкции имеют одинаковый результат:

x += y; 
x = x + y;

var x1:String = "My name is "; 
x1 += "Gilbert"; 
trace(x1); // My name is Gilbert 

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

expression1 += expression2

Присваивает выражению expression1, представляющему собой объект XMLList, значение выражения expression1 + expression2. Например, следующие две инструкции имеют одинаковый результат:

x += y; 
x = x + y; 

var x1:XML = <location>Athens</location>;	
var x2:XML = <location>Paris</location>;		
myXMLList = x1 + x2;

var x3:XML = <location>Springfield</location>;
myXMLList += x3;
		    
trace(myXMLList.toXMLString());

Результатом инструкции trace будет следующее:

<location>Athens</location>
	
<location>Paris</location>	

<location>Springfield</location>

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

expression1 ? expression2 : expression3

Вычисляет expression1, и если значение expression1 равно true, результатом будет значение expression2, в противном случае результатом будет значение expression3.

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // returns 5

var timecode:String = (new Date().getHours() < 11) ? "AM" : "PM"; 
trace(timecode); 

if (new Date().getHours() < 11) { 
	var timecode:String = "AM"; 
} else { 
	var timecode:String = "PM"; 
}
trace(timecode); 

--expression

expression--

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

var x:Number = 3; 
var y:Number = --x; // y is equal to 2

var x:Number = 3; 
var y:Number = x--; // y is equal to 3

for (var i = 10; i > 0; i--) { 
	trace(i); 
}

 delete reference

Удаляет свойство объекта, заданное параметром reference. Результатом является значение true, если свойство не существует после завершения операции, в противном случае — false. Оператор delete возвращает true, если вызывается для несуществующего свойства или динамического свойства, не определенного в классе.

Оператор delete может возвратить значение false, если параметр reference не может быть удален. Невозможно удалить фиксированные свойства или переменные, объявленные при помощи инструкции var. Фиксированным свойством является переменная или метод, заявленные в определении класса.

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

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

// create the new object "account" 
var account:Object = new Object(); 
// assign property name to the account 
account.name = "Jon"; 
// delete the property 
delete account.name; 
trace(account.name); // undefined

// delete a nonexistent property
var fooDeleted:Boolean = delete account.foo;
trace(fooDeleted); // true

В следующем примере удаляется значение элемента массива, но значение свойства length не изменяется:

var my_array:Array = new Array(); 
my_array[0] = "abc"; // my_array.length == 1 
my_array[1] = "def"; // my_array.length == 2 
my_array[2] = "ghi"; // my_array.length == 3 
// my_array[2] is deleted, but Array.length is not changed 
delete my_array[2]; 
trace(my_array.length); // 3 
trace(my_array); // abc,def,

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

var my_array:Array = [ "abc", "def", "ghi" ];
var deleteWasSuccessful:Boolean

deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[1];
deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[2];

trace(my_array) // outputs: undefined,undefined,ghi

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

 delete reference

Удаляет элементы или атрибуты XML, заданные reference.

 
var x1:XML = <x1>
				<a id = "52">AYY</a>
				<a>AYY 2 </a>
				<b>BEE</b>
				<c>CEE</c>
			</x1>;

trace(x1.toXMLString());
trace("___________");

delete x1.a.@id;

trace(x1.toXMLString());
trace("___________");

delete x1.b;

trace(x1.toXMLString());
trace("___________");

delete x1.a;

trace(x1.toXMLString());

На выходе получается следующее:

<x1>
  <a id="52">AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <c>CEE</c>
</x1>
___________
<x1>
  <c>CEE</c>
</x1>

 
var xml:XML = 
			<order>
				<item id="121">hamburger</item>
				<item id="122">fries</item>
				<item id="123">chocolate shake</item>
			</order>;
delete xml.item[1].*;
delete xml.item[1].@*;
trace(xml);

Результатом для данного примера будет следующее:

<order>
  <tem id="121">hamburger</item>
  <item/>
  <item id="123">chocolate shake</item>
</order>

 myXML..childElement1..@attributeName 

Обеспечивает навигацию к потомкам объекта XML или XMLList либо (в сочетании с оператором @) находит соответствующие атрибуты потомков. Соответствующие элементы или атрибуты не обязательно должны быть прямыми дочерними компонентами объекта XML или XMLList (дочерними объектами первого уровня), они могут располагаться на более низком уровне дерева (например, быть дочерними объектами второго уровня). Результатом является объект XMLList, так как может совпадать несколько дочерних элементов или атрибутов.

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

var myXML:XML = <a>
			<b>one
				<c> 
					<b>two</b> 
				</c> 
			</b>
			<b>three</b>
		</a>;

trace(myXML..b[0].toXMLString());
trace("______________");
trace(myXML..b[1].toXMLString());
trace("______________");
trace(myXML..b[2].toXMLString());

Результатом будет следующее:

<b>
  one
  <c>
    <b>two</b>
  </c>
</b>
______________
<b>two</b>
______________
<b>three</b>

Для возврата потомков, имена которых совпадают с именами зарезервированных слов ActionScript, используйте метод XML.descendants() вместо оператора доступа к потомкам (..), как показано в следующем примере:

var xml:XML = 
<enrollees>
	<student id="239">
		<class name="Algebra" />
 		<class name="Spanish 2"/>
	</student>
	<student id="206">
		<class name="Trigonometry" />
 		<class name="Spanish 2" />
	</student>
 </enrollees>;
 trace(xml.descendants("class")); 
 

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Billy</firstName>
			<lastName>Einstein</lastName>
		</employee>
		<employee id = "43">
			<firstName>Sally</firstName>
			<lastName>Shostakovich</lastName>
		</employee>
	</employees>
	
trace(myXML..firstName); 
	// <firstName>Billy</firstName>
	// <firstName>Sally</firstName>
				
trace(myXML..@id); //4243

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

Делит expression1 на expression2. Результатом операции деления является число с плавающей запятой двойной точности.

trace(3/0);   // Infinity
trace(-3/0);  // -Infinity
trace(0/0);   // NaN

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

Присваивает выражению expression1 значение выражения expression1 / expression2. Например, следующие две инструкции идентичны:

x /= y; 
x = x / y;

var a:Number = 10; 
var b:Number = 2; 
a /= b; trace(a); // 5 

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

object.property_or_method

Обеспечивает доступ к переменным и методам класса, определяет и задает свойства объектов и разделяет импортированные пакеты или классы.

import flash.utils.Timer;

var obj:Object = new Object();
obj.propertyA = "hello";
trace(obj.propertyA);  // hello

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

myXML.childElement
myXML.@attributeName 

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

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

var xml:XML = 
	<student id="206">
		<class name="Trigonometry" />
		<class name="Spanish 2" />
	</student>;
trace(xml.elements("class"));
trace(xml.descendants("class")); 

var myXML:XML = 
	<employee id = "42">
		<firstName>Billy</firstName>
		<lastName>Einstein</lastName>
	</employee>;

trace(myXML.firstName); // Billy
trace(myXML.@id);       // 42

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

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

Если типы данных двух операндов совпадают, определение равенства зависит от типа данных операндов:

• Значения типа int, uint и Boolean считаются равными, если имеют одинаковое значение.
• Числа с совпадающими значениями считаются равными, если ни одно из них не принадлежит к типу NaN.
• Если оба операнда имеют значение null или undefined, они считаются равными.
• Строковые выражения равны, если имеют равное количество идентичных символов.
• В отношении объектов XML:
  • Если один из операндов является текстовым или атрибутным узлом, а другой имеет простое содержимое, оба операнда преобразуются в строки при помощи метода toString() и считаются равными, если совпадают получившиеся в результате строки.
  • В противном случае объекты считаются равными, только если совпадают полные имена, атрибуты и дочерние свойства обоих объектов.
• Объекты XMLList считаются равными, если имеют одинаковое количество свойств, порядок и значения которых совпадают.
• В случае с объектами Namespace значения считаются равными, если свойства uri обоих объектов совпадают.
• В случае с объектами QName значения считаются равными, если свойства uri и localName обоих объектов совпадают.
• Переменные, представляющие объекты, массивы и функции, сравниваются по ссылке. Две переменные равны, если ссылаются на один и тот же объект, массив или одну и ту же функцию. Два отдельных массива никогда не равны, даже если состоят из одинакового количества элементов.

• Операнды имеют значения undefined и null. В этом случае результатом будет true.
• В результате автоматического преобразования типов данных типы данных значений String, Boolean, int, uint и Number преобразуются в совместимые типы, и преобразованные значения равны. В этом случае операнды считаются равными.
• Один из операндов относится к типу XML с простым содержимым (hasSimpleContent() == true), и после преобразования обоих операндов в строки при помощи метода toString() получившиеся в результате строки равны.
• Один из операндов относится к типу XMLList, и одно из следующих условий истинно:
  • Свойство length объекта XMLList имеет значение 0, а другой объект имеет значение undefined.
  • Свойство length объекта XMLList имеет значение 1, и один элемент объекта XMLList совпадает с другим операндом.

var a:String = "David"
var b:String = "David"; 
if (a == b) { 
	trace("David is David"); 
} 

var a:Number = 5; 
var b:String = "5"; 
trace(a == b); // true

var c:Number = 1; 
var d:Boolean = true; 
trace(c == d); // true
var e:Number = 0; 
var f:Boolean = false; 
trace(e == f); // true

var g:String = "true";
var h:Boolean = true;
trace(g == h); // false

var firstArray:Array = new Array("one", "two", "three"); 
var secondArray:Array = new Array("one", "two", "three"); 
trace(firstArray == secondArray); // false 
/* Arrays are only considered equal 
if the variables refer to the same array. */
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // true 

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

Сравнивает два выражения. Если выражение expression1 больше выражения expression2, то результатом будет значение true. Если expression1 меньше или равно expression2, то результатом будет false.

Если оба операнда относятся к типу String, операнды сравниваются в алфавитном порядке; все прописные буквы идут перед строчными. В противном случае операнды сначала преобразуются в числа, затем сравниваются.

var a:String = "first";
var b:String = "First";
trace(a > b); // true

var c:Number = 5;
var d:String = "4";
trace(c > d); // true

var e: Number = 2;
var f:Boolean = true;
trace(e > f); // true

Сравнивает два выражения. Если выражение expression1 больше или равно выражению expression2, то результатом будет значение true, а если выражение expression1 меньше выражения expression2, то результатом будет значение false.

if (new Date().getHours() >= 12) { 
	trace("good afternoon"); 
} else { 
	trace("good morning"); 
}

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

Проверяет, является ли свойство частью определенного объекта. Для использования оператора in укажите имя свойства в качестве первого операнда и объект в качестве второго операнда. Если указанный объект содержит данное свойство, результатом будет значение true; в противном случае — false.

Если указанный объект является объектом Array, оператор in можно использовать,чтобы проверить действительность определенного номера индекса. При передаче целого числа в качестве первого операнда результатом будет true, если индекс входит в допустимый диапазон номеров индексов, в противном случае — false.

trace("PI" in Math);         // true
trace("myProperty" in Math); // false

В следующем примере оператор in используется для того, чтобы показать, что числа 0, 1 и 2 являются действительными номерами индексов в объекте myArray, а номер 3 — нет.

public var myArray:Array = ["zero", "one", "two"];
trace(0 in myArray); // true
trace(1 in myArray); // true
trace(2 in myArray); // true
trace(3 in myArray); // false

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

++expression

 expression++

Прибавляет 1 к выражению. Выражением может быть переменная, элемент массива или свойство объекта. Преинкрементная форма оператора (++expression) прибавляет 1 к expression и возвращает результат. Постинкрементная форма оператора (expression++) прибавляет 1 к expression и возвращает исходное значение expression (значение до сложения).

var preInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
    preInc.push(++i); 
} 
trace(preInc); // 1,2,3,4,5,6,7,8,9,10 

 
var postInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
   postInc.push(i++); 
} 
trace(postInc); // 0,1,2,3,4,5,6,7,8,9 

var i:int = 0; 
while (i++ < 5) { 
	trace("this is execution " + i); 
} 
/* output: 
   this is execution 1 
   this is execution 2 
   this is execution 3 
   this is execution 4 
   this is execution 5 
*/

Проверяет на прямую противоположность оператору равенства (==). Если expression1 равно expression2, то результатом будет false. Как и в случае с оператором равенства (==), определение равенства зависит от сравниваемых типов данных.

Если типы данных двух операндов совпадают, определение равенства зависит от типа данных операндов:

• Значения типа int, uint и Boolean считаются равными, если имеют одинаковое значение.
• Числа с совпадающими значениями считаются равными, если ни одно из них не принадлежит к типу NaN.
• Если оба операнда имеют значение null или undefined, они считаются равными.
• Строковые выражения равны, если имеют равное количество идентичных символов.
• В отношении объектов XML:
  • Если один из операндов является текстовым или атрибутным узлом, а другой имеет простое содержимое, оба операнда преобразуются в строки при помощи метода toString() и считаются равными, если совпадают получившиеся в результате строки.
  • В противном случае объекты считаются равными, только если совпадают полные имена, атрибуты и дочерние свойства обоих объектов.
• Объекты XMLList считаются равными, если имеют одинаковое количество свойств, порядок и значения которых совпадают.
• В случае с объектами Namespace значения считаются равными, если свойства uri обоих объектов совпадают.
• В случае с объектами QName значения считаются равными, если свойства uri и localName обоих объектов совпадают.
• Переменные, представляющие объекты, массивы и функции, сравниваются по ссылке. Две переменные равны, если ссылаются на один и тот же объект, массив или одну и ту же функцию. Два отдельных массива никогда не равны, даже если состоят из одинакового количества элементов.

• Операнды имеют значения undefined и null. В этом случае результатом будет true.
• В результате автоматического преобразования типов данных типы данных значений String, Boolean, int, uint и Number преобразуются в совместимые типы, и преобразованные значения равны. В этом случае операнды считаются равными.
• Один из операндов относится к типу XML с простым содержимым (hasSimpleContent() == true), и после преобразования обоих операндов в строки при помощи метода toString() получившиеся в результате строки равны.
• Один из операндов относится к типу XMLList, и одно из следующих условий истинно:
  • Свойство length объекта XMLList имеет значение 0, а другой объект имеет значение undefined.
  • Свойство length объекта XMLList имеет значение 1, и один элемент объекта XMLList совпадает с другим операндом.

trace(5 != 8); // true 
trace(5 != 5); // false 

var a:String = "David";
var b:String = "Fool";
if (a != b) { 
	trace("David is not a fool"); 
}

var a:Function = function() { trace("foo"); }; 
var b:Function = function() { trace("foo"); }; 
a(); // foo 
b(); // foo 
trace(a != b); // true 
a = b; 
a(); // foo 
b(); // foo 
trace(a != b); // false

var a:Array = [ 1, 2, 3 ]; 
var b:Array = [ 1, 2, 3 ]; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // true 
a = b; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // false

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

Проверяет, содержит ли цепочка прототипов выражения объект-прототип для function. Оператор instanceof используется для обратной совместимости с ECMAScript редакции 3 и может быть полезным для опытных программистов, которые предпочитают использовать наследование на базе прототипов с использованием функций конструктора вместо классов.

Для проверки соответствия объекта определенному типу данных используйте оператор is.

При использовании с классами оператор instanceof действует подобно оператору is, так как цепочка прототипов класса включает в себя все его суперклассы. Однако интерфейсы не включаются в цепочку прототипов, поэтому оператор instanceof всегда выдает значение false при использовании с интерфейсами, тогда как оператор is выдает значение true, если объект принадлежит классу, который реализует указанный интерфейс.

Примечание. Оператор is в ActionScript является эквивалентом оператора instanceof в Java.

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof Sprite);        // true
trace(mySprite instanceof DisplayObject); // true

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof IBitmapDrawable); // false
trace(mySprite is IBitmapDrawable);         // true

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

Проверяет совместимость объекта с определенным типом данных, классом или интерфейсом. Для сравнения типов используйте оператор is вместо оператора instanceof. Оператор is можно также использовать, чтобы проверить, реализует ли объект интерфейс.

import flash.display.*;
import flash.events.IEventDispatcher;

var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite);           // true
trace(mySprite is DisplayObject);    // true
trace(mySprite is IEventDispatcher); // true

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

Сравнивает два выражения. Если выражение expression1 меньше выражения expression2, то результатом будет значение true. Если expression1 больше или равно expression2, то результатом будет false.

Если оба операнда относятся к типу String, операнды сравниваются в алфавитном порядке; все прописные буквы идут перед строчными. В противном случае операнды сначала преобразуются в числа, затем сравниваются.

trace(5 < 10); // true 
trace(2 < 2);            // false 
trace(10 < 3);           // false 
trace("Allen" < "Jack"); // true 
trace("Jack" < "Allen"); // false 
trace("11" < "3");       // true 
trace("11" < 3);         // false (numeric comparison) 
trace("C" < "abc");      // true 
trace("A" < "a");        // true 

Сравнивает два выражения. Если выражение expression1 меньше или равно expression2, то результатом будет значение true. Если expression1 больше выражения expression2, то результатом будет false.

Если оба операнда относятся к типу String, операнды сравниваются в алфавитном порядке; все прописные буквы идут перед строчными. В противном случае операнды сначала преобразуются в числа, затем сравниваются.

trace(5 <= 10); // true 
trace(2 <= 2);            // true 
trace(10 <= 3);           // false 
trace("Allen" <= "Jack"); // true 
trace("Jack" <= "Allen"); // false 
trace("11" <= "3");       // true 
trace("11" <= 3);         // false (numeric comparison) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

Указывает на начало комментария в сценарии. Символы, расположенные между разделителем комментариев (//) и символом конца строки, воспринимаются как комментарий и игнорируются. Данный разделитель используется для однострочных комментариев. Для комментариев, занимающих несколько последовательных строк, используются разделители /* и */.

// Any text following a line comment delimiter is ignored during compilation

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

Возвращает выражение expression1, если оно имеет значение false или может быть преобразовано в false, в противном случае возвращает выражение expression2. Значениями, которые могут быть преобразованы в false, являются 0, NaN, null и undefined. Если в качестве expression2 используется вызов функции, функция не будет вызвана, если expression1 принимает значение false.

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

var turns:Number = 2; 
var score:Number = 77; 
if ((turns <= 3) && (score >= 75)) { 
	trace("You Win the Game!"); 
} else { 
	trace("Try Again!"); 
} 

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

Присваивает выражению expression1 значение выражения expression1 && expression2. Например, следующие две инструкции идентичны:

x &&= y; 
x = x && y; 

var myVar:String = 'tag';
			myVar &&= "<" + myVar + "/>";
			trace (myVar); // output: <tag/>

var myVar:String = 'tag';
			if (myVar != '') {
			  myVar = "<" + myVar + "/>";
			}
			trace (myVar); // output: <tag/>

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

Инвертирует логическое значение переменной или выражения. Если expression является переменной с абсолютным или преобразованным значением true, то значением !expression будет false. Если выражение x && y возвращает значение false, выражение !(x && y) возвращает значение true.

Следующие выражения иллюстрируют результат использования логического оператора NOT (!):

• !true возвращает false.
• !false возвращает true.

var happy:Boolean = false; 
if (!happy) { 
	trace("don't worry, be happy"); // don't worry, be happy 
} 

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

Возвращает выражение expression1, если оно имеет значение true или может быть преобразовано в true, в противном случае возвращает выражение expression2. Если в качестве expression2 используется вызов функции, функция не будет вызвана, если expression1 принимает значение true.

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

var a:Number = 10; 
var b:Number = 250; 
var start:Boolean = false; 
if ((a > 25) || (b > 200) || (start)) { 
    trace("the logical OR test passed"); // the logical OR test passed 
} 

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

function fx1():Boolean { 
	trace("fx1 called"); 
	return true; 
} 
function fx2():Boolean { 
	trace("fx2 called"); 
	return true; 
} 
if (fx1() || fx2()) { 
	trace("IF statement entered");
}

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

Присваивает выражению expression1 значение выражения expression1 || expression2. Например, следующие две инструкции идентичны:

x ||= y; 
x = x || y; 

myVar ||= "default";

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

Вычисляет остаток от деления выражения expression1 на expression2. Если один из операндов не является числом, оператор остатка от деления (%) попытается преобразовать его в число.

Знак результата вычисления остатка от деления совпадает со знаком делимого (первого числа). Например, результатом вычисления обоих выражений -4 % 3 и -4 % -3 будет -1.

trace(12 % 5);    // 2 
trace(4.3 % 2.1); // 0.0999999999999996 
trace(4 % 4);     // 0 

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

Присваивает выражению expression1 значение выражения expression1 % expression2. Следующие две инструкции идентичны:

x %= y; 
x = x % y; 

var a:Number = 14; 
var b:Number = 5; 
a %= b;
trace(a); // 4 

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

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

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

Присваивает выражению expression1 значение выражения expression1 * expression2. Например, следующие два выражения идентичны:

x *= y 
x = x * y 

var a:Number = 5; 
var b:Number = 10; 
trace(a *= b); // 50 

var i:Number = 5; 
var c:Number = 4 - 6; 
var d:Number = i + 2; 
trace(c *= d); // -14 

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

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Определяет пространство имен свойства, метода, свойства XML или атрибута XML.

public class NamespaceExample extends Sprite {
	public namespace French;
	public namespace Hawaiian;
	public function NamespaceExample() {
		trace(Hawaiian::hello()); // aloha
		trace(French::hello()); // bonjour
	}
    Hawaiian function hello():String {
        return "aloha";
    }

    French function hello():String { 
        return "bonjour";
    }
}

var soap:Namespace = new Namespace("http://schemas.xmlsoap.org/wsdl/soap/");
var w:Namespace = new Namespace("http://weather.example.org/forecast");
var myXML:XML = 
	<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"> 
	 <soap:Body>
	  <w:forecast xmlns:w="http://weather.example.org/forecast">
	   <w:city>Quito</w:city>
	   <w:country>Ecuador</w:country>
	   <date>2006-01-14</date>
	  </w:forecast>
	  </soap:Body>
	</soap:Envelope>;
	
trace(myXML.soap::Body.w::forecast.w::city); // Quito

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

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

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

Если вы предпочитаете определять классы с использованием объектов Function вместо ключевого слова class, то оператор new можно использовать для создания объектов на основе функций конструктора. Не путайте функции конструктора с методами конструктора класса. Функция конструктора — это объект Function, определенный при помощи ключевого слова function, но не являющийся частью определения класса. При использовании функций конструктора для создания объектов необходимо использовать наследование от прототипа вместо наследования от класса.

class Book {
  var bName:String;
  var bPrice:Number;
  
  public function Book(nameParam:String, priceParam:Number){
    bName = nameParam;
    bPrice = priceParam;
  }
}

var book1:Book = new Book("Confederacy of Dunces", 19.95);
var book2:Book = new Book("The Floating Opera", 10.95);
trace(book1); // [object Book]

var golfCourse:Array = new Array(18);

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

object = {name1 : value1, name2 : value2,... nameN : valueN}

Создает новый объект и инициализирует его с заданными парами свойств name и value. Использование данного оператора подобно использованию синтаксиса new Object и заполнению пар свойств при помощи оператора присваивания. Прототип вновь созданного объекта в общем называется объектом Object.

Данный оператор также используется для разграничения блоков последовательного кода, связанного с инструкциями управления процессом (for, while, if, else, switch) и функциями.

var object:Object = {}; 
var object:Object = new Object(); 

var account:Object = {name:"Adobe Systems, Inc.", address:"601 Townsend Street", city:"San Francisco", state:"California", zip:"94103", balance:"1000"}; 
for (i in account) { 
	trace("account."+i+" = "+account[i]); 
} 

var person:Object = {name:"Gina Vechio", children:["Ruby", "Chickie", "Puppa"]}; 

var person:Object = new Object(); 
person.name = "Gina Vechio"; 
person.children = new Array(); 
person.children[0] = "Ruby"; 
person.children[1] = "Chickie"; 
person.children[2] = "Puppa"; 

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

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

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

Применение 1. Определяет порядок выполнения операторов. Круглые скобки переопределяют обычный порядок старшинства так, что выражения в скобках вычисляются в первую очередь. В случае со вложенными круглыми скобками содержимое самых внутренних скобок вычисляется перед содержимым внешних.

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

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

trace((2 + 3) * (4 + 5)); // 45 
trace(2 + (3 * (4 + 5))); // 29
trace(2 + (3 * 4) + 5);   // 19
trace(2 + (3 * 4) + 5);   // 19

var a:Number = 1; 
var b:Number = 2; 
function foo() { 
  a += b; 
} 
function bar() { 
  b *= 10; 
} 
trace((foo(), bar(), a + b)); // 23 

var today:Date = new Date(); 
trace(today.getFullYear()); // outputs current year 
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

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

myXML.(expression)

Вычисляет выражение в ECMAScript для XML-конструкции XML (E4X). Например, myXML.(lastName == "Smith") определяет элементы XML с именем lastName и значением "Smith". Результатом является объект XMLList.

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>
		<employee id = "44">
			<firstName>Anne</firstName>
			<lastName>Smith</lastName>
		</employee>
	</employees>;
	
trace(myXML.employee.(lastName == "Smith").@id.toXMLString()); 
	// 42
	// 44
                
trace(myXML.employee.(Number(@id) > 42).@id.toXMLString()); 
	// 43
	// 44

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

/pattern/flags

При использовании перед символами и после них указывает на то, что символы имеют литеральное значение и считаются регулярным выражением (RegExp), а не переменной, строкой или другим элементом ActionScript. Однако заметьте, что две последовательные левые косые черты (//) указывают на начало комментария.

var myRegExp:RegExp = /foo-\d+/i; 
trace(myRegExp.exec("ABC Foo-32 def.")); // Foo-32 

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

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

Оператор строгого равенства (===) имеет три общих черты с оператором равенства (==):

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

• Оператор строгого равенства выполняет автоматическое преобразование данных только для числовых типов: Number, int и uint, тогда как оператор равенства выполняет автоматическое преобразование данных для всех примитивных типов данных.
• При сравнении значений null и undefined оператор строгого равенства возвращает false.

Во-первых, сравнения между примитивными значениями и примитивными объектами, содержащими одинаковые значения, возвращают значение true в ActionScript 3.0, но false в предыдущих версиях. В предыдущих версиях примитивные значения относятся к типу данных Boolean, Number или String, тогда как примитивный объект всегда относится к типу данных Object, а не Boolean, Number или String. На практике это различие проявляется в том, что следующий код даст в результате значение false в предыдущих версиях ActionScript, так как типы данных операндов не совпадают, но в ActionScript 3.0 результатом будет значение true, так как примитивные значения относятся к типу Boolean, Number, int, uint или String независимо от того, включены они в объект или нет.

var num1:Number = 1;
var num2:Number = new Number(1);
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0
			

var num1:Number = new Number(1);
var num2:Number = new Number(1);
trace(num1 == num2);  // true in ActionScript 3.0, false in ActionScript 2.0
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0

var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2);  // true 
trace(string1 === string2); // true

// The equality (==) operator converts 5 to "5", but the strict equality operator does not
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num);  // true 
trace(string1 === num); // false 

var num:Number = 1;
var bool:Boolean = true;
trace(num == bool);  // true 
trace(num === bool); // false

var num1:Number = 1;
var num2:int = 1;
var num3:uint = 1;
trace(num1 === num2); // true
trace(num1 === num3); // true

trace(null == undefined);  // true 
trace(null === undefined); // false 

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

Проверяет на прямую противоположность оператору строгого равенства (===). Оператор строгого неравенства работает так же, как и оператор неравенства, за исключением того, что преобразуются только типы данных int и uint.

Если expression1 равно expression2, и их типы данных равны, то результатом будет false.

Оператор строгого неравенства (!==) имеет три общих черты с оператором неравенства (!=):

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

• Оператор строгого неравенства (!==) выполняет автоматическое преобразование данных только для числовых типов: Number, int и uint, тогда как оператор неравенства (!=) выполняет автоматическое преобразование данных для всех примитивных типов данных.
• При сравнении значений null и undefined оператор строгого неравенства (!==) возвращает true.

var s1:String = "5"; 
var s2:String = "5"; 
var s3:String = "Hello"; 
var n:Number = 5; 
var b:Boolean = true; 
trace(s1 == s2);  // true 
trace(s1 == s3);  // false 
trace(s1 == n);   // true 
trace(s1 == b);   // false 
trace(s1 === s2); // true 
trace(s1 === s3); // false 
trace(s1 === n);  // false 
trace(s1 === b);  // false 
trace(s1 !== s2); // false 
trace(s1 !== s3); // true 
trace(s1 !== n);  // true 
trace(s1 !== b);  // true 

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

 "text" 

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

var yourGuess:String = "Prince Edward Island"; 
submit_btn.onRelease = function() { trace(yourGuess); }; 
// Prince Edward Island

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

-expression

 expression1 - expression2

Используется для отрицания или вычитания.

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

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

trace(-(2 + 3)); // -5 

trace(5 - 2); // 3 

Следующая инструкция вычитает число с плавающей запятой 1,5 из числа с плавающей запятой 3,25:

trace(3.25 - 1.5); // 1.75 

Присваивает выражению expression1 значение выражения expression1 - expression2. Например, следующие две инструкции идентичны:

x -= y ;
x = x - y;

Строковые выражения должны быть преобразованы в числа, в противном случае результатом будет значение NaN (не число).

var x:Number = 5; 
var y:Number = 10; 
x -= y; 
trace(x); // -5 

var x:String = "5"; 
var y:String = "10"; 
x -= y; 
trace(x); // -5 

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

[modifiers] var variableName:type

function functionName():type { ... }

function functionName(parameter1:type, ..., parameterN:type) [:type]{ ... } 

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

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

Допустимые типы включают в себя все собственные типы объектов, определяемые вами классы и интерфейсы, а также тип void. Распознаваемыми собственными типами являются Boolean, Number, int, uint и String. Все встроенные классы также поддерживаются как собственные типы.

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

var userName:String = ""; 

function randomInt(integer:int):int { 
	return Math.round(Math.random()*integer); 
} 
trace(randomInt(8)); 

function squareRoot(val:Number):Number { 
	return Math.sqrt(val); 
} 
trace(squareRoot(121)); 

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

Вычисляет выражение expression и возвращает строку, в которой указан тип данных выражения. В качестве результата может быть возвращено одно из возможных строковых значений: boolean, function, number, object, string и xml. В случае применения этого оператора к экземпляру класса, определенного пользователем, результатом будет строка object. Оператор typeof используется для обратной совместимости. При помощи оператора is можно проверить совместимость типов.

trace(typeof Array); // object
trace(typeof Date);  // object
trace(typeof 3);     // number

var a:String = "sample";
var b:String = new String("sample");
trace(typeof a); // string
trace(typeof b); // string 

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

Вычисляет выражение и удаляет его значение, возвращая undefined. Оператор void часто используется в операциях сравнения, в которых используется оператор == для проверки значений типа undefined.

 myXML= <{tagName} {attributeName} = {attributeValue}>{content}

Определяет тег XML в литерале XML. Для определения закрывающего тега используйте левую косую черту /.

var x:XML = <item id= "324">cola</item>; 

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