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; 

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

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

Powiązane elementy interfejsu API

Odwraca wartość typu Boolean zmiennej lub wyrażenia. Jeśli expression jest zmienną o bezwzględnej lub przekonwertowanej wartości true, wartością !expression jest false. Jeśli wyznaczoną wartością wyrażenia x && y jest false, wyznaczoną wartością wyrażenia !(x && y) będzie true.

Następujące wyrażenia ilustrują efekt użycia operatora logicznego NEGACJI (!):

• !true zwraca false.
• !false zwraca true.

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

Powiązane elementy interfejsu API

Zwraca wartość expression1, jeśli jest równa true lub można ją przekonwertować na wartość true, a w przeciwnym razie zwraca wartość wyrażenia expression2. Jeśli wyrażenie expression2 jest wywołaniem funkcji, to funkcja nie zostanie wywołana, jeśli wyznaczoną wartością expression1 będzie true.

Jeśli oba operandy są typu Boolean, wynik jest równy true, gdy co najmniej jedno z wyrażeń jest równe true; wynik jest równy false tylko wówczas, gdy oba wyrażenia są równe false, tak jak przedstawiono to w poniższej tabeli:

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 
} 

Poniższy przykład demonstruje, że użycie wywołania funkcji jako drugiego operandu może prowadzić do nieoczekiwanych wyników. Jeśli wyznaczoną wartością wyrażenia po lewej stronie operatora jest true, wynik ten jest zwracany od razu i nie jest wyznaczana wartość wyrażenia po prawej stronie (funkcja fx2() nie jest wywoływana).

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

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; 

myVar ||= "default";

Powiązane elementy interfejsu API

Oblicza resztę z dzielenia wartości wyrażenia expression1 przez wartość wyrażenia expression2. Jeśli którykolwiek z operandów nie jest liczbą, operator modulo (%) podejmuje próbę przekonwertowania go na liczbę.

Znak wyniku operacji modulo jest taki sam, jak znak dzielnej (pierwszej liczby). Na przykład -4 % 3 i -4 % -3 dają w wyniku tę samą wartość -1.

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

Powiązane elementy interfejsu API

Przypisuje wyrażeniu expression1 wartość expression1 % expression2. Następujące dwie instrukcje są równoważne:

x %= y; 
x = x % y; 

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

Powiązane elementy interfejsu API

Mnoży dwa wyrażenia liczbowe. Jeśli oba wyrażenia są liczbami całkowitymi, iloczyn jest liczbą całkowitą. Jeśli przynajmniej jedno wyrażenie jest liczbą zmiennopozycyjną, iloczyn jest liczbą zmiennopozycyjną.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

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

Powiązane elementy interfejsu API

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identyfikuje przestrzeń nazw właściwości, metody, właściwości XML lub atrybutu 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

Powiązane elementy interfejsu API

Tworzy instancję klasy. Operatora new można używać z klasami lub zmiennymi typu Class do tworzenia instancji klasy. Operator new jest zazwyczaj używany z obiektem klasy w celu utworzenia instancji klasy. Na przykład instrukcja new Sprite() tworzy instancję klasy Sprite.

Operator new może również posłużyć do skojarzenia klasy z zasobem osadzonym, czyli obiektem zewnętrznym, takim jak obraz, dźwięk lub czcionka, umieszczonym w pliku SWF w trakcie kompilacji. Taki zasób osadzony jest reprezentowany przez unikatową klasę zasobu osadzonego. Aby uzyskać dostęp do zasobu osadzonego, należy użyć operatora new w celu utworzenia skojarzonej z nim klasy. Następnie można wywoływać odpowiednie metody i właściwości klasy obiektu osadzonego, aby manipulować tym zasobem.

Jeśli preferowane jest definiowanie klas z wykorzystaniem obiektów Function, a nie słowa kluczowego class, można używać operatora new do tworzenia obiektów w oparciu o funkcje-konstruktory. Nie należy mylić funkcji-konstruktorów z metodami-konstruktorami klas. Funkcja-konstruktor to obiekt Function zdefiniowany za pomocą słowa kluczowego function, który nie należy do definicji klasy. W przypadku zastosowania funkcji-konstruktorów do tworzenia obiektów, należy stosować dziedziczenie prototypów zamiast dziedziczenia klas.

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

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

var golfCourse:Array = new Array(18);

Powiązane elementy interfejsu API

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

Tworzy nowy obiekt i inicjuje go określonymi parami właściwości name i value. Użycie tego operatora jest równoważne użyciu składni new Object i wypełnieniu par właściwości za pomocą operatora przypisania. Prototypem nowo utworzonego obiektu jest obiekt klasy Object o nazwie ogólnej.

Ten operator służy także do oznaczania ciągłych bloków kodu związanych z instrukcjami sterowania przepływem (for, while, if, else, switch) i funkcjami.

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

Powiązane elementy interfejsu API

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Umożliwia grupowanie operacji na parametrze lub parametrach, sekwencyjne wyznaczanie wartości wyrażeń, a także wskazanie parametru lub parametrów do przekazania do funkcji, której nazwa poprzedza nawias.

Zastosowanie 1: Steruje kolejnością wykonywania operatorów. Nawiasy wymuszają zmianę normalnej kolejności wykonywania i powodują, że wartości wyrażeń w nawiasach są wyznaczane jako pierwsze. W przypadku zagnieżdżenia nawiasów zawartość najgłębiej zagnieżdżonych nawiasów jest wyznaczana przed zawartością nawiasów zewnętrznych.

Zastosowanie 2: Powodują wyznaczenie kolejno wartości wyrażeń rozdzielonych przecinkami i zwrócenie wyniku ostatniego wyrażenia.

Zastosowanie 3: Otaczają jeden lub wiele parametrów przekazywanych do funkcji, której nazwa występuje przed nawiasem otwierającym.

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

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

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

Powiązane elementy interfejsu API

myXML.(expression)

Wyznacza wartość wyrażenia w ramach konstrukcji XML zgodnej z notacją ECMAScript for XML (E4X). Na przykład kod myXML.(lastName == "Smith") identyfikuje elementy XML o nazwie lastName i wartości "Smith". Wynikiem jest obiekt klasy 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

Powiązane elementy interfejsu API

/pattern/flags

Operator ten, użyty przed znakami i po znakach, oznacza, że znaki należy traktować literalnie i że stanowią one wyrażenie regularne, a nie zmienną, ciąg znaków lub inny element języka ActionScript. Należy jednak zwrócić uwagę, że dwa następujące po sobie ukośniki (//) oznaczają początek komentarza.

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

Powiązane elementy interfejsu API

Sprawdza, czy dwa wyrażenia są równe, ale nie przeprowadza automatycznej konwersji danych. Wynikiem jest wartość true, jeśli wyrażenia są równe co do wartości i typu danych.

Operator ścisłej równości (===) pod trzema względami działa tak samo, jak operator równości (==):

• Liczby i wartości typu Boolean są porównywane na podstawie wartości i są uznawane za równe, jeśli ich wartości są takie same.
• Wyrażenia typu String są równe, jeśli mają tę samą liczbę znaków i znaki na odpowiednich pozycjach są identyczne.
• 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.

• Operator ścisłej równości przeprowadza automatyczną konwersję danych tylko dla typów liczbowych (Number, int oraz uint), natomiast operator równości przeprowadza konwersję typów na wszystkich pierwotnych typach danych.
• Wynikiem porównania wartości null i undefined za pomocą operatora ścisłej równości jest wartość false.

Po pierwsze, porównania między wartościami pierwotnymi i obiektami pierwotnymi zawierającymi tę samą wartość zwracają wartość true w języku ActionScript 3.0, natomiast we wcześniejszych wersjach zwracają wartość false. We wcześniejszych wersjach typem danych wartości pierwotnej jest Boolean, Number albo String, natomiast typem danych obiektu pierwotnego jest zawsze typ Object, a nie Boolean, Number lub String. Praktyczne znaczenie tej różnicy ilustruje poniższy przykład. We wcześniejszych wersjach języka ActionScript zwraca on wartość false, ponieważ typy danych operandów są różne, ale w języku ActionScript 3.0 zwraca wynik true, ponieważ wartości pierwotne mają przypisany typ Boolean, Number, int, uint lub String niezależnie od tego, czy są zawarte w obiekcie, czy nie.

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

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

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

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

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

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

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

Powiązane elementy interfejsu API

Sprawdza warunek przeciwny do ścisłej równości (===). Operator ścisłej nierówności działa tak samo, jak operator nierówności, z tym że konwertowane są wyłącznie typy danych int oraz unit.

Jeśli wyrażenie expression1 jest równe expression2, a ich typy danych są równe, wynikiem będzie wartość false.

Operator ścisłej nierówności (!==) pod trzema względami działa tak samo, jak operator nierówności (!=):

• Liczby i wartości typu Boolean są porównywane na podstawie wartości i są uznawane za równe, jeśli ich wartości są takie same.
• Wyrażenia typu String są równe, jeśli mają tę samą liczbę znaków i znaki na odpowiednich pozycjach są identyczne.
• 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.

• Operator ścisłej nierówności (!==) przeprowadza automatyczną konwersję danych tylko dla typów liczbowych Number, int oraz uint, natomiast operator nierówności (!=) przeprowadza konwersję typów na wszystkich pierwotnych typach danych.
• Wynikiem porównania wartości null i undefined za pomocą operatora ścisłej nierówności (!==) jest wartość 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 

Powiązane elementy interfejsu API

 "text" 

Operator ten, użyty przed znakami i po znakach, oznacza, że znaki należy traktować literalnie i że stanowią one ciąg, a nie zmienną, wartość liczbową lub inny element języka ActionScript.

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

Powiązane elementy interfejsu API

-expression

 expression1 - expression2

Służy do zmiany znaku lub odejmowania.

Zastosowanie 1: Gdy operator ten jest używany do zmiany znaku, odwraca znak wyrażenia liczbowego.

Zastosowanie 2: Gdy operator jest używany do odejmowania, wykonuje operację arytmetycznego odejmowania na dwóch wyrażeniach liczbowych, tj. odejmuje expression 2 od expression1. Gdy oba wyrażenia są liczbami całkowitymi, różnica jest liczbą całkowitą. Gdy przynajmniej jedno wyrażenie jest liczbą zmiennopozycyjną, różnica jest liczbą zmiennopozycyjną.

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

trace(5 - 2); // 3 

Następująca instrukcja odejmuje liczbę zmiennopozycyjną 1,5 od liczby zmiennopozycyjnej 3,25:

trace(3.25 - 1.5); // 1.75 

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

x -= y ;
x = x - y;

Wyrażenia typu String muszą być przekonwertowane na liczby; w przeciwnym razie wynikiem będzie wartość NaN („nie jest liczbą”).

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 

Powiązane elementy interfejsu API

[modifiers] var variableName:type

function functionName():type { ... }

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

Służy do przypisywania typu danych; ten operator określa typ zmiennej, typ wartości zwracanej przez funkcję lub typ parametru funkcji. Gdy jest używany w deklaracji zmiennej lub przypisaniu, operator ten określa typ zmiennej; gdy jest używany w deklaracji lub definicji zmiennej, operator ten określa typ wartości zwracanej przez funkcję; gdy jest używany z parametrem funkcji w definicji funkcji, operator ten określa typ zmiennej oczekiwany dla tego parametru.

Typ jest sprawdzany zawsze w czasie wykonywania. Jednak gdy kompilator działa w trybie ścisłym, wszystkie typy są również sprawdzane w czasie kompilacji, a w razie niezgodności generowane są błędy. Niezgodności mogą wystąpić w operacjach przypisania, wywołaniach funkcji i rozstrzyganiu odwołań do elementów klas za pomocą operatora kropki (.).

Do typów, których można używać, należą wszystkie natywne typy obiektów, klasy oraz interfejsy zdefiniowane przez użytkownika oraz typ void. Rozpoznawane typy natywne to Boolean, Number, int, uint oraz String. Jako typy natywne obsługiwane są również wszystkie klasy wbudowane.

Jeśli typ nie zostanie przypisany, zmienne, wartości zwracane przez funkcję lub parametry funkcji uznawane są za pozbawione typu, co oznacza że ich wartości mogą należeć do dowolnych typów. Aby jednoznacznie wyrazić zamiar użycia wartości bez typu, można jako adnotacji typu użyć znaku gwiazdki (*). Znak gwiazdki użyty w charakterze opisu typu jest równoważny pozostawieniu zmiennej, wartości zwracanej przez funkcję lub parametru funkcji bez określonego typu.

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

Powiązane elementy interfejsu API

Wyznacza wartość wyrażenia expression i zwraca ciąg znaków opisujący typ danych tego wyrażenia. Wynikiem może być jedna z sześciu wartości typu String: boolean, function, number, object, string albo xml. Zastosowanie tego obiektu do instancji klasy zdefiniowanej przez użytkownika da w wyniku ciąg znaków object. Operator typeof został uwzględniony w celu zachowania zgodności wstecz. Do sprawdzania kompatybilności typów należy używać operatora 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 

Powiązane elementy interfejsu API

Wyznacza wartość wyrażenia po czym odrzuca tę wartość i zwraca wartość undefined. Operator void jest często używany w porównaniach razem z operatorem == do sprawdzania, czy wartości są niezdefiniowane.

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

Definiuje znacznik XML w literale XML. Do zdefiniowania znacznika zamykającego należy użyć ukośnika /.

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

Powiązane elementy interfejsu API