Operatorer 

Lägger ihop numeriska uttryck. Om båda uttrycken är heltal är summan ett heltal. Om något av eller båda uttrycken är flyttal är summan ett flyttal.

Om ett uttryck är en sträng konverteras alla andra uttryck till strängar och sammanfogas i stället för att summeras. I annat fall, om ett uttryck inte är ett tal, konverteras det till ett tal i Flash^® Player.

trace(2 + 3); // 5

trace(2.5 + 3.25); // 5.75

trace("Number " + 8 + 0); // Number 80

var oldBalance:Number = 1345.23; 
var currentBalance = deposit_txt.text + oldBalance; 
trace(currentBalance); 

var oldBalance:Number = 1345.23; 
var currentBalance:Number = Number(deposit_txt.text) + oldBalance;
trace(currentBalance);

Relaterade API-element

Tilldelar expression1 värdet på expression1 + expression2. Till exempel får följande två programsatser samma resultat:

x += y; 
x = x + y; 

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

Relaterade API-element

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

Initierar en ny array eller flerdimensionell array med angivna element (a0 och så vidare) eller använder elementen i en array. Med arrayåtkomstoperatorn kan du dynamiskt ange och hämta instans-, variabel- och objektnamn. Du kan även använda den för att komma åt objektegenskaper.

Användning 1: En array är ett objekt vars egenskaper kallas element, där vart och ett av dessa identifieras av ett tal som kallas index. När du skapar en array omger du elementen med arrayåtkomstoperatorn ([]) (eller hakparenteser). En array kan innehålla element av olika typer. Följande array, som heter employee, har till exempel tre element. Det första är ett tal och de andra två är strängar (inom citattecken):

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

I följande exempel skapas en array med namnet employee_array med tre element och det tredje elementet i arrayen ändras.

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

Relaterade API-element

Utvärderar om ett uttryck som specificeras av den första operanden tillhör den datatyp som anges av den andra operanden. Om den första operanden tillhör datatypen blir resultatet den första operanden. Annars är värdet null.

Uttrycket som används för den andra operanden måste utvärderas till en datatyp.

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

Relaterade API-element

Tilldelar värdet på expression2 (operanden till höger) till variabeln, arrayelementet eller egenskapen i expression1. Tilldelning kan antingen ske med ett värde eller med en referens. Tilldelning med hjälp av värde kopierar det faktiska värdet för expression2 och lagrar det i expression1. Tilldelning med hjälp av värde sker när expression2 är ett primitivt värde, vilket betyder att dess datatyp är antingen Boolean, Number, int, uint eller String. Tilldelning med hjälp av referens lagrar en referens till expression2 i expression1. Tilldelning med hjälp av referens används ofta med operatorn new. Operatorn new skapar ett objekt i minnet, och en referens till den platsen i minnet tilldelas en variabel.

Obs! I ActionScript 3.0 är alla värden (inklusive primitiva värden) objekt, och all tilldelning sker med hjälp av referenser, men primitiva objekt har särskilda operatorer som innebär att de fungerar som om de tilldelats med hjälp av värde.

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

Relaterade API-element

 myXML.@attributeName 

Identifierar attribut för ett XML- eller XMLList-objekt. myXML.@id identifierar till exempel attribut med namnet id för XML-objektet myXML. Du kan också använda följande syntax för att komma åt attribut: myXML.attribute("id"), myXML["@id"] och myXML.@["id"]. Du bör använda syntaxen myXML.@id. Använd @* om du vill returnera ett XMLList-objekt med alla attributnamn. Om du vill returnera ett attribut med ett namn som matchar ett reserverat ord i ActionScript använder du metoden attribute() i stället för operatorn @.

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

Relaterade API-element

Konverterar expression1 och expression2 till 32-bitars heltal utan tecken och utför en boolesk AND-åtgärd på varje bit i heltalsparametrarna. Flyttal konverteras till heltal genom att alla siffror efter decimalkommat tas bort. Resultatet är ett nytt 32-bitars heltal.

Ett positivt heltal konverteras till ett hexadecimalt värde utan tecken med ett maximalt värde på 4294967295 eller 0xFFFFFFFF. För ett värde som är högre än det maximala värdet tas de mest betydande siffrorna bort när det konverteras, så att värdet förblir 32 bitar. Ett negativt tal konverteras till ett hexadecimalt värde utan tecken med hjälp av tvåkomplementnotation och det minsta värdet är -2147483648 eller 0x800000000. Ett tal som är mindre än det minsta värdet konverteras till tvåkomplement med större precision innan de viktigaste siffrorna tas bort.

Resultatet tolkas som ett 32-bitars tvåkomplementtal så att resultatet är ett heltal i området -2147483648 till 2147483647.

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

  1101
& 1011
  ----
  1001

I följande exempel visas beteendet för returvärdeskonverteringen:

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

Relaterade API-element

Tilldelar expression1 värdet på expression1 & expression2. Följande två uttryck är likvärdiga:

x &= y; 
x = x & y; 

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

Relaterade API-element

Konverterar expression1 och shiftCount till 32-bitars heltal och flyttar alla bitar i expression1 till vänster med det antal platser som anges av heltalet i resultatet av konverteringen av shiftCount. Bitpositionerna som töms på grund av den här åtgärden fylls i med 0 och bitar som flyttas från vänsteränden tas bort. Att flytta ett värde till vänster med en position är samma sak som att multiplicera det med 2.

Flyttal konverteras till heltal genom att alla siffror efter decimalkommat tas bort. Ett positivt heltal konverteras till ett hexadecimalt värde utan tecken med ett maximalt värde på 4294967295 eller 0xFFFFFFFF. För ett värde som är högre än det maximala värdet tas de mest betydande siffrorna bort när det konverteras, så att värdet förblir 32 bitar. Ett negativt tal konverteras till ett hexadecimalt värde utan tecken med hjälp av tvåkomplementnotation och det minsta värdet är -2147483648 eller 0x800000000. Ett tal som är mindre än det minsta värdet konverteras till tvåkomplement med större precision innan de viktigaste siffrorna tas bort.

Resultatet tolkas som ett 32-bitars tvåkomplementtal så att resultatet är ett heltal i området -2147483648 till 2147483647.

Om resultatet är ett negativt heltal inträffar ett körningsfel om du försöker tilldela resultatet till en variabel av typen uint. ActionScript har visserligen ingen "vänsterflyttning i bitform utan tecken"-operatorn, men du kan uppnå samma effekt och undvika körningsfel om du använder uint(expression1 << shiftCount):

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

   00000000001 binary 
<<          10 decimal
--------------
   10000000000 binary equals 1024 decimal 

I följande exempel flyttas heltalet 7 åtta bitar till vänster:

x = 7 << 8

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

Följande trace-programsats visar att bitarna har flyttats tre steg åt vänster:

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

Relaterade API-element

Utför en åtgärd med vänsterflyttning i bitform (<<=) och lagrar innehållet som ett resultat i expression1. Följande två uttryck är likvärdiga:

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 

Relaterade API-element

Konverterar expression till ett 32-bitars heltal med tecken och tillämpar sedan ett enkomplementtal i bitform. Det innebär att varje bit som är en nolla blir 1 i resultatet och varje bit som är en etta blir 0 i resultatet. Resultatet är ett 32-bitars heltal med tecken. Denna operatorn kallas även enkomplementsoperator eller en komplementoperator i bitform.

Det hexadecimala värdet 0x7777 representeras till exempel av det här binära talet:

0111011101110111

Bitnegationen för det hexadecimala värdet, ~0x7777, är det här binära talet:

1000100010001000

I hexadecimal form är det 0x8888. Därför är ~0x7777 0x8888.

Det vanligaste användningsområdet för bitoperatorer är representation av flaggbitar (booleska värden som lagras i en bit vardera).

Flyttal konverteras till heltal genom att alla siffror efter decimalkommat tas bort. Ett positivt heltal konverteras till ett hexadecimalt värde utan tecken med ett maximalt värde på 4294967295 eller 0xFFFFFFFF. För ett värde som är högre än det maximala värdet tas de mest betydande siffrorna bort när det konverteras, så att värdet förblir 32 bitar. Ett negativt tal konverteras till ett hexadecimalt värde utan tecken med hjälp av tvåkomplementnotation och det minsta värdet är -2147483648 eller 0x800000000. Ett tal som är mindre än det minsta värdet konverteras till tvåkomplement med större precision innan de viktigaste siffrorna tas bort.

Resultatet tolkas som ett 32-bitars tvåkomplementtal så att resultatet är ett heltal i området -2147483648 till 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 

Relaterade API-element

Konverterar expression1 och expression2 till 32-bitars heltal utan tecken och placerar en etta i varje bitposition, där de motsvarande bitarna för expression1 eller expression2 är 1.

Flyttal konverteras till heltal genom att alla siffror efter decimalkommat tas bort. Ett positivt heltal konverteras till ett hexadecimalt värde utan tecken med ett maximalt värde på 4294967295 eller 0xFFFFFFFF. För ett värde som är högre än det maximala värdet tas de mest betydande siffrorna bort när det konverteras, så att värdet förblir 32 bitar. Ett negativt tal konverteras till ett hexadecimalt värde utan tecken med hjälp av tvåkomplementnotation och det minsta värdet är -2147483648 eller 0x800000000. Ett tal som är mindre än det minsta värdet konverteras till tvåkomplement med större precision innan de viktigaste siffrorna tas bort.

Resultatet tolkas som ett 32-bitars tvåkomplementtal så att resultatet är ett heltal i området -2147483648 till 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) 

Relaterade API-element

Tilldelar expression1 värdet på expression1 | expression2. Följande två programsatser är till exempel likvärdiga:

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) 

Relaterade API-element

Konverterar expression och shiftCount till 32-bitars heltal och flyttar alla bitar i expression till höger med det antal platser som anges av heltalet i resultatet av konverteringen av shiftCount. Bitar som flyttas från högersidan tas bort. För att behålla tecknet för det ursprungliga uttrycket fylls bitarna till vänster i med 0 om den viktigaste biten (biten längst till vänster) i expression är 0, och de fylls i med 1 om den viktigaste biten är 1. Att flytta ett värde åt höger med en position är detsamma som att dela med 2 och ta bort resten.

Flyttal konverteras till heltal genom att alla siffror efter decimalkommat tas bort. Ett positivt heltal konverteras till ett hexadecimalt värde utan tecken med ett maximalt värde på 4294967295 eller 0xFFFFFFFF. För ett värde som är högre än det maximala värdet tas de mest betydande siffrorna bort när det konverteras, så att värdet förblir 32 bitar. Ett negativt tal konverteras till ett hexadecimalt värde utan tecken med hjälp av tvåkomplementnotation och det minsta värdet är -2147483648 eller 0x800000000. Ett tal som är mindre än det minsta värdet konverteras till tvåkomplement med större precision innan de viktigaste siffrorna tas bort.

Resultatet tolkas som ett 32-bitars tvåkomplementtal så att resultatet är ett heltal i området -2147483648 till 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)

Relaterade API-element

Utför en åtgärd med högerflyttning i bitform och lagrar resultat i expression.

Följande två programsatser är likvärdiga:

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.

Relaterade API-element

Samma som operatorn för högerflyttning i bitform (>>), förutom att den inte bevarar tecknet i det ursprungliga uttrycket eftersom bitarna till vänster alltid fylls med 0.

Flyttal konverteras till heltal genom att alla siffror efter decimalkommat tas bort. Ett positivt heltal konverteras till ett hexadecimalt värde utan tecken med ett maximalt värde på 4294967295 eller 0xFFFFFFFF. För ett värde som är högre än det maximala värdet tas de mest betydande siffrorna bort när det konverteras, så att värdet förblir 32 bitar. Ett negativt tal konverteras till ett hexadecimalt värde utan tecken med hjälp av tvåkomplementnotation och det minsta värdet är -2147483648 eller 0x800000000. Ett tal som är mindre än det minsta värdet konverteras till tvåkomplement med större precision innan de viktigaste siffrorna tas bort.

Resultatet tolkas som ett 32-bitars tvåkomplementtal utan tecken så att resultatet är ett heltal i området 0 till 4294967295.

Obs! ActionScript har ingen "vänsterflyttning i bitform utan tecken"-operatorn, men du kan uppnå samma sak med uint(expression << shiftCount).

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

Relaterade API-element

Utför en åtgärd med högerflyttning i bitform utan tecken och lagrar resultat i expression. Följande två programsatser är likvärdiga:

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

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

Relaterade API-element

Konverterar expression1 och expression2 till 32-bitars heltal utan tecken och placerar en etta i varje bitposition, där de motsvarande bitarna för expression1 eller expression2 (men inte båda) är 1.

Flyttal konverteras till heltal genom att alla siffror efter decimalkommat tas bort. Ett positivt heltal konverteras till ett hexadecimalt värde utan tecken med ett maximalt värde på 4294967295 eller 0xFFFFFFFF. För ett värde som är högre än det maximala värdet tas de mest betydande siffrorna bort när det konverteras, så att värdet förblir 32 bitar. Ett negativt tal konverteras till ett hexadecimalt värde utan tecken med hjälp av tvåkomplementnotation och det minsta värdet är -2147483648 eller 0x800000000. Ett tal som är mindre än det minsta värdet konverteras till tvåkomplement med större precision innan de viktigaste siffrorna tas bort.

Resultatet tolkas som ett 32-bitars tvåkomplementtal så att resultatet är ett heltal i området -2147483648 till 2147483647.

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

Relaterade API-element

Tilldelar expression1 värdet på expression1 ^ expression2. Följande två programsatser är till exempel likvärdiga:

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) 

Relaterade API-element

/* comment */

/* comment

   comment */

Avgränsar en eller flera rader med skriptkommentarer. Tecken mellan den inledande avgränsaren (/*) och den avslutande avgränsaren (*/) tolkas som en kommentar och ignoreras av ActionScript-kompileraren. Använd dessa avgränsare för att identifiera kommentarer som sträcker sig över flera rader. För enradiga kommentarer använder du avgränsaren //.

Om du utelämnar den avslutande blockkommentaravgränsaren (*/) eller försöker kapsla in kommentarer får du ett felmeddelande. När du har använt en inledande avgränsare (/*) avslutar den första avslutande avgränsaren (*/) kommentaren, oavsett hur många inledande avgränsare som placerats före den.

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

Relaterade API-element

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

Utvärderar ett uttryck som används i en XML- eller XMLList-initierare. En XML- eller XMLList-initierare är ett litteralt värde som tilldelas till en variabel av typ XML eller XMLList. Ett uttryck som avgränsas av XML-operatorerna { och } kan användas i en XML- eller XMLList-initierare i stället för namn eller värden. Du kan använda ett uttryck i stället för tagName, attributeName, attributeValue och 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>

Relaterade API-element

 myXML[expression]

Använder en egenskap eller ett attribut för ett XML- eller XMLList-objekt. Med hakparentesoperatorn kan du komma åt egenskapsnamn som inte är tillgängliga med punktoperatorn (.).

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

Relaterade API-element

Utvärderar expression1, sedan expression2 o.s.v. Den här operatorn används främst med slingprogramsatsen for och ofta med parentesoperatorn ().

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 

Relaterade API-element

Sammanfogar (kombinerar) strängar. Om ett uttryck är en sträng konverteras alla andra uttryck till strängar och sammanfogas.

Om båda uttrycken är tal fungerar operatorn som en additionsoperator.

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 

Relaterade API-element

expression1 + expression2

Sammanfogar (kombinerar) XML- eller XMLList-värden till ett XMLList-objekt. Ett XMLList-objekt resulterar bara om bägge operanderna är XML- eller XMLList-värden.

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

Programsatsen trace ger följande utdata:

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

Relaterade API-element

Tilldelar expression1 värdet på expression1 + expression2. Till exempel får följande två programsatser samma resultat:

x += y; 
x = x + y;

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

Relaterade API-element

expression1 += expression2

Tilldelar expression1, som är ett XMLList-objekt, värdet på expression1 + expression2. Till exempel får följande två programsatser samma resultat:

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

Programsatsen trace ger följande utdata:

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

<location>Springfield</location>

Relaterade API-element

expression1 ? expression2 : expression3

Utvärderar expression1, och om värdet på expression1 är true är resultatet värdet för expression2; i annat fall är resultatet värdet för 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--

Subtraherar 1 från operanden. Operanden kan vara en variabel, ett element i en array eller en objektegenskap. Operatorformen för förhandsminskning (--expression) subtraherar 1 från expression och returnerar resultatet. Operatorformen för efterhandsminskning (expression--) subtraherar 1 från expression och returnerar det ursprungliga värdet för expression (värdet före subtraktionen).

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

Förstör den objektegenskap som anges av reference. Resultatet är true om egenskapen inte finns när åtgärden har slutförts, i annat fall är det false. Operatorn delete returnerar true om den anropas för en egenskap som inte finns eller en dynamisk egenskap som inte är definierad i en klass.

Operatorn delete kan misslyckas och returnera false om parametern reference inte kan tas bort. Du kan inte ta bort fasta egenskaper eller variabler som deklarerats med var-programsatsen. En fast egenskap är en variabel eller metod som definierats i en klassdefinition.

Operatorn delete kan inte användas för att radera en klassegenskap, såvida det inte är en dynamisk klass som lagts till under körningen. Egenskaper för slutna klasser kan inte tas bort med delete. Ställ i stället in egenskapen på null.

Obs! Du kan inte ta bort ett objekt, men du kan göra det åtkomligt för skräpinsamlingen genom att ta bort alla referenser till objektet. Den vanligaste referensen till ett objekt är en variabel som pekar på den. Du kan ta bort sådana referenser genom att ställa in variabeln på null. Skräpsamlaren tar bort alla objekt som inte har referenser.

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

I följande exempel tas värdet för ett array-element bort, men värdet för length-egenskapen ändras inte:

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,

I följande exempel visas hur det returnerade booleska värdet från delete kan användas som villkor för framtida kodkörning. Tänk på att om ett objekt redan har tagits bort returneras false om du anropar delete på objektet igen.

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

Relaterade API-element

 delete reference

Tar bort de XML-element eller -attribut som anges av 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());

Följande utdata skapas:

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

Utdata för detta exempel är följande:

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

 myXML..childElement1..@attributeName 

Navigerar till underordnade element i ett XML- eller XMLList-objekt eller hittar (i kombination med operatorn @) matchande attribut för underordnade. De matchande elementen eller attributen måste inte vara direkt underordnade XML- eller XMLList-objektet – de kan befinna sig längre ned i trädet (exempelvis indirekt underordnade). Resultatet är ett XMLList-objekt, eftersom fler än ett underordnat element eller attribut kan matcha.

Ordningen på noderna i det XMLList-objekt som returneras är resultatet av en förflyttning av typen djupet först. Fundera på följande:

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

Detta resulterar i följande utdata:

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

Om du vill returnera underordnade objekt med namn som matchar reserverade ord i ActionScript använder du metoden XML.descendants() i stället för den underordnade operatorn (..), som i följande exempel:

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

Relaterade API-element

Dividerar expression1 med expression2. Resultatet av divisionsåtgärden är ett flyttal med dubbel precision.

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

Relaterade API-element

Tilldelar expression1 värdet på expression1 / expression2. Följande två programsatser är till exempel likvärdiga:

x /= y; 
x = x / y;

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

Relaterade API-element

object.property_or_method

Hämtar klassvariabler och -metoder, hämtar och lägger in objektegenskaper och avgränsar importerade paket eller klasser.

import flash.utils.Timer;

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

Relaterade API-element

myXML.childElement
myXML.@attributeName 

Navigerar till underordnade element för ett XML- eller XMLList-objekt eller (i kombination med operatorn @) returnerar attribut för ett XML- eller XMLList-objekt. Det returnerade objektet är ett XMLList-objekt, eftersom fler än ett underordnat element eller attribut kan matcha.

Om du vill returnera element med namn som matchar reserverade ord i ActionScript använder du metoden XML.elements() eller metoden XML.descendants() i stället för XML-punktoperatorn (.), som i följande exempel:

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

Relaterade API-element

Testar om två uttryck är lika. Resultatet blir true om uttrycken är lika.

Om datatyperna för de två operanderna matchar, beror definitionen av likhet på operandernas datatyp:

• Värden av typen int, uint och Boolean anses vara lika om de har samma värde.
• Tal med matchande värden anses vara lika, såvida de inte båda är NaN.
• Om värdet för båda operanderna är null eller undefined anses de vara lika.
• Stränguttryck är lika om de har samma antal tecken och tecknen är identiska.
• För XML-objekt:
  • Om en operand är en text- eller attributnod, och den andra har enkelt innehåll, konverteras båda operanderna till strängar med metoden toString() och betraktas som lika om de resulterande strängarna matchar.
  • Annars betraktas endast objekt som lika om det kvalificerade namnet, attribut och underordnade egenskaper för båda objekten matchar.
• XMLList-objekt betraktas som lika om de har samma antal egenskaper, och egenskapernas ordning och värden stämmer överens.
• För Namespace-objekt betraktas värdena som lika om egenskapen uri är samma för båda objekten.
• För QName-objekt betraktas värdena som lika om egenskapen uri är samma för båda objekten och egenskapen localName är samma för båda objekten.
• Variabler som representerar objekt, arrayer och funktioner jämförs utifrån referens. Två sådana variabler är lika om de refererar till samma objekt, array eller funktion. Två olika arrayer anses aldrig vara lika, även om de innehåller samma antal element.

• Operandernas värden är undefined och null, och då är resultatet true.
• Automatisk datatypkonvertering konverterar datatyper av värdena String, Boolean, int, uint och Number till kompatibla typer och de konverterade värdena är lika, vilket innebär att operanderna anses vara lika.
• En operand är av typen XML med enkelt innehåll (hasSimpleContent() == true), och när båda operanderna har konverterats till strängar med metoden toString() stämmer de resulterande strängarna överens.
• En operand är av typen XMLList, och något av följande villkor är sant:
  • Egenskapen length för XMLList-objektet är 0, och det andra objektet är undefined.
  • Egenskapen length för XMLList-objektet är 1, och ett element i XMLList-objektet matchar den andra operanden.

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 

Relaterade API-element

Jämför två uttryck och avgör om expression1 är större än expression2. I så fall är resultatet true. Om expression1 är mindre än eller lika med expression2 är resultatet false.

Om båda operanderna är av typen String jämförs de i alfabetisk ordning, med versaler före gemener. I annat fall konverteras operander först till tal och jämförs sedan.

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

Jämför två uttryck och avgör om expression1 är större än eller lika med expression2 (true) eller om expression1 är mindre än expression2 (false).

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

Relaterade API-element

Utvärderar om en egenskap utgör en del av ett specifikt objekt. Om du vill använda in-operatorn anger du ett egenskapsnamn som första operand och ett objekt som andra operand. Om det angivna objektet innehåller egenskapen blir resultatet true. I annat fall blir resultatet false.

Om det angivna objektet är ett Array-objekt kan du använda in-operatorn för att kontrollera om ett visst indexnummer är giltigt. Om du skickar ett heltal som första operand blir resultatet true om indexet ligger inom det giltiga intervallet för indexnummer. I annat fall blir resultatet false.

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

I följande exempel används in-operatorn för att visa att talen 0, 1 och 2 är giltiga indextal i myArray-objektet, men att talet 3 däremot inte är det.

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

Relaterade API-element

++expression

 expression++

Lägger till 1 till ett uttryck. Uttrycket kan vara en variabel, ett element i en array eller en objektegenskap. Operatorformen för förhandsökning (++expression) lägger till 1 i expression och returnerar resultatet. Operatorformen för efterhandsökning (expression++) lägger till 1 i expression och returnerar det ursprungliga värdet för expression (värdet före additionen).

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

Testar den exakta motsatsen till likhetsoperatorn (==). Om expression1 är lika med expression2 är resultatet false. Precis som med likhetsoperatorn (==) beror definitionen för likhet på de datatyper som jämförs.

Om datatyperna för de två operanderna matchar, beror definitionen av likhet på operandernas datatyp:

• Värden av typen int, uint och Boolean anses vara lika om de har samma värde.
• Tal med matchande värden anses vara lika, såvida de inte båda är NaN.
• Om värdet för båda operanderna är null eller undefined anses de vara lika.
• Stränguttryck är lika om de har samma antal tecken och tecknen är identiska.
• För XML-objekt:
  • Om en operand är en text- eller attributnod, och den andra har enkelt innehåll, konverteras båda operanderna till strängar med metoden toString() och betraktas som lika om de resulterande strängarna matchar.
  • Annars betraktas endast objekt som lika om det kvalificerade namnet, attribut och underordnade egenskaper för båda objekten matchar.
• XMLList-objekt betraktas som lika om de har samma antal egenskaper, och egenskapernas ordning och värden stämmer överens.
• För Namespace-objekt betraktas värdena som lika om egenskapen uri är samma för båda objekten.
• För QName-objekt betraktas värdena som lika om egenskapen uri är samma för båda objekten och egenskapen localName är samma för båda objekten.
• Variabler som representerar objekt, arrayer och funktioner jämförs utifrån referens. Två sådana variabler är lika om de refererar till samma objekt, array eller funktion. Två olika arrayer anses aldrig vara lika, även om de innehåller samma antal element.

• Operandernas värden är undefined och null, och då är resultatet true.
• Automatisk datatypkonvertering konverterar datatyper av värdena String, Boolean, int, uint och Number till kompatibla typer och de konverterade värdena är lika, vilket innebär att operanderna anses vara lika.
• En operand är av typen XML med enkelt innehåll (hasSimpleContent() == true), och när båda operanderna har konverterats till strängar med metoden toString() stämmer de resulterande strängarna överens.
• En operand är av typen XMLList, och något av följande villkor är sant:
  • Egenskapen length för XMLList-objektet är 0, och det andra objektet är undefined.
  • Egenskapen length för XMLList-objektet är 1, och ett element i XMLList-objektet matchar den andra operanden.

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

Relaterade API-element

Utvärderar om ett uttrycks prototypkedja innefattar prototypobjektet för function. Operatorn instanceof inkluderas för bakåtkompatibilitet med ECMAScript version 3, och den kan vara användbar för avancerade programmerare som väljer att använda prototypbaserat arv med konstruktorfunktioner i stället för klasser.

Använd is-operatorn för att kontrollera om ett objekt tillhör en viss datatyp.

När instanceof-operatorn används med klasser liknar den is-operatorn, eftersom en klass prototypkedja består av alla dess superklasser. Gränssnitt inkluderas däremot inte i prototypkedjor, så instanceof-operatorn ger alltid resultatet false när den används med gränssnitt, medan is-operatorn ger resultatet true om ett objekt tillhör en klass som implementerar det angivna gränssnittet.

Obs! ActionScript-operatorn is motsvarar Java-operatorn 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

Relaterade API-element

Utvärderar om ett objekt är kompatibelt med en viss datatyp, en viss klass eller ett visst gränssnitt. Använd is-operatorn i stället för instanceof-operatorn för typjämförelser. Du kan också använda is-operatorn för att kontrollera om ett objekt implementerar ett gränssnitt.

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

Relaterade API-element

Jämför två uttryck och avgör om expression1 är mindre än expression2. I så fall är resultatet true. Om expression1 är större än eller lika med expression2 är resultatet false.

Om båda operanderna är av typen String jämförs de i alfabetisk ordning, med versaler före gemener. I annat fall konverteras operander först till tal och jämförs sedan.

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 

Jämför två uttryck och avgör om expression1 är mindre än eller lika med expression2. I så fall är resultatet true. Om expression1 är större än expression2 är resultatet false.

Om båda operanderna är av typen String jämförs de i alfabetisk ordning, med versaler före gemener. I annat fall konverteras operander först till tal och jämförs sedan.

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 

Anger början på en skriptkommentar. Tecken mellan kommentaravgränsaren (//) och radslutstecknet tolkas som en kommentar och ignoreras. Använd den här avgränsaren för enradiga kommentarer. För kommentarer som löper över flera på varandra följande rader använder du avgränsarna /* och */.

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

Relaterade API-element

Returnerar expression1 om det är false eller kan konverteras till false; i annat fall returneras expression2. Exempel på värden som kan konverteras till false är 0, NaN, null och undefined. Om du använder ett funktionsanrop som expression2 anropas funktionen inte omexpression1 utvärderas till false.

Om båda operanderna är av typen Boolean är resultatet true endast om båda operanderna är true, som i följande tabell:

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

Relaterade API-element

Tilldelar expression1 värdet på expression1 && expression2. Följande två programsatser är till exempel likvärdiga:

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

Relaterade API-element

Inverterar det booleska värdet för en variabel eller ett uttryck. Om expression är en variabel med det absoluta eller konverterade värdet true är värdet på !expression false. Om uttrycket x && y utvärderas till false utvärderas uttrycket !(x && y) till true.

Följande uttryck visar resultatet med operatorn logiskt NOT (!):

• !true returnerar false.
• !false returnerar true.

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

Relaterade API-element

Returnerar expression1 om det är true eller kan konverteras till true, och i annat fall returneras expression2. Om du använder ett funktionsanrop som expression2 anropas inte funktionen omexpression1 utvärderas till true.

Om båda operanderna är av typen Boolean är resultatet true om något eller båda uttrycken är true. Resultatet är false endast om båda uttrycken är false, som i följande tabell:

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 
} 

I följande exempel beskrivs hur ett funktionsanrop som används som andra operand kan ge oväntade resultat. Om uttrycket till vänster om operatorn utvärderas till true returneras det resultatet utan att uttrycket till höger utvärderas (funktionen fx2() anropas inte).

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

Relaterade API-element

Tilldelar expression1 värdet på expression1 || expression2. Följande två programsatser är till exempel likvärdiga:

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

myVar ||= "default";

Relaterade API-element

Beräknar återstoden av expression1 delat med expression2. Om någon av operanderna är icke-numerisk försöker modulo-operatorn (%) att konvertera den till ett tal.

Tecknet för modulo-resultatet matchar tecknet för täljaren (det första talet). Till exempel utvärderas både -4 % 3 och -4 % -3 till -1.

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

Relaterade API-element

Tilldelar expression1 värdet på expression1 % expression2. Följande två programsatser är likvärdiga:

x %= y; 
x = x % y; 

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

Relaterade API-element

Multiplicerar två numeriska uttryck. Om båda uttrycken är heltal är produkten ett heltal. Om något av eller båda uttrycken är flyttal är produkten ett flyttal.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

Tilldelar expression1 värdet på expression1 * expression2. Följande två uttryck är likvärdiga:

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 

Relaterade API-element

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identifierar namnutrymmet för en egenskap, en metod, en XML-egenskap eller ett XML-attribut.

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

Relaterade API-element

Instansierar en klassinstans. Operatorn new kan användas med en klass eller variabel av typen Class för att skapa en klassinstans. Operatorn new används vanligtvis med ett klassobjekt för att skapa en instans av en klass. Programsatsen new Sprite() skapar exempelvis en instans av klassen Sprite.

Operatorn new kan också användas för att koppla en klass till en inbäddad resurs, vilket är ett externt objekt som en bild, ett ljud eller ett teckensnitt som kompileras till en SWF-fil. Varje inbäddad resurs representeras av en unik inbäddad resursklass. Om du vill öppna en inbäddad resurs måste du använda operatorn new för att instansiera dess associerade klass. Sedan kan du anropa lämpliga metoder och egenskaper för den inbäddade resursklassen och ändra den inbäddade resursen.

Om du föredrar att definiera klasser med funktionsobjekt i stället för nyckelordet class kan du använda operatorn new för att skapa objekt baserat på konstruktorfunktioner. Blanda inte ihop konstruktorfunktioner med konstruktormetoder i en klass. En konstruktorfunktion är ett funktionsobjekt som definieras med nyckelordet function, men som inte tillhör en klassdefinition. Om du använder konstruktorfunktioner för att skapa objekt måste du använda prototyparv i stället för klassarv.

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

Relaterade API-element

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

Skapar ett nytt objekt och initierar det med de angivna egenskapsparen name och value. Att använda den här operatorn är samma sak som att använda syntaxen new Object och fylla i egenskapsparen med tilldelningsoperatorn. Prototypen för det nyskapade objektet kallas allmänt för objektet Object.

Den här operatorn används även för att markera block med sammanhängande kod som är kopplad till programsatser för flödeskontroll (for, while, if, else, switch) samt funktioner.

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

Relaterade API-element

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Utför en grupperingsåtgärd på en eller flera parametrar, utför sekventiell utvärdering av uttryck eller omger en eller fler parametrar och skickar dem som argument till en funktion som föregår parentesen.

Användning 1: Styr i vilken ordning operatorerna utförs. Parenteser åsidosätter den vanliga ordningen och gör att uttrycken inom parenteser utvärderas först. När parenteser kapslas utvärderas innehållet i de innersta parenteserna före innehållet i de yttre.

Användning 2: Utvärderar en serie sekventiella uttryck, som avgränsas med kommatecken, och returnerar resultatet av det sista uttrycket.

Användning 3: Omger en eller flera parametrar och skickar dem till den funktion som föregår parenteserna.

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 

Relaterade API-element

myXML.(expression)

Utvärderar ett uttryck i ett ECMAScript för XML (E4X) XML-konstruktion. myXML.(lastName == "Smith") identifierar till exempel XML-element med namnet lastName och värdet "Smith". Resultatet är ett XMLList-objekt.

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

Relaterade API-element

/pattern/flags

Vid användning före och efter tecken visar de att tecknen har ett strängvärde och anses vara ett reguljärt uttryck (RegExp), inte en variabel, sträng eller något annat ActionScript-element. Observera emellertid att två på varandra följande snedstreck (//) visar början på en kommentar.

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

Relaterade API-element

Testar om två uttryck är lika, men utför inte automatisk datakonvertering. Resultatet är true om båda uttrycken, inklusive de tillhörande datatyperna, är lika.

Operatorn strikt likhet (===) är samma som likhetsoperatorn (==) på tre sätt:

• Tal och booleska värden jämförs utifrån värde och anses vara lika om de har samma värde.
• Stränguttryck är lika om de har samma antal tecken och tecknen är identiska.
• Variabler som representerar objekt, arrayer och funktioner jämförs utifrån referens. Två sådana variabler är lika om de refererar till samma objekt, array eller funktion. Två olika arrayer anses aldrig vara lika, även om de innehåller samma antal element.

• Operatorn strikt likhet utför endast automatisk datakonvertering för taltyper (Number, int och uint), medan likhetsoperatorn utför automatisk datakonvertering för alla primitiva datatyper.
• Vid en jämförelse av null och undefined returnerar operatorn strikt likhet värdet false.

För det första returnerar jämförelser mellan primitiva värden och primitiva objekt som innehåller samma värde true i ActionScript 3.0, men false i tidigare versioner. I tidigare versioner är datatypen för ett primitivt värde antingen Boolean, Number eller String, medan datatypen för ett primitivt objekt alltid är Object och inte Boolean, Number eller String. Den praktiska effekten av den här skillnaden är att följande kod resulterar i false i tidigare versioner av ActionScript, eftersom operandernas datatyper inte matchar. I ActionScript 3.0 är resultatet emellertid true, eftersom primitiva värden är av typen Boolean, Number, int, uint eller String, vare sig de är placerade i ett objekt eller inte.

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 

Relaterade API-element

Testar den exakta motsatsen till operatorn för strikt likhet (===). Operatorn strikt olikhet utför samma åtgärder som operatorn inequality, förutom att endast datatyperna int och uint konverteras.

Om expression1 är lika med expression2, och deras datatyper är lika, är resultatet false.

Operatorn strikt olikhet (!==) är samma som operatorn olikhet (!=) på tre sätt:

• Tal och booleska värden jämförs utifrån värde och anses vara lika om de har samma värde.
• Stränguttryck är lika om de har samma antal tecken och tecknen är identiska.
• Variabler som representerar objekt, arrayer och funktioner jämförs utifrån referens. Två sådana variabler är lika om de refererar till samma objekt, array eller funktion. Två olika arrayer anses aldrig vara lika, även om de innehåller samma antal element.

• Operatorn strikt olikhet (!==) utför endast automatisk datakonvertering för taltyper, Number, int och uint, medan olikhetsoperatorn (!=) utför automatisk datakonvertering för alla primitiva datatyper.
• Vid en jämförelse av null och undefined returnerar operatorn strikt olikhet (!==) värdet 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 

Relaterade API-element

 "text" 

Vid användning före och efter tecken visar de att tecknen har ett strängvärde och anses vara en sträng, inte en variabel, ett numeriskt värde eller något annat ActionScript-element.

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

Relaterade API-element

-expression

 expression1 - expression2

Används för negering eller subtraktion.

Användning 1: När operatorn används för negation inverteras tecknet för ett numeriskt uttryck.

Användning 2: När operatorn används för subtraktion utför den en aritmetisk subtraktion på två numeriska uttryck och subtraherar expression2 från expression1. Om båda uttrycken är heltal är differensen ett heltal. Om något av, eller båda uttrycken är flyttal är differensen ett flyttal.

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

trace(5 - 2); // 3 

Följande programsats subtraherar flyttalet 1,5 från flyttalet 3,25:

trace(3.25 - 1.5); // 1.75 

Tilldelar expression1 värdet på expression1 - expression2. Följande två programsatser är till exempel likvärdiga:

x -= y ;
x = x - y;

Stränguttryck måste konverteras till tal, annars returneras NaN (inte ett tal).

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 

Relaterade API-element

[modifiers] var variableName:type

function functionName():type { ... }

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

Denna operatorn används för tilldelning av en datatyp och specificerar variabeltypen, funktionsreturtypen eller funktionsparametertypen. När den används i en variabeldeklaration eller i en tilldelning anger den här operatorn variabelns typ. När den används i en funktionsdeklaration eller -definition anger operatorn funktionens returtyp. Används den med en funktionsparameter i en funktionsdefinition anger operatorn variabeltypen som förväntas för den parametern.

Typkontroll sker alltid vid körning. Men om kompilatorn är inställd på strikt läge kontrolleras alla typer vid kompileringen, och fel genereras vid felmatchningar. Felmatchningar kan uppstå under tilldelningsåtgärder, funktionsanrop och avreferering av klassmedlemmar med punktoperatorn (.).

Typer som du kan använda omfattar interna objekttyper, klasser och gränssnitt som du anger samt void. De giltiga interna typerna är Boolean, Number, int, uint och String. Inbyggda klasser stöds också som interna typer.

Om du inte tilldelar någon datatyp betraktas variabeln, funktionsreturvärdet eller funktionsparametern som icke typbestämd vilket betyder att värdet kan vara vilken datatyp som helst. Om du vill tydliggöra att du tänker använda ett icke typbestämt värde kan du använda asterisken (*) som typanteckning. När asterisken används som typanteckning är den likvärdig med att ange en variabel, funktionsreturtyp eller funktionsparameter som icke typbestämd.

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

Relaterade API-element

Utvärderar expression och returnerar en sträng som anger uttryckets datatyp. Resultatet begränsas till sex möjliga strängvärden: boolean, function, number, object, string och xml. Om du använder den här operatorn på en instans av en användardefinierad klass blir resultatet strängen object. Operatorn typeof ingår för bakåtkompatibilitet. Använd is-operatorn för att kontrollera typkompatibilitet.

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 

Relaterade API-element

Utvärderar ett uttryck och tar sedan bort dess värde och returnerar undefined. Operatorn void används ofta i jämförelser där operatorn == används för att kontrollera om det finns odefinierade värden.

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

Definierar en XML-tagg i en XML-litteral. Använd ett snedstreck / för att definiera den avslutande taggen.

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

Relaterade API-element