Operatory 

Dodaje wyrażenia liczbowe. Jeśli oba wyrażenia są liczbami całkowitymi, suma jest liczbą całkowitą; jeśli co najmniej jedno wyrażenie jest liczbą zmiennopozycyjną, suma jest liczbą zmiennopozycyjną.

Jeśli jedno wyrażenie jest ciągiem znaków, wszystkie pozostałe wyrażenia są konwertowane na ciągi znaków i konkatenowane, a nie sumowane. W przeciwnym razie, jeśli wyrażenie nie jest liczbą, program Flash^® Player konwertuje je na liczbę.

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

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 + expression2. Na przykład następujące dwie instrukcje odniosą ten sam skutek:

x += y; 
x = x + y; 

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

Powiązane elementy interfejsu API

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

Inicjuje nową tablicę lub tablicę wielowymiarową określonymi elementami (a0 itd.) oraz umożliwia dostęp do elementów w tablicy. Operator dostępu do tablicy umożliwia dynamiczne ustawianie i pobieranie nazw instancji, zmiennych i obiektów. Umożliwia także dostęp do właściwości obiektów.

Zastosowanie 1: Tablica jest obiektem, którego właściwości nazywane są elementami; każdy z elementów jest identyfikowany przez liczbę nazywaną indeksem. Tworząc tablicę, jej elementy ujmuje się w nawiasy kwadratowe ([]), które są operatorem dostępu do tablicy. Jedna tablica może zawierać elementy różnych typów. Na przykład poniższa tablica o nazwie employee ma trzy elementy: pierwszy jest liczbą, a następne dwa są ciągami znaków (ujętymi w cudzysłów):

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

Poniższy kod tworzy tablicę o nazwie employee_array zawierającą trzy elementy i zmienia trzeci element tej tablicy.

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

Powiązane elementy interfejsu API

Sprawdza, czy wyrażenie określone przez pierwszy operand jest elementem typu danych określonego przez drugi operand. Jeśli pierwszy operand należy do typu danych, wynikiem jest pierwszy operand. W przeciwnym wypadku wynikiem jest wartość null.

Wyrażenie użyte w charakterze drugiego operandu musi po wyznaczeniu jego wartości zwracać typ danych.

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

Powiązane elementy interfejsu API

Przypisuje wartość wyrażenia expression2 (operandu po prawej stronie) zmiennej, elementowi tablicy lub właściwości w wyrażeniu expression1. Możliwe są przypisania przez wartość lub przez odwołanie. Przypisanie przez wartość polega na skopiowaniu faktycznej wartości wyrażenia expression2 do obiektu expression1. Przypisanie przez wartość jest stosowane, gdy wyrażenie expression2 jest wartością pierwotną, co oznacza, że jego typem danych jest Boolean, Number, int, uint lub String. Przypisanie przez odwołanie polega na zapisaniu odwołania do obiektu expression2 w obiekcie expression1. Przypisanie przez odwołanie jest często stosowane razem z operatorem new. Operator new tworzy obiekt w pamięci, a odwołanie do odpowiedniego miejsca w pamięci jest przypisywane zmiennej.

Uwaga: W języku ActionScript 3.0 wszystkie wartości (w tym wartości pierwotne) są obiektami i wszystkie przypisania są faktycznie realizowane przez odwołanie, jednak z obiektami pierwotnymi są skojarzone operatory specjalne, dzięki którym obiekty te mogą zachowywać się tak, jak gdyby były przypisane przez wartość.

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

Powiązane elementy interfejsu API

 myXML.@attributeName 

Identyfikuje atrybuty obiektu XML lub XMLList. Na przykład, myXML.@id identyfikuje atrybuty o nazwie id obiektu XML myXML. Można również użyć następującej składni w celu uzyskania dostępu do atrybutów: myXML.attribute("id"), myXML["@id"] oraz myXML.@["id"]. Zalecana składnia to myXML.@id. Aby zwrócić obiekt XMLList z listą wszystkich nazw atrybutów, należy użyć zapisu @*. Aby zwrócić atrybut o nazwie dopasowanej do słowa zastrzeżonego języka ActionScript, należy użyć metody attribute() zamiast operatora @.

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

Powiązane elementy interfejsu API

Konwertuje wyrażenia expression1 i expression2 na 32-bitowe liczby całkowite bez znaku i wykonuje logiczną operację AND na parach odpowiednich bitów tych parametrów całkowitoliczbowych. Liczby zmiennopozycyjne są konwertowane na liczby całkowite poprzez usunięcie cyfr po kropce dziesiętnej. Wynik jest nową 32-bitową liczbą całkowitą.

Dodatnia liczba całkowita jest konwertowana na liczbę szesnastkową bez znaku o maksymalnej wartości 4294967295 lub 0xFFFFFFFF; w wartościach większych od maksymalnej cyfry najbardziej znaczące są usuwane podczas konwersji, tak aby wartości były zawsze 32-bitowe. Liczba ujemna jest konwertowana na liczbę szesnastkową bez znaku przy wykorzystaniu notacji dopełnienia do dwóch, z minimalną wartością -2147483648 lub 0x800000000; liczby mniejsze od minimalnej wartości są konwertowane do wartości z dopełnieniem do dwóch o większej precyzji, a następnie najbardziej znaczące cyfry są usuwane.

Wynik jest interpretowany jako 32-bitowa liczba z dopełnieniem do dwóch, a więc jest liczbą całkowitą z zakresu od -2147483648 do 2147483647.

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

  1101
& 1011
  ----
  1001

Poniższe przykłady ilustrują konwersję wartości zwracanej:

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

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 & expression2. Na przykład następujące dwa wyrażenia są równoważne:

x &= y; 
x = x & y; 

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

Powiązane elementy interfejsu API

Konwertuje wyrażenie expression1 i shiftCount na 32-bitowe liczby całkowite, a następnie przesuwa wszystkie bity wartości expression1 w lewo o liczbę pozycji określoną przez liczbę całkowitą będącą wynikiem konwersji wartości shiftCount. Pozycje bitowe opróżnione w wyniku tej operacji są wypełniane zerami, a bity wysunięte w lewo są usuwane. Przesunięcie wartości w lewo o jedną pozycję jest równoważne pomnożeniu jej przez 2.

Liczba zmiennopozycyjna jest konwertowana na całkowitą poprzez usunięcie cyfr po kropce dziesiętnej. Dodatnia liczba całkowita jest konwertowana na liczbę szesnastkową bez znaku o maksymalnej wartości 4294967295 lub 0xFFFFFFFF; w wartościach większych od maksymalnej cyfry najbardziej znaczące są usuwane podczas konwersji, tak aby wartości były zawsze 32-bitowe. Liczba ujemna jest konwertowana na liczbę szesnastkową bez znaku przy wykorzystaniu notacji dopełnienia do dwóch, z minimalną wartością -2147483648 lub 0x800000000; liczby mniejsze od minimalnej wartości są konwertowane do wartości z dopełnieniem do dwóch o większej precyzji, a następnie najbardziej znaczące cyfry są usuwane.

Wynik jest interpretowany jako 32-bitowa liczba z dopełnieniem do dwóch, a więc jest liczbą całkowitą z zakresu od -2147483648 do 2147483647.

Jeśli wynik jest ujemną liczbą całkowitą, próba przypisania go do zmiennej typu uint spowoduje błąd w czasie wykonywania. Mimo że w języku ActionScript nie ma operatora „przesunięcia bitowego w lewo bez uwzględnienia znaku”, można uzyskać podobny efekt i uniknąć błędu w czasie wykonywania, stosując zapis 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 

W następującym przykładzie liczba całkowita 7 jest przesuwana o 8 bitów w lewo:

x = 7 << 8

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

Poniższa instrukcja trace wykazuje, że bity zostały przesunięte o trzy pozycje w lewo:

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

Powiązane elementy interfejsu API

Wykonuje przesunięcie bitowe w lewo (<<=) i przypisuje wynik w wyrażeniu expression1. Następujące dwa wyrażenia są równoważne:

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 

Powiązane elementy interfejsu API

Konwertuje wartość wyrażenia expression na 32-bitową liczbę całkowitą ze znakiem, a następnie wykonuje na niej operację bitowego dopełnienia do jedynek. Oznacza to, że każdy bit o wartości 0 jest w wyniku ustawiany na 1, a każdy bit o wartości 1 jest w wyniku ustawiany na 0. Wynik jest 32-bitową liczbą całkowitą ze znakiem. Ten operator jest nazywany także operatorem dopełnienia bitowego lub dopełnienia do jedynek.

Na przykład wartość szesnastkowa 0x7777 w zapisie dwójkowym ma postać:

0111011101110111

Wynik negacji bitowej tej wartości szesnastkowej, ~0x7777, w zapisie dwójkowym ma postać:

1000100010001000

W zapisie szesnastkowym jest to liczba 0x8888. A zatem ~0x7777 równa się 0x8888.

Operatory bitowe są stosowane najczęściej na wartościach zawierających bity flag (tj. wartości logiczne, z których każda zajmuje 1 bit).

Liczba zmiennopozycyjna jest konwertowana na całkowitą poprzez usunięcie cyfr po kropce dziesiętnej. Dodatnia liczba całkowita jest konwertowana na liczbę szesnastkową bez znaku o maksymalnej wartości 4294967295 lub 0xFFFFFFFF; w wartościach większych od maksymalnej cyfry najbardziej znaczące są usuwane podczas konwersji, tak aby wartości były zawsze 32-bitowe. Liczba ujemna jest konwertowana na liczbę szesnastkową bez znaku przy wykorzystaniu notacji dopełnienia do dwóch, z minimalną wartością -2147483648 lub 0x800000000; liczby mniejsze od minimalnej wartości są konwertowane do wartości z dopełnieniem do dwóch o większej precyzji, a następnie najbardziej znaczące cyfry są usuwane.

Wynik jest interpretowany jako 32-bitowa liczba z dopełnieniem do dwóch, a więc jest liczbą całkowitą z zakresu od -2147483648 do 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 

Powiązane elementy interfejsu API

Konwertuje wyrażenia expression1 i expression2 na 32-bitowe liczby całkowite bez znaku i umieszcza 1 na wszystkich pozycjach bitowych, na których odpowiednie bity wyrażenia expression1, wyrażenia expression2 lub obu tych wyrażeń są równe 1.

Liczba zmiennopozycyjna jest konwertowana na całkowitą poprzez usunięcie cyfr po kropce dziesiętnej. Dodatnia liczba całkowita jest konwertowana na liczbę szesnastkową bez znaku o maksymalnej wartości 4294967295 lub 0xFFFFFFFF; w wartościach większych od maksymalnej cyfry najbardziej znaczące są usuwane podczas konwersji, tak aby wartości były zawsze 32-bitowe. Liczba ujemna jest konwertowana na liczbę szesnastkową bez znaku przy wykorzystaniu notacji dopełnienia do dwóch, z minimalną wartością -2147483648 lub 0x800000000; liczby mniejsze od minimalnej wartości są konwertowane do wartości z dopełnieniem do dwóch o większej precyzji, a następnie najbardziej znaczące cyfry są usuwane.

Wynik jest interpretowany jako 32-bitowa liczba z dopełnieniem do dwóch, a więc jest liczbą całkowitą z zakresu od -2147483648 do 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) 

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 | expression2. Na przykład następujące dwie instrukcje są równoważne:

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) 

Powiązane elementy interfejsu API

Konwertuje wyrażenie expression i shiftCount na 32-bitowe liczby całkowite, a następnie przesuwa wszystkie bity wartości expression w prawo o liczbę pozycji określoną przez liczbę całkowitą będącą wynikiem konwersji wartości shiftCount. Bity wysunięte z prawej strony są usuwane. Aby zachowany został znak pierwotnego wyrażenia, bity po lewej stronie są wypełniane zerami, jeśli najbardziej znaczący (skrajny lewy) bit wartości expression jest równy 0, lub wypełniane jedynkami, jeśli najbardziej znaczący bit jest równy 1. Przesunięcie wartości o jedną pozycję w prawo jest równoznaczne z podzieleniem jej przez 2 i odrzuceniem reszty.

Liczba zmiennopozycyjna jest konwertowana na całkowitą poprzez usunięcie cyfr po kropce dziesiętnej. Dodatnia liczba całkowita jest konwertowana na liczbę szesnastkową bez znaku o maksymalnej wartości 4294967295 lub 0xFFFFFFFF; w wartościach większych od maksymalnej cyfry najbardziej znaczące są usuwane podczas konwersji, tak aby wartości były zawsze 32-bitowe. Liczba ujemna jest konwertowana na liczbę szesnastkową bez znaku przy wykorzystaniu notacji dopełnienia do dwóch, z minimalną wartością -2147483648 lub 0x800000000; liczby mniejsze od minimalnej wartości są konwertowane do wartości z dopełnieniem do dwóch o większej precyzji, a następnie najbardziej znaczące cyfry są usuwane.

Wynik jest interpretowany jako 32-bitowa liczba z dopełnieniem do dwóch, a więc jest liczbą całkowitą z zakresu od -2147483648 do 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)

Powiązane elementy interfejsu API

Wykonuje operację bitowego przesunięcia w prawo i zapisuje wynik w wyrażeniu expression.

Następujące dwie instrukcje są równoważne:

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.

Powiązane elementy interfejsu API

Działa tak samo jak operator przesunięcia bitowego w prawo (>>) poza tym, że nie zachowuje znaku pierwotnego wyrażenia, ponieważ bity po lewej stronie są zawsze wypełniane zerami.

Liczba zmiennopozycyjna jest konwertowana na całkowitą poprzez usunięcie cyfr po kropce dziesiętnej. Dodatnia liczba całkowita jest konwertowana na liczbę szesnastkową bez znaku o maksymalnej wartości 4294967295 lub 0xFFFFFFFF; w wartościach większych od maksymalnej cyfry najbardziej znaczące są usuwane podczas konwersji, tak aby wartości były zawsze 32-bitowe. Liczba ujemna jest konwertowana na liczbę szesnastkową bez znaku przy wykorzystaniu notacji dopełnienia do dwóch, z minimalną wartością -2147483648 lub 0x800000000; liczby mniejsze od minimalnej wartości są konwertowane do wartości z dopełnieniem do dwóch o większej precyzji, a następnie najbardziej znaczące cyfry są usuwane.

Wynik jest interpretowany jako 32-bitowa liczba bez znaku, a więc jest liczbą całkowitą z zakresu od 0 do 4294967295.

Uwaga: W języku ActionScript nie ma komplementarnego operatora „przesunięcia bitowego w lewo bez uwzględnienia znaku”, można uzyskać podobny efekt, stosując zapis uint(expression << shiftCount).

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

Powiązane elementy interfejsu API

Wykonuje operację bitowego przesunięcia w prawo bez zachowania znaku i zapisuje wynik w wyrażeniu expression. Następujące dwie instrukcje są równoważne:

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

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

Powiązane elementy interfejsu API

Konwertuje wyrażenia expression1 i expression2 na 32-bitowe liczby całkowite bez znaku i umieszcza 1 na wszystkich pozycjach bitowych, na których odpowiednie bity jednego z wyrażeń, expression1 albo expression2, (ale nie obu) są równe 1.

Liczba zmiennopozycyjna jest konwertowana na całkowitą poprzez usunięcie cyfr po kropce dziesiętnej. Dodatnia liczba całkowita jest konwertowana na liczbę szesnastkową bez znaku o maksymalnej wartości 4294967295 lub 0xFFFFFFFF; w wartościach większych od maksymalnej cyfry najbardziej znaczące są usuwane podczas konwersji, tak aby wartości były zawsze 32-bitowe. Liczba ujemna jest konwertowana na liczbę szesnastkową bez znaku przy wykorzystaniu notacji dopełnienia do dwóch, z minimalną wartością -2147483648 lub 0x800000000; liczby mniejsze od minimalnej wartości są konwertowane do wartości z dopełnieniem do dwóch o większej precyzji, a następnie najbardziej znaczące cyfry są usuwane.

Wynik jest interpretowany jako 32-bitowa liczba z dopełnieniem do dwóch, a więc jest liczbą całkowitą z zakresu od -2147483648 do 2147483647.

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

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 ^ expression2. Na przykład następujące dwie instrukcje są równoważne:

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) 

Powiązane elementy interfejsu API

/* comment */

/* comment

   comment */

Stanowi ogranicznik jednego lub wielu wierszy komentarza w skrypcie. Znaki między ogranicznikiem otwierającym (/*) a ogranicznikiem zamykającym (*/) są interpretowane jako komentarz i ignorowane przez kompilator języka ActionScript. Tych ograniczników należy używać do oznaczania komentarzy zajmujących wiele kolejnych wierszy; do oznaczania komentarzy jednowierszowych należy używać ogranicznika //.

Pominięcie ogranicznika zamykającego blok komentarza (*/) lub próba zagnieżdżenia komentarza spowoduje zgłoszenie błędu. Pierwszy ogranicznik zamykający (*/) po ograniczniku otwierającym (/*) kończy komentarz, niezależnie od liczby umieszczonych przed nim ograniczników otwierających.

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

Powiązane elementy interfejsu API

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

Wyznacza wartość wyrażenia używanego do inicjowania obiektu XML lub XMLList. Wartość inicjująca obiekt XML lub XMLList to wartość literalna przypisywana zmiennej typu XML lub XMLList. Wyrażenie ograniczone operatorami XML {and} może być użyte do inicjowania obiektu XML lub XMLList zamiast literalnych nazw lub wartości. W miejsce parametrów tagName, attributeName, attributeValue i content można używać wyrażeń.

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>

Powiązane elementy interfejsu API

 myXML[expression]

Umożliwia dostęp do właściwości lub atrybutu obiektu XML lub XMLList. Operator nawiasów kwadratowych umożliwia uzyskanie dostępu do właściwości o nazwach, które są niedostępne za pośrednictwem operatora kropki (.).

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

Powiązane elementy interfejsu API

Wyznacza wartość wyrażenia expression1, następnie expression2 i tak dalej. Ten operator jest używany przede wszystkim w instrukcji pętli for, często razem z operatorem nawiasów ().

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 

Powiązane elementy interfejsu API

Przeprowadza konkatenację (połączenie) ciągów. Jeśli jedno wyrażenie jest ciągiem znaków, wszystkie pozostałe wyrażenia są konwertowane na ciągi znaków i konkatenowane.

Jeśli oba wyrażenia są liczbami, operator ten działa tak samo, jak operator dodawania.

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 

Powiązane elementy interfejsu API

expression1 + expression2

Konkatenuje (łączy) wartości XML lub XMLList w obiekt klasy XMLList. Wynikiem konkatenacji jest obiekt XMLList pod warunkiem, że oba operandy są wartościami klasy XML lub 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()); 

Instrukcja trace wygeneruje następujące wyniki:

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

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 + expression2. Na przykład następujące dwie instrukcje odniosą ten sam skutek:

x += y; 
x = x + y;

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

Powiązane elementy interfejsu API

expression1 += expression2

Przypisuje wyrażeniu expression1 (które jest obiektem XMLList) wartość expression1 + expression2. Na przykład następujące dwie instrukcje odniosą ten sam skutek:

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

Instrukcja trace wygeneruje następujące wyniki:

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

<location>Springfield</location>

Powiązane elementy interfejsu API

expression1 ? expression2 : expression3

Wyznacza wartość wyrażenia expression1 i jeśli wyrażenie expression1 jest równe true, wynikiem jest wartość expression2; w przeciwnym razie wynikiem jest wartość 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--

Odejmuje 1 od operandu. Operand może być zmienną, elementem tablicy lub właściwością obiektu. Operator w formie dekrementacji poprzedzającej (--expression) odejmuje 1 od wartości expression i zwraca wynik. Operator w formie dekrementacji następującej (expression--) odejmuje 1 od wartości expression i zwraca pierwotną wartość wyrażenia expression (tj. jego wartość przed odejmowaniem).

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

Niszczy właściwość obiektu określoną przez operand reference; wynikiem jest wartość true, jeśli właściwość nie istnieje po ukończeniu operacji, albo wartość false w przeciwnym wypadku. Operator delete zwraca wartość true, jeśli zostanie wywołany na nieistniejącej właściwości lub właściwości dynamicznej niezdefiniowanej w klasie.

Działanie operatora delete może zakończyć się niepowodzeniem i zwróceniem wartości false, jeśli parametr reference określa właściwość, której nie można usunąć. Nie można usuwać właściwości ustalonych ani zmiennych zadeklarowanych za pomocą instrukcji var. Właściwość ustalona jest to zmienna lub metoda zdefiniowana w definicji klasy.

Operatora delete nie można używać do niszczenia właściwości klas innych niż dynamiczne klasy dodane w czasie wykonywania. Za pomocą operatora delete nie można niszczyć właściwości klas zapieczętowanych. Zamiast tego należy przypisać właściwości wartość null.

Uwaga: Nie jest możliwe usunięcie obiektu, ale usuwając wszystkie odwołania do obiektu, można spowodować uwzględnienie go w procesie czyszczenia pamięci. Najczęściej spotykanym rodzajem odwołania do obiektu jest zmienna, która na niego wskazuje. Takie odwołanie można usunąć, przypisując zmiennej wartość null. Proces czyszczenia pamięci usuwa z pamięci wszelkie obiekty, do których nie ma odwołań.

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

Poniższy przykładowy kod usuwa element tablicy, ale wartość właściwości length nie ulega zmianie:

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,

Poniższy przykład ilustruje, w jaki sposób wartość Boolean zwrócona przez operator delete może posłużyć jako warunek w dalszym wykonaniu kodu. Należy zwrócić uwagę, że jeśli element został już usunięty, wywołanie delete na tym elemencie ponownie zwróci wartość 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

Powiązane elementy interfejsu API

 delete reference

Usuwa elementy lub atrybuty XML określone przez parametr 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());

Wynik będzie następujący:

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

Wynik działania tego kodu przykładowego jest następujący:

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

 myXML..childElement1..@attributeName 

Powoduje przejście do elementów potomnych obiektu XML lub XMLList albo (w połączeniu z operatorem @) znajduje dopasowane atrybuty elementów potomnych. Dopasowane elementy lub atrybuty nie muszą być bezpośrednimi potomkami obiektu XML lub XMLList; mogą znajdować się niżej w hierarchii (np. być potomkami drugiego rzędu, tj. „wnukami”). Wynikiem jest obiekt klasy XMLList, ponieważ możliwe jest dopasowanie więcej niż jednego elementu potomnego lub atrybutu.

Kolejność węzłów w zwróconym obiekcie XMLList wynika z przejścia przez elementy począwszy od najgłębiej położonego. Przykład:

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

Uzyskane wyniki byłyby następujące:

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

Aby zwrócić wszystkie obiekty potomne o nazwach zgodnych z wyrazem zastrzeżonym w narzędziu ActionScript, należy użyć metody XML.descendants() zamiast operatora descendant (..), co ilustruje następujący przykład:

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

Powiązane elementy interfejsu API

Dzieli wartość expression1 przez wartość expression2. Wynikiem dzielenia jest liczba zmiennopozycyjna o podwójnej precyzji.

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

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 / expression2. Na przykład następujące dwie instrukcje są równoważne:

x /= y; 
x = x / y;

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

Powiązane elementy interfejsu API

object.property_or_method

Umożliwia dostęp do zmiennych i metod oraz pobieranie i ustawianie właściwości obiektów, a także stanowi ogranicznik importowanych pakietów i klas.

import flash.utils.Timer;

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

Powiązane elementy interfejsu API

myXML.childElement
myXML.@attributeName 

Powoduje przejście do elementów potomnych obiektu XML lub XMLList albo (w połączeniu z operatorem @) zwraca atrybuty obiektu XML lub XMLList. Zwrócony obiekt należy do klasy XMLList, ponieważ możliwe jest dopasowanie więcej niż jednego elementu potomnego lub atrybutu.

Aby zwrócić elementy z nazwami dopasowanymi do słów zastrzeżonych języka ActionScript, należy użyć metody XML.elements() lub metody XML.descendants(), a nie operatora kropki (.), co ilustruje następujący przykład:

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

Powiązane elementy interfejsu API

Sprawdza, czy dwa wyrażenia są równe. Wynikiem jest wartość true, jeśli wyrażenia są równe.

Jeśli typy danych obu operandów są identyczne, definicja równości zależy od typu danych operandów:

• Wartości typu int, uint i Boolean są uznawane za równe, jeśli mają te same wartości.
• Liczby o takich samych wartościach są uznawane za równe, chyba że obie mają wartość NaN.
• Jeśli oba operandy mają wartość null lub undefined, są uznawane za równe.
• Wyrażenia typu String są równe, jeśli mają tę samą liczbę znaków i znaki na odpowiednich pozycjach są identyczne.
• W przypadku obiektów XML:
  • Jeśli jeden operand jest tekstem lub węzłem atrybutu, a drugi ma treść prostą, oba operandy są konwertowane na ciągi znaków za pomocą metody toString() i są uznawane za równe, jeśli wynikowe ciągi znaków są równe.
  • W przeciwnym razie obiekty są uznawane za równe tylko wówczas, gdy oba obiekty mają takie same nazwy kwalifikowane, atrybuty i właściwości potomne.
• Obiekty XMLList są uznawane za równe, jeśli mają tę samą liczbę właściwości, a kolejność i wartości tych właściwości są takie same.
• Wartości obiektów typu Namespace są uznawane za równe, jeśli właściwości uri obu obiektów są równe.
• Wartości typu QName są uznawane za równe, jeśli odpowiednio właściwości uri oraz localName obu obiektów są równe.
• Zmienne reprezentujące obiekty, tablice i funkcje są porównywane przez odwołanie. Dwie takie zmienne są równe, jeśli odwołują się do tego samego obiektu, tablicy lub funkcji. Dwie odrębne tablice nigdy nie są uznawane za równe, nawet jeśli mają tę samą liczbę elementów.

• Oba operandy mają wartość undefined lub null; wówczas wynikiem jest wartość true.
• W wyniku automatycznej konwersji typów danych wartości typu String, Boolean, int, uint i Number zostały przekonwertowane na typy kompatybilne i przekonwertowane wartości są równe; wówczas operandy są uznawane za równe.
• Jednym z operandów jest obiekt XML z treścią prostą (hasSimpleContent() == true), a po przekonwertowaniu obu operandów na ciągi znaków za pomocą metody toString() wynikowe ciągi znaków są równe.
• Jeden operand należy do typu XMLList i spełniony jest jeden z następujących warunków:
  • Właściwość length obiektu XMLList ma wartość 0, a drugi obiekt jest równy undefined.
  • Właściwość length obiektu XMLList ma wartość 1 i ten jeden element obiektu XMLList jest równy drugiemu operandowi.

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 

Powiązane elementy interfejsu API

Porównuje dwa wyrażenia i określa, czy wartość wyrażenia expression1 jest większa od wartości expression2; jeśli tak, wynikiem jest wartość true. Jeśli wartość expression1 jest mniejsza lub równa expression2, wynikiem jest wartość false.

Jeśli oba operandy należą do typu String, są porównywane według kolejności alfabetycznej; wszystkie wielkie litery poprzedzają małe litery. W przeciwnym razie operandy są najpierw konwertowane na liczby, a potem porównywane.

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

Porównuje dwa wyrażenia i określa, czy wartość wyrażenia expression1 jest większa lub równa wartości expression2 (true), czy też wartość expression1 jest mniejsza niż wartość expression2 (false).

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

Powiązane elementy interfejsu API

Sprawdza, czy właściwość należy do określonego obiektu. Używając operatora in, należy podać nazwę właściwości jako pierwszy operand i obiekt jako drugi operand. Jeśli określony obiekt zawiera taką właściwość, wynikiem będzie wartość true; w przeciwnym razie wynikiem będzie wartość false.

Jeśli określony obiekt jest obiektem Array, operatora in można użyć do sprawdzenia, czy konkretny indeks jest poprawny. W wypadku podania liczby całkowitej jako pierwszego operandu wynikiem będzie wartość true, jeśli indeks mieści się w dozwolonym zakresie liczb albo wartość false w przeciwnym wypadku.

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

W poniższym przykładzie operator in zastosowano w celu zademonstrowania, że liczby 0, 1 i 2 są poprawnym indeksami tablicy myArray, ale liczba 3 nie jest poprawnym indeksem.

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

Powiązane elementy interfejsu API

++expression

 expression++

Dodaje 1 do wartości wyrażenia. Wyrażenie może być zmienną, elementem tablicy lub właściwością obiektu. Operator inkrementacji w postaci poprzedzającej (++expression) dodaje 1 do wartości expression i zwraca wynik. Operator inkrementacji w postaci następującej (expression++) dodaje 1 do expression i zwraca pierwotną wartość expression (tj. wartość sprzed dodawania).

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

Sprawdza warunek przeciwny do równości (==). Jeśli wyrażenie expression1 jest równe expression2, wynikiem będzie wartość false. Podobnie jak w przypadku operatora równości (==) definicja równości zależy od tego, jakie typy danych są porównywane.

Jeśli typy danych obu operandów są identyczne, definicja równości zależy od typu danych operandów:

• Wartości typu int, uint i Boolean są uznawane za równe, jeśli mają te same wartości.
• Liczby o takich samych wartościach są uznawane za równe, chyba że obie mają wartość NaN.
• Jeśli oba operandy mają wartość null lub undefined, są uznawane za równe.
• Wyrażenia typu String są równe, jeśli mają tę samą liczbę znaków i znaki na odpowiednich pozycjach są identyczne.
• W przypadku obiektów XML:
  • Jeśli jeden operand jest tekstem lub węzłem atrybutu, a drugi ma treść prostą, oba operandy są konwertowane na ciągi znaków za pomocą metody toString() i są uznawane za równe, jeśli wynikowe ciągi znaków są równe.
  • W przeciwnym razie obiekty są uznawane za równe tylko wówczas, gdy oba obiekty mają takie same nazwy kwalifikowane, atrybuty i właściwości potomne.
• Obiekty XMLList są uznawane za równe, jeśli mają tę samą liczbę właściwości, a kolejność i wartości tych właściwości są takie same.
• Wartości obiektów typu Namespace są uznawane za równe, jeśli właściwości uri obu obiektów są równe.
• Wartości typu QName są uznawane za równe, jeśli odpowiednio właściwości uri oraz localName obu obiektów są równe.
• Zmienne reprezentujące obiekty, tablice i funkcje są porównywane przez odwołanie. Dwie takie zmienne są równe, jeśli odwołują się do tego samego obiektu, tablicy lub funkcji. Dwie odrębne tablice nigdy nie są uznawane za równe, nawet jeśli mają tę samą liczbę elementów.

• Oba operandy mają wartość undefined lub null; wówczas wynikiem jest wartość true.
• W wyniku automatycznej konwersji typów danych wartości typu String, Boolean, int, uint i Number zostały przekonwertowane na typy kompatybilne i przekonwertowane wartości są równe; wówczas operandy są uznawane za równe.
• Jednym z operandów jest obiekt XML z treścią prostą (hasSimpleContent() == true), a po przekonwertowaniu obu operandów na ciągi znaków za pomocą metody toString() wynikowe ciągi znaków są równe.
• Jeden operand należy do typu XMLList i spełniony jest jeden z następujących warunków:
  • Właściwość length obiektu XMLList ma wartość 0, a drugi obiekt jest równy undefined.
  • Właściwość length obiektu XMLList ma wartość 1 i ten jeden element obiektu XMLList jest równy drugiemu operandowi.

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

Powiązane elementy interfejsu API

Sprawdza, czy łańcuch prototypów wyrażenia zawiera obiekt prototypowy dla funkcji function. Operator instanceof jest obsługiwany ze względu na zgodność wstecz z wydaniem 3. specyfikacji języka ECMAScript i może być przydatny dla zaawansowanych programistów, którzy stosują dziedziczenie w oparciu o prototypy oraz funkcje-konstruktory, a nie w oparciu o klasy.

Aby sprawdzić, czy obiekt należy do określonego typu danych, należy użyć operatora is.

Operator instanceof używany w odniesieniu do klas działa podobnie, jak operator is, ponieważ łańcuch prototypów klasy zawiera wszystkie jej nadklasy. Jednak interfejsy nie są uwzględnione w łańcuchu prototypów, dlatego operator instanceof zawsze zwraca wartość false, gdy operandem jest interfejs, podczas gdy operator is zwraca wartość true, jeśli obiekt należy do klasy implementującej określony interfejs.

Uwaga: Operator is w języku ActionScript jest równoważny operatorowi instanceof w języku 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

Powiązane elementy interfejsu API

Sprawdza, czy obiekt jest kompatybilny z określonym typem danych, klasą lub interfejsem. Do porównywania typów należy używać operatora is, a nie operatora instanceof. Operatora is można także używać do sprawdzania, czy obiekt implementuje określony interfejs.

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

Powiązane elementy interfejsu API

Porównuje dwa wyrażenia i określa, czy wartość wyrażenia expression1 jest mniejsza od wartości expression2; jeśli tak, wynikiem jest wartość true. Jeśli wartość expression1 jest większa lub równa expression2, wynikiem jest wartość false.

Jeśli oba operandy należą do typu String, są porównywane według kolejności alfabetycznej; wszystkie wielkie litery poprzedzają małe litery. W przeciwnym razie operandy są najpierw konwertowane na liczby, a potem porównywane.

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 

Porównuje dwa wyrażenia i określa, czy wartość wyrażenia expression1 jest mniejsza lub równa wartości expression2; jeśli tak, wynikiem jest wartość true. Jeśli wartość wyrażenia expression1 jest większa od wartości expression2, wynikiem jest wartość false.

Jeśli oba operandy należą do typu String, są porównywane według kolejności alfabetycznej; wszystkie wielkie litery poprzedzają małe litery. W przeciwnym razie operandy są najpierw konwertowane na liczby, a potem porównywane.

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 

Oznacza początek komentarza w skrypcie. Znaki między ogranicznikiem komentarza (//) a znakiem końca wiersza są interpretowane jako komentarz i ignorowane. Tego ogranicznika należy używać do oznaczania komentarzy jednowierszowych; w celu oznaczenia komentarzy zajmujących wiele kolejnych wierszy należy używać ograniczników /* i */.

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

Powiązane elementy interfejsu API

Zwraca wartość expression1, jeśli jest równa false lub można ją przekonwertować na wartość false, a w przeciwnym razie zwraca wartość wyrażenia expression2. Przykładami wartości, które można przekonwertować na false, są: 0, NaN, null oraz undefined. Jeśli wyrażenie expression2 jest wywołaniem funkcji, to funkcja nie zostanie wywołana, jeśli wyznaczoną wartością expression1 będzie false.

Jeśli oba operandy należą do typu Boolean, wynik będzie równy true tylko wtedy, gdy oba operandy będą równe true, tak jak przedstawiono to w poniższej tabeli:

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

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 && expression2. Na przykład następujące dwie instrukcje są równoważne:

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