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

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

См. также

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

x += y; 
x = x + y; 

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

См. также

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]]; 
			
/* Выберите "Отладка" > "Создать список переменных" в тестовом режиме, 
чтобы просмотреть список элементов массива.*/ 

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]);
} 
/* Вывод цикла for: 
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]);
}
/* Вывод цикла for:
foo
bar */ 

См. также

Проверяет, относится ли выражение, заданное первым операндом, к типу данных, заданному вторым операндом. Если первый операнд относится к этому типу данных, результатом будет первый операнд. В противном случае результатом будет значение 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

См. также

Присваивает значение выражения 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; // в милях
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // в километрах
trace(mercury.diameter); // 4878

См. также

 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()); // атрибут
    trace(xml2[i].name());     // id и color
 } 

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

См. также

Преобразует выражения 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 (или двоичное 1001) 

  1101
& 1011
  ----
  1001

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

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

См. также

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

x &= y; 
x = x & y; 

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

См. также

Преобразует выражения 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() предотвращает возникновение ошибки этапа выполнения

x = 1 << 10

   двоичное 00000000001 
<<          десятичное 10
--------------
   двоичное 10000000000 равно десятичному 1024 

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

x = 7 << 8

   двоичное 00000000111 
<<          десятичное 8
--------------
   двоичное 11100000000 равно десятичному 1792 

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

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

См. также

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

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

var x:Number = 4; 
// Сдвиг всех битов на одну позицию влево. 
x <<= 1; 
trace(x); // 8 
// десятичное 4 = двоичное 0100 
// десятичное 8 = двоичное 1000 

См. также

Преобразует 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; // определяет бит 0 как флаг только для чтения 
var flags:int = 0; 
trace(flags); 
/* Чтобы задать флаг только для чтения в переменной flags, 
   в следующем коде используется побитовый оператор OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* Чтобы очистить флаг только для чтения в переменной flags, 
   сначала создайте маску, применив побитовый оператор NOT к ReadOnlyFlag. 
   В маске каждый бит равен 1 кроме флага только для чтения. 
   Затем примените побитовый оператор AND к маске, чтобы очистить флаг только для чтения. 
   В следующем коде создается маска и выполняется побитовый оператор AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

См. также

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

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

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

// десятичное 15 = двоичное 1111 
var a:Number = 15; 
// десятичное 9 = двоичное 1001 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // возвращает десятичное 15 (двоичное 1111) 

См. также

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

x |= y; 
x = x | y; 

// десятичное 15 = двоичное 1111 
var a:Number = 15; 
// десятичное 9 = двоичное 1001 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // возвращает десятичное 15 (двоичное 1111) 

См. также

Преобразует выражения 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 (десятичное 65535)
>>                                 десятичное 8
--------------------
    двоичное 00000000000000000000000011111111 (десятичное 255)

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

    двоичное 11111111111111111111111111111000 (десятичное -8)
>>                                десятичное 1
--------------------
    двоичное 11111111111111111111111111111100 (десятичное -4)

См. также

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

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

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

function convertToBinary(numberToConvert:Number):String { 
    var result:String = ""; 
    for (var i = 0; i < 32; i++) { 
        // Извлечение наименее значащего бита при помощи побитового AND. 
        var lsb:Number = numberToConvert & 1; 
        // Добавление этого бита в результат.
        result = (lsb ? "1" : "0")+result; 
        // Сдвиг numberToConvert вправо на один бит, чтобы увидеть следующий бит. 
        numberToConvert >>= 1; 
    } 
    return result; 
} 
trace(convertToBinary(479)); 
// Возвращает строку 00000000000000000000000111011111. 
// Эта строка является двоичным представлением десятичного числа 479.

См. также

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

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

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

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

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

См. также

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

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

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

См. также

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

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

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

// десятичное 15 = двоичное 1111 
// десятичное 9 = двоичное 1001 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// возвращает десятичное 6 (двоичное 0110) 

См. также

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

x ^= y 
x = x ^ y 

// десятичное 15 = двоичное 1111 
var a:Number = 15; 
// десятичное 9 = двоичное 1001 
var b:Number = 9; 
trace(a ^= b); // возвращает десятичное 6 (двоичное 0110) 

См. также

/* комментарий */

/* комментарий

   комментарий */

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

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

/* записывает положение X и Y 
фрагментов роликов ball и bat */ 
var ballX:Number = ball_mc._x; 
var ballY:Number = ball_mc._y; 
var batX:Number = bat_mc._x; 
var batY:Number = bat_mc._y; 

/* Это попытка вложить комментарий. 
/* Но первый закрывающий тег будет соотнесен 
с первым открывающим тегом */ 
и этот текст не будет воспринят как комментарий */ 

См. также

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

Вычисляет выражение, которое используется в инициализаторе 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>

См. также

 myXML[expression]

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

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

См. также

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

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
    trace("i = " + i + ", j = " + j); 
} 
// вывод: 
// 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 

См. также

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

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

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 

См. также

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>
    

См. также

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

x += y; 
x = x + y;

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

См. также

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>

См. также

expression1 ? expression2 : expression3

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

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // возвращает 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 равно 2

var x:Number = 3; 
var y:Number = x--; // y равно 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. Сборщик мусора удаляет любой объект, на который нет ни одной ссылки.

// создание нового объекта "account" 
var account:Object = new Object(); 
// присваивание свойства name объекту account 
account.name = "Jon"; 
// удаление свойства 
delete account.name; 
trace(account.name); // undefined

// удаление несуществующего свойства
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] удален, но Array.length не изменяется 
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) // вывод: undefined,undefined,ghi

См. также

 delete reference

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

При использовании с операндом XMLList результатом оператора delete всегда является значение true, так как операнд XMLList всегда ссылается на действительный объект (хотя, возможно, и пустой) XMLList.

 
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

См. также

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

trace(3/0);   // Бесконечность
trace(-3/0);  // Минус бесконечность
trace(0/0);   // NaN

См. также

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

x /= y; 
x = x / y;

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

См. также

object.property_or_method

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

import flash.utils.Timer;

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

См. также

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

См. также

Проверяет равенство двух выражений. Если выражения равны, результатом будет значение 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 
/* Массивы считаются равными, только 
если переменные ссылаются на один и тот же массив. */
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // true 

См. также

Сравнивает два выражения. Если выражение 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"); 
}

См. также

Проверяет, является ли свойство частью определенного объекта. Для использования оператора 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

См. также

++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); 
} 
/* вывод: 
   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

См. также

Проверяет, содержит ли цепочка прототипов выражения объект-прототип для 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

См. также

Проверяет совместимость объекта с определенным типом данных, классом или интерфейсом. Для сравнения типов используйте оператор 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

См. также

Сравнивает два выражения. Если выражение 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 (числовое сравнение) 
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 (числовое сравнение) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

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

// Любой текст, идущий после разделителя строчных комментариев, игнорируется во время компиляции

См. также

Возвращает выражение 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!"); 
}

См. также

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

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

var myVar:String = 'tag';
myVar &&= "<" + myVar + "/>";
trace (myVar); // вывод: <tag/>

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

См. также

Инвертирует логическое значение переменной или выражения. Если 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 
} 

См. также

Возвращает выражение 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");
}

См. также

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

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

myVar ||= "default";

См. также

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

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

trace(12 % 5);    // 2 
trace(4,3 % 2,1);    // 0.0999999999999996 
trace(4 % 4);     // 0 

См. также

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

x %= y; 
x = x % y; 

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

См. также

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

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 

См. также

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

См. также

Создает экземпляр класса. Оператор 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); // [объект Book]

var golfCourse:Array = new Array(18);

См. также

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

См. также

(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()); // выводит текущий год 
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

См. также

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

См. также

/pattern/flags

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

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

См. также

Проверяет равенство двух выражений, но не выполняет автоматическое преобразование данных. Если оба выражения, включая их типы данных, равны, результатом будет значение 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 в ActionScript 3.0, false в ActionScript 2.0
			

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

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

// Оператор равенства (==) преобразует 5 в "5", а оператор строгого равенства - нет
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 

См. также

Проверяет на прямую противоположность оператору строгого равенства (===). Оператор строгого равенства работает так же, как и оператор неравенства, за исключением того, что преобразуются только типы данных 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 

См. также

 "текст" 

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

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

См. также

-expression

 expression1 - expression2

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

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

Применение 2: При использовании для вычитания этот оператор выполняет операцию арифметического вычитания над двумя числовыми выражениями, вычитая expression2 из 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 

См. также

[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)); 

См. также

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

См. также

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

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

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

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

См. также