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;