Operatoren 

Telt numerieke expressies op. Wanneer beide expressies gehele getallen zijn, is de som een geheel getal; wanneer één of beide expressies drijvende-kommagetallen zijn, is de som een drijvende-kommagetal.

Wanneer een van de expressies een tekenreeks is, worden alle andere expressies in tekenreeksen omgezet en samengevoegd in plaats van bij elkaar opgeteld. Als een expressie geen getal is, wordt deze door Flash^® Player omgezet in een getal.

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 + expression2 toe. De volgende twee instructies hebben bijvoorbeeld hetzelfde resultaat:

x += y; 
x = x + y; 

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

Verwante API-elementen

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

Initialiseert een nieuwe array of multidimensionale array met de opgegeven elementen ( a0, enzovoort) of verkrijgt toegang tot elementen in een array. Met de operator voor arraytoegang kunt u instantienamen, objectnamen en variabelenamen dynamisch instellen en ophalen. Hiermee hebt u ook toegang tot objecteigenschappen.

Gebruik 1: een array is een object waarvan de eigenschappen elementen worden genoemd. Deze elementen worden aangegeven met een getal dat een index wordt genoemd. Wanneer u een array maakt, omringt u de elementen met de operator voor arraytoegang ([]) (of vierkante haakjes). Een array kan elementen van verschillende typen bevatten. De volgende array met de naam employee bevat bijvoorbeeld drie elementen, het eerste element is een getal en de volgende twee elementen zijn tekenreeksen (binnen aanhalingstekens):

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

In het volgende voorbeeld wordt de array employee_array met drie elementen gemaakt en wordt het derde element in de array gewijzigd.

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

Verwante API-elementen

Evalueert of een expressie die door de eerste operand wordt opgegeven, lid is van het gegevenstype dat door de tweede operand wordt opgegeven. Wanneer de eerste operand lid van het gegevenstype is, is het resultaat de eerste operand. Anders is het resultaat de waarde null.

De expressie die wordt gebruikt voor de tweede operand, moet een gegevenstype opleveren.

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

Verwante API-elementen

Wijst de waarde van expression2 (de operand aan de rechterkant) toe aan de variabele, het arrayelement of de eigenschap in expression1. Toewijzen kan via waarde of via verwijzing plaatsvinden. Bij toewijzen via waarde wordt de huidige waarde van expression2 gekopieerd en opgeslagen in expression1. Toewijzen via waarde wordt gebruikt wanneer expression2 een primitieve waarde is (het gegevenstype is Boolean, Number, int, uint of String). Bij toewijzen via verwijzing wordt een verwijzing naar expression2 in expression1 opgeslagen. Toewijzen via verwijzing wordt vaak toegepast via de operator new. De operator new maakt een object in het geheugen en een verwijzing naar die locatie in het geheugen wordt aan een variabele toegewezen.

Opmerking: in ActionScript 3.0 zijn alle waarden (inclusief primitieve waarden) objecten en vinden alle toewijzingen plaats via verwijzing. Primitieve objecten hebben echter speciale operatoren waardoor ze zich kunnen gedragen alsof ze via waarde zijn toegewezen.

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

Verwante API-elementen

 myXML.@attributeName 

Identificeert kenmerken van een object XML of XMLList. myXML.@id identificeert bijvoorbeeld kenmerken met de naam id voor het XML-object myXML. U kunt ook de volgende syntaxis gebruiken om toegang te krijgen tot kenmerken: myXML.attribute("id"), myXML["@id"] en myXML.@["id"]. De syntaxis myXML.@id wordt aanbevolen. Als u een XMLList-object van alle kenmerknamen wilt retourneren, gebruikt u @*. Als u een kenmerk wilt retourneren met een naam die overeenkomt met een voor ActionScript gereserveerd woord, gebruikt u de methode attribute() in plaats van de operator @.

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

Verwante API-elementen

Zet expression1 en expression2 om in 32-bits gehele getallen zonder teken en voert een Booleaanse bewerking AND uit voor elke bit van de parameters van gehele getallen. Drijvende-kommagetallen worden in gehele getallen omgezet door de cijfers na het decimaalteken te verwijderen. Het resultaat is een nieuw 32-bits geheel getal.

Een positief geheel getal wordt in een hexadecimale waarde zonder teken omgezet met een maximumwaarde van 4294967295 of 0xFFFFFFFF. Wanneer het getal groter is dan de maximumwaarde, worden de meest significante cijfers genegeerd tijdens het omzetten zodat de waarde 32-bits blijft. Een negatief getal wordt met de twee-complement-notatie omgezet in een hexadecimale waarde zonder teken met een minimumwaarde van -2147483648 of 0x800000000. Wanneer het getal kleiner is dan de minimumwaarde, wordt het met grotere precisie met de twee-complement-notatie omgezet en worden vervolgens de meest significante cijfers genegeerd.

Het resultaat wordt geïnterpreteerd als een 32-bits twee-complement-getal. Dit betekent dat het resultaat een geheel getal is in het bereik van -2147483648 tot en met 2147483647.

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

  1101
& 1011
  ----
  1001

In de volgende voorbeelden wordt de werking van de omzetting van een geretourneerde waarde getoond:

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 & expression2 toe. De volgende twee expressies zijn bijvoorbeeld gelijk:

x &= y; 
x = x & y; 

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

Verwante API-elementen

Zet expression1 en shiftCount om in 32-bits gehele getallen en verplaatst alle bits in expression1 een aantal posities naar links. Dit aantal is het gehele getal dat het resultaat is van de omzetting van shiftCount. De bitposities die bij deze bewerking leeg worden gemaakt, worden gevuld met 0 en bits die verder worden verplaatst dan het linkereinde, worden verwijderd. Wanneer u een waarde één positie naar links verplaatst, staat dit gelijk aan vermenigvuldigen met 2.

Een drijvende-kommagetal wordt in een geheel getal omgezet door de cijfers na het decimaalteken te verwijderen. Een positief geheel getal wordt in een hexadecimale waarde zonder teken omgezet met een maximumwaarde van 4294967295 of 0xFFFFFFFF. Wanneer het getal groter is dan de maximumwaarde, worden de meest significante cijfers genegeerd tijdens het omzetten zodat de waarde 32-bits blijft. Een negatief getal wordt met de twee-complement-notatie omgezet in een hexadecimale waarde zonder teken met een minimumwaarde van -2147483648 of 0x800000000. Wanneer het getal kleiner is dan de minimumwaarde, wordt het met grotere precisie met de twee-complement-notatie omgezet en worden vervolgens de meest significante cijfers genegeerd.

Het resultaat wordt geïnterpreteerd als een 32-bits twee-complement-getal. Dit betekent dat het resultaat een geheel getal is in het bereik van -2147483648 tot en met 2147483647.

Wanneer het resultaat een negatief geheel getal is, wordt een fout bij uitvoering gegenereerd wanneer u probeert het resultaat aan een variabele van het type uint toe te wijzen. ActionScript heeft geen operator 'bitsgewijs zonder teken naar links verplaatsen', maar u bereikt hetzelfde effect, en voorkomt de fout bij uitvoering, als u uint(expression1 << shiftCount) gebruikt:

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 

In het volgende voorbeeld wordt het gehele getal 7 8 bits naar links verplaatst:

x = 7 << 8

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

Met de volgende instructie trace wordt getoond dat de bits drie posities naar rechts zijn verplaatst:

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

Verwante API-elementen

Voert de bewerking <<= (bitsgewijs naar links verplaatsen) uit en slaat de inhoud als resultaat op in expression1. De volgende twee expressies zijn gelijkwaardig:

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 

Verwante API-elementen

Zet expression om in een 32-bits geheel getal met teken en past vervolgens een bitsgewijze één-complement-bewerking toe. Dit betekent dat elke bit met waarde 0 in het resultaat op 1 wordt ingesteld en dat elke bit met waarde 1 in het resultaat op 0 wordt ingesteld. Het resultaat is een 32-bits geheel getal met teken. Deze operator wordt ook één-complement-operator of bitsgewijze complement-operator genoemd.

De hexadecimale waarde 0x7777 wordt bijvoorbeeld als het volgende binaire getal weergegeven:

0111011101110111

De bitsgewijze negatie van die hexadecimale waarde, ~0x7777, is het volgende binaire getal:

1000100010001000

Hexadecimaal is dit 0x8888. Daarom is ~0x7777 gelijk aan 0x8888.

Bitsgewijze operatoren worden vooral gebruikt voor het weergeven van markeringsbits (Booleaanse waarden die elk door 1 bit worden vertegenwoordigd).

Een drijvende-kommagetal wordt in een geheel getal omgezet door de cijfers na het decimaalteken te verwijderen. Een positief geheel getal wordt in een hexadecimale waarde zonder teken omgezet met een maximumwaarde van 4294967295 of 0xFFFFFFFF. Wanneer het getal groter is dan de maximumwaarde, worden de meest significante cijfers genegeerd tijdens het omzetten zodat de waarde 32-bits blijft. Een negatief getal wordt met de twee-complement-notatie omgezet in een hexadecimale waarde zonder teken met een minimumwaarde van -2147483648 of 0x800000000. Wanneer het getal kleiner is dan de minimumwaarde, wordt het met grotere precisie met de twee-complement-notatie omgezet en worden vervolgens de meest significante cijfers genegeerd.

Het resultaat wordt geïnterpreteerd als een 32-bits twee-complement-getal. Dit betekent dat het resultaat een geheel getal is in het bereik van -2147483648 tot en met 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 

Verwante API-elementen

Zet expression1 en expression2 om in 32-bits gehele getallen zonder teken en plaatst een 1 op elke bitpositie waar de bijbehorende bits van expression1 of expression2 1 zijn.

Een drijvende-kommagetal wordt in een geheel getal omgezet door de cijfers na het decimaalteken te verwijderen. Een positief geheel getal wordt in een hexadecimale waarde zonder teken omgezet met een maximumwaarde van 4294967295 of 0xFFFFFFFF. Wanneer het getal groter is dan de maximumwaarde, worden de meest significante cijfers genegeerd tijdens het omzetten zodat de waarde 32-bits blijft. Een negatief getal wordt met de twee-complement-notatie omgezet in een hexadecimale waarde zonder teken met een minimumwaarde van -2147483648 of 0x800000000. Wanneer het getal kleiner is dan de minimumwaarde, wordt het met grotere precisie met de twee-complement-notatie omgezet en worden vervolgens de meest significante cijfers genegeerd.

Het resultaat wordt geïnterpreteerd als een 32-bits twee-complement-getal. Dit betekent dat het resultaat een geheel getal is in het bereik van -2147483648 tot en met 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) 

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 | expression2 toe. De volgende twee instructies zijn bijvoorbeeld gelijk:

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) 

Verwante API-elementen

Zet expression en shiftCount om in 32-bits gehele getallen en verplaatst alle bits in expression een aantal posities naar rechts. Dit aantal is het gehele getal dat het resultaat is van de omzetting van shiftCount. Bits die voorbij het rechtereinde worden verplaatst, worden verwijderd. Het teken van de oorspronkelijke expressie blijft behouden doordat de bits aan de linkerkant met 0 worden gevuld wanneer de meest significante bit (de meest linkse bit) van expression 0 is. De bits worden met 1 gevuld wanneer de meest significante bit 1 is. Wanneer u een waarde één positie naar rechts verplaatst, komt dit overeen met delen door 2 en de rest verwijderen.

Een drijvende-kommagetal wordt in een geheel getal omgezet door de cijfers na het decimaalteken te verwijderen. Een positief geheel getal wordt in een hexadecimale waarde zonder teken omgezet met een maximumwaarde van 4294967295 of 0xFFFFFFFF. Wanneer het getal groter is dan de maximumwaarde, worden de meest significante cijfers genegeerd tijdens het omzetten zodat de waarde 32-bits blijft. Een negatief getal wordt met de twee-complement-notatie omgezet in een hexadecimale waarde zonder teken met een minimumwaarde van -2147483648 of 0x800000000. Wanneer het getal kleiner is dan de minimumwaarde, wordt het met grotere precisie met de twee-complement-notatie omgezet en worden vervolgens de meest significante cijfers genegeerd.

Het resultaat wordt geïnterpreteerd als een 32-bits twee-complement-getal. Dit betekent dat het resultaat een geheel getal is in het bereik van -2147483648 tot en met 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)

Verwante API-elementen

Voert een bitsgewijze verplaatsing naar rechts uit en slaat het resultaat op in expression.

De volgende twee instructies zijn gelijkwaardig:

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.

Verwante API-elementen

Dezelfde operator als de operator voor bitsgewijs naar rechts verplaatsen (>>), met dit verschil dat deze operator het teken van de oorspronkelijke expressie niet behoudt omdat de bits aan de linkerkant altijd met 0 worden gevuld.

Een drijvende-kommagetal wordt in een geheel getal omgezet door de cijfers na het decimaalteken te verwijderen. Een positief geheel getal wordt in een hexadecimale waarde zonder teken omgezet met een maximumwaarde van 4294967295 of 0xFFFFFFFF. Wanneer het getal groter is dan de maximumwaarde, worden de meest significante cijfers genegeerd tijdens het omzetten zodat de waarde 32-bits blijft. Een negatief getal wordt met de twee-complement-notatie omgezet in een hexadecimale waarde zonder teken met een minimumwaarde van -2147483648 of 0x800000000. Wanneer het getal kleiner is dan de minimumwaarde, wordt het met grotere precisie met de twee-complement-notatie omgezet en worden vervolgens de meest significante cijfers genegeerd.

Het resultaat wordt geïnterpreteerd als een 32-bits geheel getal zonder teken. Dit betekent dat het resultaat een geheel getal is in het bereik 0 tot en met 4294967295.

Opmerking: ActionScript heeft geen aanvullende operator 'bitsgewijs zonder teken naar links verplaatsen', maar u bereikt hetzelfde effect als u uint(expression << shiftCount) gebruikt.

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

Verwante API-elementen

Voert een bitsgewijze verplaatsing naar rechts zonder teken uit en slaat het resultaat op in expression. De volgende twee instructies zijn gelijkwaardig:

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

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

Verwante API-elementen

Zet expression1 en expression2 om in 32-bits gehele getallen zonder teken en plaatst een 1 op elke bitpositie waar de bijbehorende bits in expression1 of expression2, maar niet beide, 1 zijn.

Een drijvende-kommagetal wordt in een geheel getal omgezet door de cijfers na het decimaalteken te verwijderen. Een positief geheel getal wordt in een hexadecimale waarde zonder teken omgezet met een maximumwaarde van 4294967295 of 0xFFFFFFFF. Wanneer het getal groter is dan de maximumwaarde, worden de meest significante cijfers genegeerd tijdens het omzetten zodat de waarde 32-bits blijft. Een negatief getal wordt met de twee-complement-notatie omgezet in een hexadecimale waarde zonder teken met een minimumwaarde van -2147483648 of 0x800000000. Wanneer het getal kleiner is dan de minimumwaarde, wordt het met grotere precisie met de twee-complement-notatie omgezet en worden vervolgens de meest significante cijfers genegeerd.

Het resultaat wordt geïnterpreteerd als een 32-bits twee-complement-getal. Dit betekent dat het resultaat een geheel getal is in het bereik van -2147483648 tot en met 2147483647.

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 ^ expression2 toe. De volgende twee instructies zijn bijvoorbeeld gelijk:

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) 

Verwante API-elementen

/* comment */

/* comment

   comment */

Scheidt een of meer regels scriptopmerkingen. Tekens tussen het openingsscheidingsteken (/*) en het sluitingsscheidingsteken (*/) worden beschouwd als opmerking en door de ActionScript-compiler genegeerd. Gebruik deze scheidingstekens om opmerkingen op meerdere, opeenvolgende regels te identificeren. Gebruik voor opmerkingen op één regel het scheidingsteken //.

Er wordt een foutmelding gegenereerd wanneer u het sluitingsscheidingsteken voor opmerkingenblok ( */) weglaat of opmerkingen nest. Nadat een openingsscheidingsteken (/*) is gebruikt, eindigt het eerste sluitingsscheidingsteken (*/) de opmerking, ongeacht het aantal voorafgaande openingsscheidingstekens.

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

Verwante API-elementen

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

Evalueert een expressie die wordt gebruikt in een XML- of XMLList-initialiseerder. Een XML- of XMLList-initialiseerder is een letterlijke waarde die is toegewezen aan een variabele van het type XML of XMLList. Een expressie die wordt gescheiden door de XML-operatoren { en } kan in een XML- of XMLList-initialiseerder worden gebruikt in plaats van letterlijke namen of waarden. Een expressie kan worden gebruikt in plaats van tagName, attributeName, attributeValue en content.

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

Verwante API-elementen

 myXML[expression]

Hiermee wordt toegang tot een eigenschap of kenmerk van een object XML of XMLList verkregen. Met de vierkante-haakjesoperator kunt u eigenschapnamen benaderen die niet toegankelijk zijn met de puntoperator ( .).

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

Verwante API-elementen

Evalueert expression1, vervolgens expression2, enzovoort. Deze operator wordt vooral gebruikt met de lusinstructie for en wordt vaak gebruikt met de haakjesoperator ().

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 

Verwante API-elementen

Voegt tekenreeksen samen (combineren). Wanneer een van de expressies een tekenreeks is, worden de andere expressies omgezet in tekenreeksen en samengevoegd.

Wanneer beide expressies getallen zijn, functioneert deze operator als een operator voor optellen.

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 

Verwante API-elementen

expression1 + expression2

voegt XML- of XMLList-waarden samen (combineren) tot een object XMLList. Het resultaat is alleen een object XMLList wanneer beide operanden XML- of XMLList-waarden zijn.

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

Met de instructie trace wordt de volgende uitvoer geproduceerd:

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 + expression2 toe. De volgende twee instructies hebben bijvoorbeeld hetzelfde resultaat:

x += y; 
x = x + y;

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

Verwante API-elementen

expression1 += expression2

Wijst aan expression1, een XMLList-object, de waarde van expression1 + expression2 toe. De volgende twee instructies hebben bijvoorbeeld hetzelfde resultaat:

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

Met de instructie trace wordt de volgende uitvoer geproduceerd:

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

<location>Springfield</location>

Verwante API-elementen

expression1 ? expression2 : expression3

Evalueert expression1 en als de waarde van expression1 true is, is het resultaat de waarde van expression2; anders is het resultaat de waarde van 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--

Verlaagt de operand met 1. De operand kan een variabele, element in een array of eigenschap van een object zijn. De vooraf verlagende vorm van de operator (--expression) verlaagt expression met 1 en retourneert het resultaat. De achteraf verlagende vorm van de operator (expression--) verlaagt expression met 1 en retourneert de beginwaarde van expression (de waarde vóór de verlaging).

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

Verwijdert de objecteigenschap die is opgegeven met reference. Het resultaat is true als de eigenschap niet aanwezig is wanneer de bewerking is voltooid; anders is het resultaat false. De operator delete retourneert true als deze wordt aangeroepen voor een niet-bestaande eigenschap of een dynamische eigenschap die niet in een klasse is gedefinieerd.

De operator delete kan mislukken en false retourneren als de parameter reference niet kan worden verwijderd. U kunt geen vaste eigenschappen of variabelen verwijderen die met de instructie var zijn gedeclareerd. Een vaste eigenschap is een variabele of methode die in een klassedefinitie is gedefinieerd.

U kunt niet de operator delete gebruiken om een eigenschap of een klasse te verwijderen, tenzij die klasse een dynamische klasse is die bij uitvoering is toegevoegd. Eigenschappen van verzegelde klassen kunnen niet met delete worden verwijderd. Stel de eigenschap in plaats daarvan in op null.

Opmerking: u kunt een object niet verwijderen, maar u kunt wel zorgen dat het in aanmerking komt voor opschoning. Dit doet u door alle verwijzingen naar het object te verwijderen. De meest gebruikte verwijzing naar een object is een variabele die ernaar verwijst. U kunt een dergelijke verwijzing verwijderen door de variabele in te stellen op null. Bij opschonen wordt elk object zonder verwijzingen verwijderd.

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

In het volgende voorbeeld wordt de waarde van een arrayelement verwijderd, maar blijft de waarde van de eigenschap length ongewijzigd:

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,

in het volgende voorbeeld wordt getoond hoe de geretourneerde Booleaanse waarde uit delete als voorwaarde voor toekomstige code-uitvoering kan worden gebruikt. Als voor een item dat al is verwijderd nogmaals delete wordt aangeroepen, wordt false geretourneerd.

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

Verwante API-elementen

 delete reference

Verwijdert de XML-elementen of -kenmerken die zijn opgegeven door 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());

De uitvoer is als volgt:

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

De uitvoer van dit voorbeeld is als volgt:

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

 myXML..childElement1..@attributeName 

Navigeert naar afstammende elementen van een object XML of XMLList of (in combinatie met de operator @) zoekt naar overeenkomende kenmerken of afstammingen. De overeenkomende elementen of kenmerken hoeven geen direct onderliggende items van het object XML of XMLList te zijn. Ze kunnen zich lager in de structuur bevinden (bijvoorbeeld kleinkinderen). Het resultaat is een XMLList-object omdat meer dan één onderliggend element of kenmerk van toepassing kan zijn.

De volgorde van nodes in het object XMLList dat wordt geretourneerd, is het resultaat van een bewerking waarbij de structuur eerst op diepte wordt doorlopen. Overweeg bijvoorbeeld het volgende:

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

Dit zou resulteren in de volgende uitvoer:

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

U kunt de methode XML.descendants() gebruiken in plaats van de afstammingsoperator (..) om afstammingen te retourneren met namen die overeenkomen met woorden die zijn gereserveerd voor ActionScript, zoals in het volgende voorbeeld wordt weergegeven:

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

Verwante API-elementen

Deelt expression1 door expression2. Het resultaat van de operator voor delen is een drijvende-kommagetal met dubbele precisie.

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 / expression2 toe. De volgende twee instructies zijn bijvoorbeeld gelijk:

x /= y; 
x = x / y;

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

Verwante API-elementen

object.property_or_method

Benadert klassevariabelen en -methoden, haalt objecteigenschappen op en stelt deze in, en scheidt geïmporteerde pakketten of klassen.

import flash.utils.Timer;

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

Verwante API-elementen

myXML.childElement
myXML.@attributeName 

Navigeert naar onderliggende elementen van een object XML of XMLList of retourneert kenmerken (in combinatie met de operator @) van een object XML of XMLList. Het object retourneert een XMLList omdat meer dan één onderliggend element of kenmerk van toepassing kan zijn.

Om elementen te retourneren met namen die overeenkomen met voor ActionScript gereserveerde woorden, gebruikt u de methode XML.elements() of XML.descendants() in plaats van de XML-operator punt (.), zoals in het volgende voorbeeld te zien is:

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

Verwante API-elementen

Test twee expressies op gelijkheid. Wanneer de expressies gelijk zijn, is het resultaat true.

Wanneer de gegevenstypen van de twee operanden overeenkomen, hangt de definitie van gelijkheid af van het gegevenstype van de operanden:

• Waarden van het type int, uint en Boolean worden als gelijk beschouwd wanneer de waarden overeenkomen.
• Getallen met overeenkomende waarden worden als gelijk beschouwd, tenzij beide NaN zijn.
• Als de waarde van beide operanden null of undefined is, worden ze als gelijk beschouwd.
• Tekenreeksexpressies zijn gelijk wanneer deze hetzelfde aantal tekens bevatten en de tekens identiek zijn.
• Bij XML-objecten:
  • Wanneer de ene operand een tekst- of kenmerknode is en de andere eenvoudige inhoud bevat, worden beide operanden met de methode toString() omgezet in tekenreeksen en worden als gelijk beschouwd wanneer de resulterende tekenreeksen overeenkomen.
  • Anders worden objecten alleen als gelijk beschouwd wanneer de gekwalificeerde naam, kenmerken en onderliggende eigenschappen voor beide objecten overeenkomen.
• Objecten XMLList worden als gelijk beschouwd wanneer ze hetzelfde aantal eigenschappen hebben en zowel de volgorde als de waarden van de eigenschappen overeenkomen.
• Bij objecten Namespace worden waarden als gelijk beschouwd wanneer de eigenschappen uri van beide objecten overeenkomen.
• Bij QName-objecten worden waarden als gelijk beschouwd als beide objecten dezelfde uri-eigenschap en dezelfde localName-eigenschap hebben.
• Variabelen die objecten, arrays en functies vertegenwoordigen, worden via verwijzing vergeleken. Twee van dergelijke variabelen zijn gelijk wanneer deze naar hetzelfde object, dezelfde array of dezelfde functie verwijzen. Twee afzonderlijke arrays worden nooit als gelijk beschouwd, ook niet wanneer deze hetzelfde aantal elementen bevatten.

• De waarden van de operanden zijn undefined en null; in dat geval is het resultaat true.
• Bij automatische omzetting van gegevenstypen worden de gegevenstypen van waarden String, Boolean, int, uint en Number omgezet in compatibele typen en zijn de omgezette waarden gelijk. In dat geval worden de operanden als gelijk beschouwd.
• Eén operand is van het type XML met eenvoudige inhoud (hasSimpleContent() == true) en nadat beide operanden met de methode toString() in tekenreeksen zijn omgezet, komen de resulterende tekenreeksen overeen.
• Eén operand is van het type XMLList en een van de volgende voorwaarden is van toepassing:
  • De eigenschap length van het object XMLList is 0 en het andere object is undefined.
  • De eigenschap length van het object XMLList is 1 en één element van het object XMLList komt overeen met de andere operand.

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 

Verwante API-elementen

Vergelijkt twee expressies en bepaalt of expression1 groter is dan expression2. Als dat het geval is, is het resultaat true. Als expression1 kleiner dan of gelijk aan expression2 is, is het resultaat false.

Wanneer beide operanden van het type String zijn, worden ze vergeleken op alfabetische volgorde: alle hoofdletters komen voor kleine letters. Anders worden operanden eerst in getallen omgezet en vervolgens vergeleken.

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

Vergelijkt twee expressies en bepaalt of expression1 groter dan of gelijk aan expression2 is (true) of dat expression1 kleiner dan expression2 is (false).

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

Verwante API-elementen

Evalueert of een eigenschap deel is van een specifiek object. Als u de operator in wilt gebruiken, geeft u een eigenschapnaam op als de eerste operand en een object als de tweede operand. Als het opgegeven object een dergelijke eigenschap bevat, is het resultaat true; anders is het resultaat false.

Wanneer het opgegeven object een object Array is, kunt u de operator in gebruiken om te controleren of een bepaald indexnummer geldig is. Als u een geheel getal doorgeeft als eerste operand, is het resultaat true als de index binnen het geldige bereik van indexnummers valt, anders is het resultaat false.

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

In het volgende voorbeeld wordt de operator in gebruikt om te laten zien dat de getallen 0, 1 en 2 geldige indexnummers zijn in het object myArray, maar dat nummer 3 dat niet is.

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

Verwante API-elementen

++expression

 expression++

Verhoogt een expressie met 1. De expressie kan een variabele, element in een array of eigenschap van een object zijn. De vooraf verhogende vorm van de operator (++expression) verhoogt expression met 1 en retourneert het resultaat. De achteraf verhogende vorm van de operator (expression++) verhoogt expression met 1 en retourneert de beginwaarde van expression (de waarde vóór de verhoging).

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

Test op het tegenovergestelde van de operator == (gelijk aan). Als expression1 gelijk is aan expression2, is het resultaat false. Net als bij de operator == (gelijk aan), hangt de definitie van gelijkheid af van de gegevenstypen die worden vergeleken.

Wanneer de gegevenstypen van de twee operanden overeenkomen, hangt de definitie van gelijkheid af van het gegevenstype van de operanden:

• Waarden van het type int, uint en Boolean worden als gelijk beschouwd wanneer de waarden overeenkomen.
• Getallen met overeenkomende waarden worden als gelijk beschouwd, tenzij beide NaN zijn.
• Als de waarde van beide operanden null of undefined is, worden ze als gelijk beschouwd.
• Tekenreeksexpressies zijn gelijk wanneer deze hetzelfde aantal tekens bevatten en de tekens identiek zijn.
• Bij XML-objecten:
  • Wanneer de ene operand een tekst- of kenmerknode is en de andere eenvoudige inhoud bevat, worden beide operanden met de methode toString() omgezet in tekenreeksen en worden als gelijk beschouwd wanneer de resulterende tekenreeksen overeenkomen.
  • Anders worden objecten alleen als gelijk beschouwd wanneer de gekwalificeerde naam, kenmerken en onderliggende eigenschappen voor beide objecten overeenkomen.
• Objecten XMLList worden als gelijk beschouwd wanneer ze hetzelfde aantal eigenschappen hebben en zowel de volgorde als de waarden van de eigenschappen overeenkomen.
• Bij objecten Namespace worden waarden als gelijk beschouwd wanneer de eigenschappen uri van beide objecten overeenkomen.
• Bij QName-objecten worden waarden als gelijk beschouwd als beide objecten dezelfde uri-eigenschap en dezelfde localName-eigenschap hebben.
• Variabelen die objecten, arrays en functies vertegenwoordigen, worden via verwijzing vergeleken. Twee van dergelijke variabelen zijn gelijk wanneer deze naar hetzelfde object, dezelfde array of dezelfde functie verwijzen. Twee afzonderlijke arrays worden nooit als gelijk beschouwd, ook niet wanneer deze hetzelfde aantal elementen bevatten.

• De waarden van de operanden zijn undefined en null; in dat geval is het resultaat true.
• Bij automatische omzetting van gegevenstypen worden de gegevenstypen van waarden String, Boolean, int, uint en Number omgezet in compatibele typen en zijn de omgezette waarden gelijk. In dat geval worden de operanden als gelijk beschouwd.
• Eén operand is van het type XML met eenvoudige inhoud (hasSimpleContent() == true) en nadat beide operanden met de methode toString() in tekenreeksen zijn omgezet, komen de resulterende tekenreeksen overeen.
• Eén operand is van het type XMLList en een van de volgende voorwaarden is van toepassing:
  • De eigenschap length van het object XMLList is 0 en het andere object is undefined.
  • De eigenschap length van het object XMLList is 1 en één element van het object XMLList komt overeen met de andere operand.

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

Verwante API-elementen

Evalueert of de prototypeketen van een expressie het prototype voor function bevat. De operator instanceof is opgenomen voor achterwaartse compatibiliteit met ECMAScript, 3rd Edition en kan nuttig zijn voor geavanceerde programmeurs die ervoor kiezen prototypegebaseerde overerving te gebruiken met constructorfuncties in plaats van klassen.

Gebruik de operator is om te controleren of een object lid is van een specifiek gegevenstype.

Als de operator instanceof wordt gebruikt bij klassen, is deze gelijk aan de operator is omdat de prototypeketen van een klasse alle bijbehorende superklassen bevat. Interfaces worden echter niet opgenomen in prototypeketens. De operator instanceof resulteert dus altijd in false als deze bij interfaces wordt gebruikt, terwijl de operator is intrue resulteert als een object tot een klasse behoort die de opgegeven interface implementeert.

Opmerking: de ActionScript-operator is is het equivalent van de Java-operator instanceof.

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

Verwante API-elementen

Evalueert of een object compatibel is met een specifiek gegevenstype, specifieke klasse of specifieke interface. Gebruik de operator is in plaats van de operator instanceof voor typevergelijking. U kunt ook de operator is gebruiken om te controleren of een object een interface implementeert.

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

Verwante API-elementen

Vergelijkt twee expressies en bepaalt of expression1 kleiner is dan expression2. Als dat het geval is, is het resultaat true. Als expression1 groter dan of gelijk aan expression2 is, is het resultaat false.

Wanneer beide operanden van het type String zijn, worden ze vergeleken op alfabetische volgorde: alle hoofdletters komen voor kleine letters. Anders worden operanden eerst in getallen omgezet en vervolgens vergeleken.

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 

Vergelijkt twee expressies en bepaalt of expression1 kleiner dan of gelijk aan expression2 is. Als dat het geval is, is het resultaat true. Als expression1 groter is dan expression2, is het resultaat false.

Wanneer beide operanden van het type String zijn, worden ze vergeleken op alfabetische volgorde: alle hoofdletters komen voor kleine letters. Anders worden operanden eerst in getallen omgezet en vervolgens vergeleken.

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 

Geeft het begin van een scriptopmerking aan. Tekens tussen het scheidingsteken voor opmerkingen ( //) en het teken voor regeleinde wordt als een opmerking beschouwd en wordt genegeerd. Gebruik dit scheidingsteken voor opmerkingen op één regel. Gebruik de scheidingstekens /* en */ voor opmerkingen op meerdere, opeenvolgende regels.

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

Verwante API-elementen

Retourneert expression1 als de waarde false is of kan worden omgezet in false, anders expression2. Voorbeelden van waarden die kunnen worden omgezet in false zijn 0, NaN, null en undefined. Als u een functieaanroep als expression2 gebruikt, wordt de functie niet aangeroepen als expression1false oplevert.

Als beide operanden van het type Boolean zijn, is het resultaat alleen true als beide operanden true zijn, zoals in de volgende tabel te zien is:

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 && expression2 toe. De volgende twee instructies zijn bijvoorbeeld gelijk:

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

Verwante API-elementen

Keert de Booleaanse waarde van een variabele of expressie om. Als expression een variabele is met de absolute of omgezette waarde true, is de waarde van !expression false. Als de expressie x && y de waarde false oplevert, levert de expressie !(x && y) de waarde true op.

De volgende expressies tonen het resultaat van het gebruik van de logische operator NOT (!):

• !true retourneert false.
• !false retourneert true.

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

Verwante API-elementen

Retourneert expression1 als de waarde true is of kan worden omgezet in true, anders expression2. Als u een functieaanroep als expression2 gebruikt, wordt de functie niet aangeroepen als expression1true oplevert.

Als beide operanden van het type Boolean zijn, is het resultaat true als een of beide expressies true zijn. Het resultaat is alleen false als beide expressies false zijn, zoals in de volgende tabel te zien is:

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 
} 

In het volgende voorbeeld wordt getoond hoe het gebruik van een functieaanroep als de tweede operand tot onverwachte resultaten kan leiden. Als de expressie aan de linkerkant van de operator de waarde true oplevert, wordt dat resultaat geretourneerd zonder dat de expressie aan de rechterkant wordt geëvalueerd (de functie fx2() wordt niet aangeroepen).

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 || expression2 toe. De volgende twee instructies zijn bijvoorbeeld gelijk:

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

myVar ||= "default";

Verwante API-elementen

Berekent de rest van expression1 gedeeld door expression2. Wanneer een van de operanden niet-numeriek is, probeert de operator % (restbepaling bij deling) deze om te zetten in een getal.

Het teken van het resultaat van de bewerking restbepaling bij deling komt overeen met het teken van het deeltal (het eerste getal). -4 % 3 en -4 % -3 leveren bijvoorbeeld allebei -1 op.

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

Verwante API-elementen

Wijst aan expression1 de waarde van expression1 % expression2 toe. De volgende twee instructies zijn gelijkwaardig:

x %= y; 
x = x % y; 

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

Verwante API-elementen

Vermenigvuldigt twee numerieke expressies. Wanneer beide expressies gehele getallen zijn, is het product een geheel getal. Wanneer één of beide expressies drijvende-kommagetallen zijn, is het product een drijvende-kommagetal.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

Wijst aan expression1 de waarde van expression1 * expression2 toe. De volgende twee expressies zijn bijvoorbeeld gelijk:

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 

Verwante API-elementen

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identificeert de naamruimte van een eigenschap, methode, XML-eigenschap of XML-kenmerk.

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

Verwante API-elementen

Instantieert een klasse-instantie. De operator new kan worden gebruikt met een klasse of een variabele van het type Class om een instantie van een klasse te maken. De operator new wordt meestal gebruikt met een klasseobject om een instantie van een klasse te maken. Met de instructie new Sprite() wordt bijvoorbeeld een instantie van de klasse Sprite gemaakt.

U kunt de operator new ook gebruiken om een klasse te koppelen aan een ingesloten element (een extern object zoals een afbeelding, geluid of lettertype dat in een SWF-bestand is gecompileerd). Elk ingesloten element wordt vertegenwoordigd door een uniek ingesloten klasse-element. U kunt een ingesloten element benaderen door met de operator new de gekoppelde klasse te instantiëren. Vervolgens kunt u de juiste methoden en eigenschappen van de ingesloten elementklasse aanroepen om het ingesloten element te manipuleren.

Als u liever klassen definieert met Function-objecten in plaats van met het trefwoord class, kunt u met de operator new objecten maken op basis van constructorfuncties. Haal constructorfuncties en constructormethoden van een klasse niet door elkaar. Een constructorfunctie is een object Function dat met het gereserveerde woord function is gedefinieerd maar geen deel uitmaakt van een klassedefinitie. Wanneer u constructorfuncties gebruikt om objecten te maken, moet u prototypeovererving gebruiken in plaats van klasseovererving.

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

Verwante API-elementen

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

Maakt een nieuw object en initialiseert dit met de opgegeven eigenschapparen name en value. Wanneer u deze operator gebruikt, is dit hetzelfde als wanneer u de syntaxis new Object gebruikt en de eigenschapparen met de toewijzingsoperator vult. Het prototype van het zojuist gemaakte object wordt normaliter het object Object genoemd.

Deze operator wordt ook gebruikt om blokken opeenvolgende code te markeren voor instructies (for, while, if, else, switch) en functies voor verloopbeheer.

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

Verwante API-elementen

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Voert een groeperende bewerking uit voor een of meer parameters, voert opeenvolgende evaluatie van expressies uit of omringt een of meer parameters en geeft ze als argumenten door aan een functie die aan de ronde haakjes voorafgaat.

Gebruik 1: bepaalt de volgorde waarin de operatoren worden uitgevoerd. Ronde haakjes overschrijven de normale prioriteitsvolgorde en zorgen dat de expressies binnen de ronde haakjes eerst worden geëvalueerd. Wanneer de ronde haakjes zijn genest, wordt eerst de inhoud van de binnenste ronde haakjes geëvalueerd en daarna de inhoud van de ronde haakjes daaromheen.

Gebruik 2: evalueert opeenvolgend een reeks door komma's gescheiden expressies en retourneert het resultaat van de laatste expressie.

Gebruik 3: omringt één of meer parameters en geeft ze door aan de functie die aan de haakjes voorafgaat.

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 

Verwante API-elementen

myXML.(expression)

Evalueert een expressie in een construct ECMAScript for XML (E4X). myXML.(lastName == "Smith") identificeert bijvoorbeeld XML-elementen met de naam lastName en de waarde "Smith". Het resultaat is een object 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

Verwante API-elementen

/pattern/flags

Bij gebruik vóór en na tekens wordt aangegeven dat de tekens een letterlijke waarde hebben en als een reguliere expressie (RegExp) worden beschouwd, niet als een variabele, tekenreeks of ander ActionScript-element. De twee slash-tekens ( //) geven het begin van een opmerking aan.

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

Verwante API-elementen

Test twee expressies op gelijkheid maar voert geen automatische gegevensomzetting uit. Het resultaat is true wanneer beide expressies, inclusief hun gegevenstypen, gelijk zijn.

De operator === (strikt gelijk aan) is op drie vlakken gelijk aan de operator == (gelijk aan):

• Getallen en Booleaanse waarden worden via hun waarde vergeleken en worden als gelijk beschouwd wanneer de waarden overeenkomen.
• Tekenreeksexpressies zijn gelijk wanneer deze hetzelfde aantal tekens bevatten en de tekens identiek zijn.
• Variabelen die objecten, arrays en functies vertegenwoordigen, worden via verwijzing vergeleken. Twee van dergelijke variabelen zijn gelijk wanneer deze naar hetzelfde object, dezelfde array of dezelfde functie verwijzen. Twee afzonderlijke arrays worden nooit als gelijk beschouwd, ook niet wanneer deze hetzelfde aantal elementen bevatten.

• De operator voor strikte gelijkheid voert alleen automatische gegevensomzetting uit voor de typen Number, int en uint, terwijl de operator voor ongelijk aan automatische gegevensomzetting uitvoert voor alle primitieve gegevenstypen.
• Bij vergelijking van null en undefined retourneert de operator voor strikte gelijkheid false.

Het eerste verschil is dat vergelijkingen tussen primitieve waarden en primitieve objecten die dezelfde waarde bevatten, true retourneren in ActionScript 3.0, maar false in eerdere versies. In lagere versies is het gegevenstype van een primitieve waarde Boolean, Number of String, terwijl het gegevenstype van een primitief object altijd Object is en niet Boolean, Number of String. In de praktijk heeft dit verschil tot gevolg dat in eerdere versies van ActionScript de volgende code resulteert in false omdat de gegevenstypen van de operanden niet overeenkomen. In ActionScript 3.0 is het resultaat echter true omdat primitieve waarden als Boolean, Number, int, uint of String worden getypeerd, of ze zich nu in een omvattend object bevinden of niet.

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 

Verwante API-elementen

Test op het tegenovergestelde van de operator === (strikt gelijk aan). De operator voor strikte ongelijkheid voert dezelfde bewerkingen uit als de operator voor ongelijkheid, behalve dat alleen de gegevenstypen int en uint worden omgezet.

Als expression1 gelijk is aan expression2 en hun gegevenstypen gelijk zijn, is het resultaat false.

De operator !== (strikt ongelijk aan) is op drie vlakken gelijk aan de operator != (ongelijk aan):

• Getallen en Booleaanse waarden worden via hun waarde vergeleken en worden als gelijk beschouwd wanneer de waarden overeenkomen.
• Tekenreeksexpressies zijn gelijk wanneer deze hetzelfde aantal tekens bevatten en de tekens identiek zijn.
• Variabelen die objecten, arrays en functies vertegenwoordigen, worden via verwijzing vergeleken. Twee van dergelijke variabelen zijn gelijk wanneer deze naar hetzelfde object, dezelfde array of dezelfde functie verwijzen. Twee afzonderlijke arrays worden nooit als gelijk beschouwd, ook niet wanneer deze hetzelfde aantal elementen bevatten.

• De operator !== (strikt ongelijk aan) voert alleen automatische gegevensomzetting uit voor de typen Number, int en uint, terwijl de operator != (ongelijk aan) automatische gegevensomzetting uitvoert voor alle primitieve gegevenstypen.
• Bij vergelijking van null en undefined, retourneert de operator !== (strikt ongelijk aan) 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 

Verwante API-elementen

 "text" 

Bij gebruik vóór en na tekens wordt aangegeven dat de tekens een letterlijke waarde hebben en als een tekenreeks worden beschouwd, niet als een variabele, een numerieke waarde of een ander ActionScript-element.

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

Verwante API-elementen

-expression

 expression1 - expression2

Wordt gebruikt voor negatie of aftrekken.

Gebruik 1: als de operator wordt gebruikt voor negatie, keert deze het teken van een numerieke expressie om.

Gebruik 2: als de operator wordt gebruikt voor aftrekken, voert deze een rekenkundige aftrekking uit op twee numerieke expressies, waarbij expression 2 wordt afgetrokken van expression1. Wanneer beide expressies gehele getallen zijn, is het verschil een geheel getal. Wanneer één of beide expressies drijvende-kommagetallen zijn, is het verschil een drijvende-kommagetal.

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

trace(5 - 2); // 3 

de volgende instructie trekt het drijvende-kommagetal 1,5 van het drijvende-kommagetal 3,25 af:

trace(3.25 - 1.5); // 1.75 

Wijst aan expression1 de waarde van expression1 - expression2 toe. De volgende twee instructies zijn bijvoorbeeld gelijk:

x -= y ;
x = x - y;

Tekenreeksexpressies moeten in getallen worden omgezet, anders is het resultaat NaN (Not a Number (geen getal)).

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 

Verwante API-elementen

[modifiers] var variableName:type

function functionName():type { ... }

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

Wordt gebruikt voor het toewijzen van een gegevenstype. Deze operator geeft het type van een variabele, het type van de geretourneerde waarde van de functie of het type van een parameter van de functie op. Wanneer de operator in een variabeledeclaratie of toewijzing wordt gebruikt, geeft deze het type van de variabele op. Wanneer de operator in een functiedeclaratie of definitie wordt gebruikt, geeft deze het type van de geretourneerde waarde van de functie op. Wanneer de operator met een functieparameter in een functiedefinitie wordt gebruikt, geeft deze het verwachte variabeletype op voor die parameter.

Controle van het type vindt plaats bij uitvoering. Wanneer de compiler is ingesteld op de strikte modus, worden alle typen echter bij compilatie gecontroleerd en worden fouten gegenereerd wanneer typen niet overeenkomen. Afwijkingen kunnen voorkomen tijdens toewijzingsbewerkingen, functieaanroepen en het oplossen van klasselidverwijzingen via de puntoperator ( .).

Typen die u kunt gebruiken, zijn alle native objecttypen, klassen en interfaces die u definieert en void. Erkende native typen zijn Boolean, Number, int, uint en String. Alle ingebouwde klassen worden ook als native typen ondersteund.

Wanneer u geen gegevenstype toewijst, wordt de variabele, geretourneerde waarde van de functie of functieparameter als zonder type beschouwd, zodat de waarde van elk gegevenstype kan zijn. Wanneer u duidelijk wilt maken dat u opzettelijk een waarde zonder type gebruikt, kunt u het sterretje (*) gebruiken als typeannotatie. Wanneer het sterretje als typeannotatie wordt gebruikt, staat dit gelijk aan het weglaten van het type voor een variabele, de geretourneerde waarde van een functie of een functieparameter.

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

Verwante API-elementen

Evalueert expression en retourneert een tekenreeks die het gegevenstype van de expressie opgeeft. Het resultaat is beperkt tot zes mogelijke tekenreekswaarden: boolean, function, number, object, string en xml. Wanneer u deze operator toepast op een instantie van een door de gebruiker gedefinieerde klasse, is het resultaat de tekenreeks object. De operator typeof is opgenomen voor achterwaartse compatibiliteit. Gebruik de operator is om te controleren op typecompatibiliteit.

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 

Verwante API-elementen

Evalueert een expressie, negeert de waarde ervan en retourneert undefined. De operator void wordt vaak gebruikt bij vergelijkingen die de operator == gebruiken om op ongedefinieerde waarden te testen.

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

Definieert een XML-tag in een letterlijke XML. Gebruik het slash-teken (/) om de afsluitingstag te definiëren.

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

Verwante API-elementen