Array

Paket	Översta nivån
Klass	public dynamic class Array
Arv	Array Object

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Med klassen Array kan du använda och ändra arrayer. Arrayindexvärden är nollbaserade, vilket innebär att det första elementet i arrayen är [0], det andra elementet är [1] osv. Om du vill skapa ett Array-objekt använder du konstruktorn new Array(). Array() kan även anropas som en funktion. Du kan dessutom använda arrayåtkomstoperatorn ([]) när du initierar en array eller för att komma åt elementen i en array.

Du kan spara en mängd olika datatyper i arrayelement, inklusive tal, strängar, objekt och till och med andra arrayer. Du kan skapa en flerdimensionell array genom att skapa en indexerad array och tilldela varje element i arrayen varsin indexerad array. En sådan array är flerdimensionell eftersom den kan användas för att representera data i en tabell.

Arrayer är glesa arrayer, vilket betyder att det kan finnas ett element på indexposition 0 och ett annat på indexposition 5, men inget på indexpositionerna mellan dessa element. I sådana fall är elementen på positionerna 1 till 4 odefinierade, vilket indikerar frånvaron av ett element, och inte nödvändigtvis närvaron av ett element med värdet undefined.

Arraytilldelning görs med referenser, inte med värden. När du tilldelar en arrayvariabel till en annan arrayvariabel, refererar båda till samma array:

 var oneArray:Array = new Array("a", "b", "c");
 var twoArray:Array = oneArray; // Both array variables refer to the same array.
 twoArray[0] = "z";             
 trace(oneArray);               // Output: z,b,c.

Använd inte klassen Array för att skapa associativa arrayer (kallas även för hash-tabeller) som är en typ av datastruktur som innehåller namngivna element i stället för numrerade element. Använd Object-klassen om du vill skapa associativa arrayer. Det går att skapa associativa arrayer med klassen Array i ActionScript, men det går inte att använda några av metoderna eller egenskaperna i klassen Array med associativa arrayer.

Du kan utöka klassen Array och åsidosätta eller lägga till metoder. Du måste dock ange underklassen som dynamic, annars går det inte att spara data i en array.

Visa exemplen

Relaterade API-element

[] (arrayåtkomst)
Klassen Object

Publika egenskaper

Dölj ärvda publika egenskaper

Visa ärvda publika egenskaper

	Egenskap		Definieras med
		constructor : Object En referens till klassobjektet eller konstruktorfunktionen för en given objektinstans.	Object
		length : uint Ett positivt heltal som anger hur många element det finns i arrayen.	Array

Publika metoder

Dölj ärvda publika metoder

Visa ärvda publika metoder

	Metod		Definieras med
		Array(... values) Gör att du kan skapa en array som innehåller de angivna elementen.	Array
		Array(numElements:int = 0) Gör att du kan skapa en array med det angivna antalet element.	Array
		concat(... args):Array Sammanfogar elementen som anges i parametrarna med elementen i en array och skapar en ny array.	Array
		every(callback:Function, thisObject:* = null):Boolean Kör en testfunktion för varje objekt i arrayen tills ett objekt som returnerar false för den angivna funktionen påträffas.	Array
		filter(callback:Function, thisObject:* = null):Array Kör en testfunktion för varje objekt i arrayen och skapar en ny array för alla objekt som returnerar true för den angivna funktionen.	Array
		forEach(callback:Function, thisObject:* = null):void Kör en funktion för varje objekt i arrayen.	Array
		hasOwnProperty(name:String):Boolean Anger om det finns en egenskap angiven för ett objekt.	Object
		indexOf(searchElement:*, fromIndex:int = 0):int Söker efter ett objekt i en array med strikt likhet (===) och returnerar indexpositionen för det objektet.	Array
		insertAt(index:int, element:*):void Infoga ett enskilt element i en array.	Array
		isPrototypeOf(theClass:Object):Boolean Anger om en instans av klassen Object finns i prototypkedjan för objektet som anges som parameter.	Object
		join(sep:*):String Konverterar elementen i en array till strängar, infogar den angivna avgränsaren mellan elementen, sammanfogar dem och returnerar resultatsträngen.	Array
		lastIndexOf(searchElement:*, fromIndex:int = 0x7fffffff):int Söker efter ett objekt i en array bakifrån från det sista objektet, och returnerar indexpositionen för det matchande objektet med strikt likhet (===).	Array
		map(callback:Function, thisObject:* = null):Array Kör en funktion på varje objekt i en array och skapar en ny array med objekt som motsvarar resultatet av funktionen på varje objekt i den ursprungliga arrayen.	Array
		pop():* Tar bort det sista elementet från en array och returnerar elementets värde.	Array
		propertyIsEnumerable(name:String):Boolean Anger om den angivna egenskapen finns och är uppräkningsbar.	Object
		push(... args):uint Lägger till ett eller flera element i slutet av en array och returnerar arrayens nya längd.	Array
		removeAt(index:int):* Ta bort ett enskilt element från en array.	Array
		reverse():Array Vänder arrayen på plats.	Array
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Anger tillgänglighet för en dynamisk egenskap för slingåtgärder.	Object
		shift():* Tar bort det första elementet från en array och returnerar det elementet.	Array
		slice(startIndex:int = 0, endIndex:int = 16777215):Array Returnerar en ny array som består av ett intervall med element från originalarrayen, utan att originalarrayen modifieras.	Array
		some(callback:Function, thisObject:* = null):Boolean Kör en testfunktion för varje objekt i arrayen tills ett objekt som returnerar true påträffas.	Array
		sort(... args):Array Sorterar elementen i en array.	Array
		sortOn(fieldName:Object, options:Object = null):Array Sorterar elementen i en array efter ett eller flera fält i arrayen.	Array
		splice(startIndex:int, deleteCount:uint, ... values):Array Lägger till element i och tar bort element från en array.	Array
		toLocaleString():String Returnerar en sträng som representerar elementen i den angivna arrayen.	Array
		toString():String Returnerar en sträng som representerar elementen i den angivna arrayen.	Array
		unshift(... args):uint Lägger till ett eller flera element i början av en array och returnerar arrayens nya längd.	Array
		valueOf():Object Returnerar det angivna objektets primitiva värde.	Object

Publika konstanter

	Konstant		Definieras med
		CASEINSENSITIVE : uint = 1 [statisk] Anger skiftlägeskänslig sortering för sorteringsmetoderna i klassen Array.	Array
		DESCENDING : uint = 2 [statisk] Anger fallande sortering för sorteringsmetoderna i klassen Array.	Array
		NUMERIC : uint = 16 [statisk] Anger numerisk sortering (i stället för teckensträngssortering) för sorteringsmetoderna i klassen Array.	Array
		RETURNINDEXEDARRAY : uint = 8 [statisk] Anger att en sortering returnerar en array som består av arrayindexvärden.	Array
		UNIQUESORT : uint = 4 [statisk] Anger det unika sorteringskravet för sorteringsmetoderna i klassen Array.	Array

Egenskapsdetaljer

length

egenskap

length:uint

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Ett positivt heltal som anger hur många element det finns i arrayen. Den här egenskapen uppdateras automatiskt när nya element läggs till i arrayen. Om du tilldelar ett värde till ett array-element (t.ex. my_array[index] = value), och om index är ett tal och index+1 är större än the length-egenskapen uppdateras length-egenskapen till index+1.

Obs: Om du tilldelar ett värde som är kortare än den befintliga längden till egenskapen length trunkeras arrayen.

Implementering
public function get length():uint
public function set length(value:uint):void

Exempel ( Så här använder du exemplet )

I följande kod skapas ett Array-objekt, names, med strängelementet Bill. Därefter använder du metoden push() för att lägga till ett annat strängelement Kyle. Arraylängden som bestäms av egenskapen length var ett element innan push() användes och är två element efter push() anropades. En annan sträng, Jeff, läggs till för att längden på names ska bli tre element. Därefter anropas metoden shift() två gånger, vilket tar bort Bill och Kyle, så att den slutliga arrayen får length lika med ett.


var names:Array = new Array("Bill");
names.push("Kyle");
trace(names.length); // 2

names.push("Jeff");
trace(names.length); // 3

names.shift();
names.shift();
trace(names.length); // 1

Konstruktordetaljer

()

Konstruktor

public function Array(... values)

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Gör att du kan skapa en array som innehåller de angivna elementen. Du kan ange värden av valfri typ. Det första elementet i en array har indexvärdet (eller positionen) 0.

Obs! Klassen visar två konstruktorer, eftersom konstruktorn accepterar olika typer av argument. Konstruktorn uppför sig på olika sätt beroende på vilken typ av och antal argument som skickas enligt detaljerna för varje post. ActionScript 3.0 tillåter inte metod- eller konstruktoröverinläsning.

Parametrar

... values — En kommaavgränsad lista med en eller två godtyckliga värden.

Obs: Om bara en enda numerisk parameter skickas till Array-konstruktorn antas den ange arrayegenskapen length.

Utlöser

RangeError — Argumentet är tal som inte är ett heltal och som är större än eller lika med 0.

Relaterade API-element

[] arrayåtkomst
Array.length

Exempel ( Så här använder du exemplet )

I följande exempel skapas ett nytt Array-objekt med den ursprungliga längden 3. Arrayen fylls med strängelementen one, two och three och därefter konverteras elementen till en sträng.

package {
    import flash.display.Sprite;

    public class Array_Array_3 extends Sprite {

        public function Array_Array_3() {
            var myArr:Array = new Array("one", "two", "three");
            trace(myArr.length); // 3
            trace(myArr);          // one,two,three
        }
    }
}

Array

()

Konstruktor

public function Array(numElements:int = 0)

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Gör att du kan skapa en array med det angivna antalet element. Om du inte anger några parametrar skapas en array med 0 element. Om du anger ett antal element skapas en array med numElements stycken element.

Obs! Klassen visar två konstruktormetoder, eftersom konstruktorn accepterar olika typer av argument. Konstruktorn uppför sig på olika sätt beroende på vilken typ av och antal argument som skickas enligt detaljerna för varje post. ActionScript 3.0 tillåter inte metod- eller konstruktoröverinläsning.

Parametrar

numElements:int (default = 0) — Ett heltal som anger hur många element det finns i arrayen.

Utlöser

RangeError — Argumentet är tal som inte är ett heltal och som är större än eller lika med 0.

Relaterade API-element

[] arrayåtkomst
Array.length

Exempel ( Så här använder du exemplet )

I följande exempel skapas Array-objektet myArr utan argument och med den ursprungliga längden 0:

package {
    import flash.display.Sprite;

    public class Array_Array extends Sprite {

        public function Array_Array() {
            var myArr:Array = new Array();
            trace(myArr.length); // 0
        }
    }
}

I följande exempel skapas ett Array-objekt med 5 ursprungliga element, med längden 5. De första elementen fylls med strängen "one" och strängelementet "six" läggs till i slutet av arrayen med metoden push():

package {
    import flash.display.Sprite;

    public class Array_Array_2 extends Sprite {

        public function Array_Array_2() {
            var myArr:Array = new Array(5);
            trace(myArr.length); // 5
            myArr[0] = "one";
            myArr.push("six");
            trace(myArr);         // one,,,,,six
            trace(myArr.length); // 6
        }
    }
}

Metoddetaljer

concat

()

metod

AS3 function concat(... args):Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Sammanfogar elementen som anges i parametrarna med elementen i en array och skapar en ny array. Om parametrarna anger en array sammanfogas elementen i arrayen. Om inga parametrar skickas skapas en kopia (grund klon) av den ursprungliga arrayen.

Parametrar

... args — Ett värde av valfri datatyp (till exempel tal, element eller strängar) som ska sammanfogas i en ny array.

Returnerar

Array — En array som innehåller elementen från arrayen följt av elementen från parametrarna.

Exempel ( Så här använder du exemplet )

Följande kod skapar fyra Array-objekt:

Arrayen numbers som innehåller siffrorna 1, 2 och 3.
Arrayen letters som innehåller bokstäverna a, b och c.
Arrayen numbersAndLetters som anropar metoden concat() som skapar arrayen [1,2,3,a,b,c].
Arrayen lettersAndNumbers som anropar metoden concat() som skapar arrayen [a,b,c,1,2,3].


var numbers:Array = new Array(1, 2, 3);
var letters:Array = new Array("a", "b", "c");
var numbersAndLetters:Array = numbers.concat(letters);
var lettersAndNumbers:Array = letters.concat(numbers);

trace(numbers);       // 1,2,3
trace(letters);       // a,b,c
trace(numbersAndLetters); // 1,2,3,a,b,c
trace(lettersAndNumbers); // a,b,c,1,2,3

every

()

metod

AS3 function every(callback:Function, thisObject:* = null):Boolean

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Kör en testfunktion för varje objekt i arrayen tills ett objekt som returnerar false för den angivna funktionen påträffas. Du kan använda denna metod om du vill avgöra om alla objekt i en array uppfyller vissa kriterier, till exempel att värdena är mindre än ett visst tal.

I den här metoden måste den andra parametern, thisObject, vara null om den första parametern, callback, är ett metodslut. Anta att du skapar en funktion i ett filmklipp med namnet me:

     function myFunction(obj:Object):void {
        //your code here
     }

Anta sedan att du använder metoden every() på en array med namnet myArray:

     myArray.every(myFunction, me);

Eftersom myFunction är en medlem av klassen Timeline, som inte kan åsidosättas av me, genereras ett undantag i Flash-miljön. Du kan undvika det här körtidsfelet genom att tilldela funktionen till en variabel enligt följande:

     var myFunction:Function = function(obj:Object):void {
         //your code here
     };
     myArray.every(myFunction, me);

Parametrar

	`callback:Function` — Funktionen som ska köras på varje objekt i arrayen. Funktionen kan innehålla en enkel jämförelse (till exempel `item < 20`) eller en mer komplex åtgärd. Funktionen anropas med tre argument; objektets värde och indexposition samt Array-objektet: function callback(item:*, index:int, array:Array):Boolean;

	`thisObject:*` (default = `null`) — Ett objekt som ska användas som `this` i funktionen.

Returnerar

Boolean — Det booleska värdet true om alla objekt i arrayen returnerar true för den angivna funktionen; annars false.

Relaterade API-element

Array.some()

Exempel ( Så här använder du exemplet )

I följande exempel testas två arrayer för att avgöra om alla objekt i de två arrayerna är tal. Dessutom returneras resultaten av testet som visar att isNumeric är true för den första arrayen och false för den andra:

package {
    import flash.display.Sprite;
    public class Array_every extends Sprite {
        public function Array_every() {
            var arr1:Array = new Array(1, 2, 4);
            var res1:Boolean = arr1.every(isNumeric);
            trace("isNumeric:", res1); // true
 
            var arr2:Array = new Array(1, 2, "ham");
            var res2:Boolean = arr2.every(isNumeric);
            trace("isNumeric:", res2); // false
        }
        private function isNumeric(element:*, index:int, arr:Array):Boolean {
            return (element is Number);
        }
    }
}

filter

()

metod

AS3 function filter(callback:Function, thisObject:* = null):Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Kör en testfunktion för varje objekt i arrayen och skapar en ny array för alla objekt som returnerar true för den angivna funktionen. Om ett objekt returnerar false tas det inte med i den nya arrayen.

I den här metoden måste den andra parametern, thisObject, vara null om den första parametern, callback, är ett metodslut. Anta att du skapar en funktion i ett filmklipp med namnet me:

     function myFunction(obj:Object):void {
        //your code here
     }

Anta sedan att du använder metoden filter() på en array med namnet myArray:

 
     myArray.filter(myFunction, me);

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.filter(myFunction, me);

Parametrar

	`callback:Function` — Funktionen som ska köras på varje objekt i arrayen. Funktionen kan innehålla en enkel jämförelse (till exempel `item < 20`) eller en mer komplex åtgärd. Funktionen anropas med tre argument; objektets värde och indexposition samt Array-objektet: function callback(item:*, index:int, array:Array):Boolean;

	`thisObject:*` (default = `null`) — Ett objekt som ska användas som `this` i funktionen.

Returnerar

Array — En ny array som innehåller alla objekt från den ursprungliga arrayen som returnerade true.

Relaterade API-element

Array.map()

Exempel ( Så här använder du exemplet )

I följande exempel skapas en array med alla anställda som är chefer:

package {
    import flash.display.Sprite;
    public class Array_filter extends Sprite {
        public function Array_filter() {
            var employees:Array = new Array();
            employees.push({name:"Employee 1", manager:false});
            employees.push({name:"Employee 2", manager:true});
            employees.push({name:"Employee 3", manager:false});
            trace("Employees:");
            employees.forEach(traceEmployee);
            
            var managers:Array = employees.filter(isManager);
            trace("Managers:");
            managers.forEach(traceEmployee);
        }
        private function isManager(element:*, index:int, arr:Array):Boolean {
            return (element.manager == true);
        }
        private function traceEmployee(element:*, index:int, arr:Array):void {
            trace("\t" + element.name + ((element.manager) ? " (manager)" : ""));
        }
    }
}

forEach

()

metod

AS3 function forEach(callback:Function, thisObject:* = null):void

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Kör en funktion för varje objekt i arrayen.

I den här metoden måste den andra parametern, thisObject, vara null om den första parametern, callback, är ett metodslut. Anta att du skapar en funktion i ett filmklipp med namnet me:

     function myFunction(obj:Object):void {
        //your code here
     }

Anta sedan att du använder metoden forEach() på en array med namnet myArray:

     myArray.forEach(myFunction, me);

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.forEach(myFunction, me);

Parametrar

	`callback:Function` — Funktionen som ska köras på varje objekt i arrayen. Funktionen kan innehålla ett enkelt kommando (till exempel programsatsen `trace()`) eller en mer komplex åtgärd. Funktionen anropas med tre argument; objektets värde och indexposition samt Array-objektet: function callback(item:*, index:int, array:Array):void;

	`thisObject:*` (default = `null`) — Ett objekt som ska användas som `this` i funktionen.

Exempel ( Så här använder du exemplet )

I följande exempel körs programsatsen trace() i funktionen traceEmployee() på varje objekt i arrayen:

package {
    import flash.display.Sprite;
    public class Array_forEach extends Sprite {
        public function Array_forEach() {
            var employees:Array = new Array();
            employees.push({name:"Employee 1", manager:false});
            employees.push({name:"Employee 2", manager:true});
            employees.push({name:"Employee 3", manager:false});
            trace(employees);
            employees.forEach(traceEmployee);
        }
        private function traceEmployee(element:*, index:int, arr:Array):void {
            trace(element.name + " (" + element.manager + ")");
        }
    }
}

I följande exempel körs även programsatsen trace() i en något ändrad traceEmployee()-funktion på varje objekt i arrayen:

package {
    import flash.display.Sprite;
    public class Array_forEach_2 extends Sprite {
        public function Array_forEach_2() {
            var employeeXML:XML = <employees>
                    <employee name="Steven" manager="false" />
                    <employee name="Bruce" manager="true" />
                    <employee name="Rob" manager="false" />
                </employees>;
            var employeesList:XMLList = employeeXML.employee;
            var employeesArray:Array = new Array();
            for each (var tempXML:XML in employeesList) {
                employeesArray.push(tempXML);
            }
            employeesArray.sortOn("@name");
            employeesArray.forEach(traceEmployee);
        }
        private function traceEmployee(element:*, index:Number, arr:Array):void {
            trace(element.@name + ((element.@manager == "true") ? " (manager)" : ""));
        }
    }
}

indexOf

()

metod

AS3 function indexOf(searchElement:*, fromIndex:int = 0):int

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Söker efter ett objekt i en array med strikt likhet (===) och returnerar indexpositionen för det objektet.

Parametrar

	`searchElement:*` — Objektet som ska sökas efter i arrayen.

	`fromIndex:int` (default = `0`) — Positionen i arrayen där sökningen efter objektet ska påbörjas.

Returnerar

int — En nollbaserad indexposition för objektet i arrayen. Om argumentet searchElement inte hittas returneras -1.

Relaterade API-element

Array.lastIndexOf()
=== (strikt likhet)

Exempel ( Så här använder du exemplet )

I följande exempel visas positionen i den angivna arrayen:

package {
    import flash.display.Sprite;
    public class Array_indexOf extends Sprite {
        public function Array_indexOf() {
            var arr:Array = new Array(123,45,6789);
            arr.push("123-45-6789");
            arr.push("987-65-4321");
            
            var index:int = arr.indexOf("123");
            trace(index); // -1
            
            var index2:int = arr.indexOf(123);
            trace(index2); // 0
        }
    }
}

insertAt

()

metod

AS3 function insertAt(index:int, element:*):void

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

Flash Player 19, AIR 19

Infoga ett enskilt element i en array. Den här metoden ändrar arrayen utan att skapa en kopia.

Parametrar

	`index:int` — Ett heltal som anger positionen i den array där elementet ska infogas. Du kan använda ett negativt heltal för att ange en position i förhållande till arrayens slut (till exempel är -1 arrayens sista element).

	`element:*`

join

()

metod

AS3 function join(sep:*):String

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Konverterar elementen i en array till strängar, infogar den angivna avgränsaren mellan elementen, sammanfogar dem och returnerar resultatsträngen. En inkapslad array avgränsas alltid av ett komma (,), inte av den avgränsare som skickas till metoden join().

Parametrar

sep:* (default = NaN) — Ett tecken eller en sträng som avgränsar arrayelement i den returnerade strängen. Om du inte anger parametern används ett komma som standardavgränsare.

Returnerar

String — En sträng som består av element från en array som konverterats till strängar och som avgränsas av den angivna parametern.

Relaterade API-element

String.split()

Exempel ( Så här använder du exemplet )

Följande kod skapar ett Array-objekt, myArr, med elementen one, two och three och därefter en sträng som innehåller one and two and three med metoden join().


var myArr:Array = new Array("one", "two", "three");
var myStr:String = myArr.join(" and ");
trace(myArr); // one,two,three
trace(myStr); // one and two and three

Följande kod skapar ett Array-objekt, specialChars, med elementen (, ), - och ett blanksteg och skapar därefter en sträng som innehåller (888) 867-5309. Därefter används en for-slinga där varje typ av specialtecken som finns i specialChars tas bort för att skapa en sträng (myStr) som endast innehåller siffrorna i telefonnumret: 888675309. Observera att andra tecken, till exempel +, kan läggas till i specialChars och då fungerar detta även för internationella telefonnummerformat.


var phoneString:String = "(888) 867-5309";

var specialChars:Array = new Array("(", ")", "-", " ");
var myStr:String = phoneString;

var ln:uint = specialChars.length;
for(var i:uint; i < ln; i++) {
    myStr = myStr.split(specialChars[i]).join("");
}

var phoneNumber:Number = new Number(myStr);

trace(phoneString); // (888) 867-5309
trace(phoneNumber); // 8888675309

lastIndexOf

()

metod

AS3 function lastIndexOf(searchElement:*, fromIndex:int = 0x7fffffff):int

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Söker efter ett objekt i en array bakifrån från det sista objektet och returnerar indexpositionen för det matchande objektet med strikt likhet (===).

Parametrar

	`searchElement:*` — Objektet som ska sökas efter i arrayen.

	`fromIndex:int` (default = `0x7fffffff`) — Positionen i arrayen där sökningen efter objektet ska påbörjas. Standardvärdet är maximalt tillåtet värde för ett index. Om du inte anger `fromIndex` påbörjas sökningen vid det sista objektet i arrayen.

Returnerar

int — En nollbaserad indexposition för objektet i arrayen. Om argumentet searchElement inte hittas returneras -1.

Relaterade API-element

Array.indexOf()
=== (strikt likhet)

Exempel ( Så här använder du exemplet )

I följande exempel visas positionen i den angivna arrayen:

package {
    import flash.display.Sprite;
    public class Array_lastIndexOf extends Sprite {
        public function Array_lastIndexOf() {
            var arr:Array = new Array(123,45,6789,123,984,323,123,32);
            
            var index:int = arr.indexOf(123);
            trace(index); // 0
            
            var index2:int = arr.lastIndexOf(123);
            trace(index2); // 6
        }
    }
}

map

()

metod

AS3 function map(callback:Function, thisObject:* = null):Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Kör en funktion på varje objekt i en array och skapar en ny array med objekt som motsvarar resultatet av funktionen på varje objekt i den ursprungliga arrayen.

I den här metoden måste den andra parametern, thisObject, vara null om den första parametern, callback, är ett metodslut. Anta att du skapar en funktion i ett filmklipp med namnet me:

     function myFunction(obj:Object):void {
        //your code here
     }

Anta sedan att du använder metoden map() på en array med namnet myArray:

     myArray.map(myFunction, me);

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.map(myFunction, me);

Parametrar

	`callback:Function` — Funktionen som ska köras på varje objekt i arrayen. Funktionen kan innehålla ett enkelt kommando (till exempel ändra skiftläget på en array med strängar) eller en mer komplex åtgärd. Funktionen anropas med tre argument; objektets värde och indexposition samt Array-objektet: function callback(item:*, index:int, array:Array):String;

	`thisObject:*` (default = `null`) — Ett objekt som ska användas som `this` i funktionen.

Returnerar

Array — En ny array som innehåller resultatet av funktionen på varje objekt i den ursprungliga arrayen.

Relaterade API-element

Array.filter()

Exempel ( Så här använder du exemplet )

I följande exempel ändras alla objekt i arrayen till versaler:

package {
    import flash.display.Sprite;
    public class Array_map extends Sprite {
        public function Array_map() {
            var arr:Array = new Array("one", "two", "Three");
            trace(arr); // one,two,Three

            var upperArr:Array = arr.map(toUpper);
            trace(upperArr); // ONE,TWO,THREE
        }
        private function toUpper(element:*, index:int, arr:Array):String {
            return String(element).toUpperCase();
        }
    }
}

pop

()

metod

AS3 function pop():*

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Tar bort det sista elementet från en array och returnerar elementets värde.

Returnerar

* — Värdet för det sista elementet (valfri datatyp) i den angivna arrayen.

Relaterade API-element

Array.push()
Array.shift()
Array.unshift()

Exempel ( Så här använder du exemplet )

I följande kod skapas ett Array-objekt, letters, med elementen a, b och c. Det sista elementet (c) tas bort från arrayen med metoden pop() och tilldelas till String-objektet letter.


var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
var letter:String = letters.pop();
trace(letters); // a,b
trace(letter);     // c

push

()

metod

AS3 function push(... args):uint

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Lägger till ett eller flera element i slutet av en array och returnerar arrayens nya längd.

Parametrar

... args — Ett eller fler värden som bifogas arrayen.

Returnerar

uint — Ett heltal som representerar den nya arrayens längd.

Relaterade API-element

Array.pop()
Array.shift()
Array.unshift()

Exempel ( Så här använder du exemplet )

I följande kod skapas ett tomt Array-objekt, letters, och därefter fylls arrayen på med elementen a, b och c med metoden push().


var letters:Array = new Array();

letters.push("a");
letters.push("b");
letters.push("c");

trace(letters.toString()); // a,b,c

I följande kod skapas ett Array-objekt, letters, som från början fylls på med elementet a. Därefter använder du metoden push() en gång för att lägga till elementen b och c i slutet av arrayen, som består av tre element efter användningen av push.


var letters:Array = new Array("a");
var count:uint = letters.push("b", "c");

trace(letters); // a,b,c
trace(count);   // 3

removeAt

()

metod

AS3 function removeAt(index:int):*

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

Flash Player 19, AIR 19

Ta bort ett enskilt element från en array. Den här metoden ändrar arrayen utan att skapa en kopia.

Parametrar

index:int — Ett heltal som anger indexvärdet för elementet i arrayen som ska tas bort. Du kan använda ett negativt heltal för att ange en position i förhållande till arrayens slut (till exempel är -1 arrayens sista element).

Returnerar

* — Det element som togs bort från originalarrayen.

reverse

()

metod

AS3 function reverse():Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Vänder arrayen på plats.

Returnerar

Array — Den nya arrayen.

Exempel ( Så här använder du exemplet )

I följande kod skapas ett Array-objekt, letters, med elementen a, b och c. Ordningen av arrayelementen kastas därefter om med metoden reverse() som skapar arrayen [c,b,a].


var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
letters.reverse();
trace(letters); // c,b,a

shift

()

metod

AS3 function shift():*

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Tar bort det första elementet från en array och returnerar det elementet. De resterande arrayelementen flyttas från sin ursprungliga position, i, till i-1.

Returnerar

* — Det första elementet (valfri datatyp) i en array.

Relaterade API-element

Array.pop()
Array.push()
Array.unshift()

Exempel ( Så här använder du exemplet )

I följande kod skapas Array-objektet letters, med elementen a, b och c. Därefter använder du metoden shift() för att ta bort det första elementet (a) från letters och tilldela det till strängen firstLetter.


var letters:Array = new Array("a", "b", "c");
var firstLetter:String = letters.shift();
trace(letters);     // b,c
trace(firstLetter); // a

slice

()

metod

AS3 function slice(startIndex:int = 0, endIndex:int = 16777215):Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Returnerar en ny array som består av ett intervall med element från originalarrayen, utan att originalarrayen modifieras. Den returnerade arrayen inkluderar elementet startIndex och alla element fram till, men inte inklusive, elementet endIndex.

Om inga parametrar skickas skapas en kopia (grund klon) av den ursprungliga arrayen.

Parametrar

	`startIndex:int` (default = `0`) — Ett tal som anger indexvärdet på referenspunkten för segmentet. Om `startIndex` är ett negativt tal, börjar referenspunkten i slutet av arrayen där -1 är det sista elementet.

	`endIndex:int` (default = `16777215`) — Ett tal som anger indexvärdet på slutpunkten för segmentet. Om du utelämnar den här parametern omfattar segmentet alla element från referenspunkten till arrayens slut. Om `endIndex` är ett negativt tal, specificeras slutpunkten från slutet av arrayen där -1 är det sista elementet.

Returnerar

Array — En array som består av ett intervall med element från originalarrayen.

Exempel ( Så här använder du exemplet )

I följande kod skapas ett Array-objekt, letters, med elementen [a,b,c,d,e,f]. Därefter skapas arrayen someLetters genom ett anrop till metoden slice() på elementen ett (b) till tre (d). Resultatet blir en array med elementen b och c.


var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(1,3);

trace(letters);     // a,b,c,d,e,f
trace(someLetters); // b,c

Följande kod skapar ett Array-objekt letters med elementen [a,b,c,d,e,f]. Därefter skapas arrayen someLetters genom ett anrop till metoden slice() på elementen två (c). Resultatet blir en array med elementen [c,d,e,f].


var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(2);

trace(letters);     // a,b,c,d,e,f
trace(someLetters); // c,d,e,f

I följande kod skapas ett Array-objekt, letters, med elementen [a,b,c,d,e,f]. Därefter skapas arrayen someLetters genom ett anrop till metoden slice() på det näst sista elementet från slutet (e). Resultatet blir en array med elementen e och f.


var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(-2);

trace(letters);     // a,b,c,d,e,f
trace(someLetters); // e,f

some

()

metod

AS3 function some(callback:Function, thisObject:* = null):Boolean

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Kör en testfunktion för varje objekt i arrayen tills ett objekt som returnerar true påträffas. Använd denna metod om du vill avgöra om något objekt i en array uppfyller vissa kriterier, till exempel ett värde som är mindre än ett visst tal.

I den här metoden måste den andra parametern, thisObject, vara null om den första parametern, callback, är ett metodslut. Anta att du skapar en funktion i ett filmklipp med namnet me:

     function myFunction(obj:Object):void {
        //your code here
     }

Anta sedan att du använder metoden some() på en array med namnet myArray:

     myArray.some(myFunction, me);

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.some(myFunction, me);

Parametrar

	`callback:Function` — Funktionen som ska köras på varje objekt i arrayen. Funktionen kan innehålla en enkel jämförelse (till exempel `item < 20`) eller en mer komplex åtgärd. Funktionen anropas med tre argument; objektets värde och indexposition samt Array-objektet: function callback(item:*, index:int, array:Array):Boolean;

	`thisObject:*` (default = `null`) — Ett objekt som ska användas som `this` i funktionen.

Returnerar

Boolean — Det booleska värdet true om något objekt i arrayen returnerar true för den angivna funktionen; annars false.

Relaterade API-element

every()

Exempel ( Så här använder du exemplet )

I följande exempel visas vilka värden som är odefinierade:

package {
    import flash.display.Sprite;
    public class Array_some extends Sprite {
        public function Array_some() {
            var arr:Array = new Array();
            arr[0] = "one";
            arr[1] = "two";
            arr[3] = "four";
            var isUndef:Boolean = arr.some(isUndefined);
            if (isUndef) {
                trace("array contains undefined values: " + arr);
            } else {
                trace("array contains no undefined values.");
            }
        }
        private function isUndefined(element:*, index:int, arr:Array):Boolean {
            return (element == undefined);
        }
    }
}

sort

()

metod

AS3 function sort(... args):Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Sorterar elementen i en array. Metoden sorteras efter Unicode-värden. (ASCII är en del av Unicode.)

Som standard, Array.sort() fungerar på följande sätt:

Sortering är skiftlägeskänslig (Z kommer före a).
Sortering är stigande (a kommer före b).
Arrayen ändras så att den återger sorteringsordningen. Flera element med samma sorteringsfält placeras efter varandra utan inbördes ordning i den sorterade arrayen.
Alla fält, oavsett datatyp, sorteras som om de vore strängar. 100 kommer före 99 eftersom "1" är ett lägre strängvärde än "9".

Om du vill sortera en array med andra inställningar än standardinställningarna kan du antingen använda ett av sorteringsalternativen som beskrivs under sortOptions för parametern ...args eller skapa egna anpassade funktioner som gör sorteringen. Om du skapar en anpassad funktion kan du anropa metoden sort() och använda namnet på den anpassade funktionen som första argument (compareFunction).

Parametrar

... args — Argumenten som anger en jämförelsefunktion och ett eller flera värden som bestämmer beteendet för sorteringen.

Metoden använder syntaxen och argumentordningen Array.sort(compareFunction, sortOptions) med argumenten definierade enligt följande:

compareFunction – En jämförelsefunktion som anger sorteringsordningen för element i en array. Det här argumentet är valfritt. En jämförelsefunktion ska ta två argument som ska jämföras. Givet elementen A och B, kan resultatet av compareFunction vara av negativt-, 0- eller positivt värde.
- Ett negativt returvärde anger att A visas före B i den sorterade sekvensen.
- Ett returvärde som är 0 anger att A och B har samma sorteringsordning.
- Ett positivt returvärde anger att A visas efter B i den sorterade sekvensen.
sortOptions – Ett eller flera värden eller definierade konstanter, avgränsade med operatorn | (OR i bitform) som ändrar sorteringens beteende från grundinställningen. Det här argumentet är valfritt. Följande värden är acceptabla för sortOptions:
- 1 eller Array.CASEINSENSITIVE
- 2 eller Array.DESCENDING
- 4 eller Array.UNIQUESORT
- 8 eller Array.RETURNINDEXEDARRAY
- 16 eller Array.NUMERIC
Mer information finns under metoden Array.sortOn().

Returnerar

Array — Det returnerade värdet beror på om du skickar några argument, enligt följande lista:

Om du anger värdet 4 eller Array.UNIQUESORT för argumentet sortOptions i parametern ...args och två eller fler element som sorteras har identiska sorteringsfält, returnerar Flash värdet 0 och arrayen ändras inte.
Om du anger värdet 8 eller Array.RETURNINDEXEDARRAY för argumentet sortOptions i parametern ...args returnerar Flash en sorterad numerisk array med indexvärde som återger resultatet av sorteringen. Arrayen ändras inte.
I annat fall returnerar Flash ingenting och arrayen ändras för att återge sorteringsordningen.

Relaterade API-element

| (OR i bitform)
Array.sortOn()

Exempel ( Så här använder du exemplet )

I följande kod skapas ett Array-objekt, vegetables, med elementen [spinach, green pepper, cilantro, onion, avocado]. Arrayen sorteras därefter av metoden sort() som anropas utan parametrar. Resultatet är vegetables som är sorterat i alfabetisk ordning ([avocado, cilantro, green pepper, onion, spinach]).


var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "cilantro",
                 "onion",
                 "avocado");

trace(vegetables); // spinach,green pepper,cilantro,onion,avocado
vegetables.sort();
trace(vegetables); // avocado,cilantro,green pepper,onion,spinach

I följande kod skapas ett Array-objekt, vegetables, med elementen [spinach, green pepper, Cilantro, Onion, and Avocado]. Arrayen sorteras därefter av metoden sort() som anropas utan parametrar första gången. Resultatet är [Avocado,Cilantro,Onion,green pepper,spinach]. Därefter anropas sort() på vegetables igen med konstanten CASEINSENSITIVE som en parameter. Resultatet är vegetables som är sorterad i alfabetisk ordning ([Avocado, Cilantro, green pepper, Onion, spinach]).


var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "Cilantro",
                 "Onion",
                 "Avocado");

vegetables.sort();
trace(vegetables); // Avocado,Cilantro,Onion,green pepper,spinach
vegetables.sort(Array.CASEINSENSITIVE);
trace(vegetables); // Avocado,Cilantro,green pepper,Onion,spinach

I följande kod skapas det tomma Array-objektet vegetables, som fylls med fem anrop till push(). Varje gång push() anropas skapas ett nytt Vegetable-objekt genom ett anrop till konstruktorn Vegetable() som tar ett String- (name) och Number-objekt (price). Genom att anropa push() fem gånger med följande värden skapas följande array: [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. Därefter använder du metoden sort() för att sortera arrayen, vilket ger arrayen [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44].

var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));

trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44

vegetables.sort();

trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44

//The following code defines the Vegetable class
class Vegetable {
    private var name:String;
    private var price:Number;

    public function Vegetable(name:String, price:Number) {
        this.name = name;
        this.price = price;
    }

    public function toString():String {
        return " " + name + ":" + price;
    }
}

Följande exempel är precis likadant som det föregående, förutom att metoden sort() används med en anpassad sorteringsfunktion (sortOnPrice) som sorterar efter pris i stället för i bokstavsordning. Observera att den nya funktionen getPrice() extraherar priset.


var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));

trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44

vegetables.sort(sortOnPrice);

trace(vegetables);
// celery:1.29, squash:1.44, lettuce:1.49, spinach:1.89, asparagus:3.99

function sortOnPrice(a:Vegetable, b:Vegetable):Number {
    var aPrice:Number = a.getPrice();
    var bPrice:Number = b.getPrice();

    if(aPrice > bPrice) {
        return 1;
    } else if(aPrice < bPrice) {
        return -1;
    } else  {
        //aPrice == bPrice
        return 0;
    }
}

// The following code defines the Vegetable class and should be in a separate package.
class Vegetable {
    private var name:String;
    private var price:Number;

    public function Vegetable(name:String, price:Number) {
        this.name = name;
        this.price = price;
    }

    public function getPrice():Number {
        return price;
    }

    public function toString():String {
        return " " + name + ":" + price;
    }
}

I följande kod skapas Array-objektet numbers med elementen [3,5,100,34,10]. Ett anrop till sort() utan parametrar sorterar arrayen i bokstavsordning och returnerar det oönskade resultatet [10,100,3,34,5]. Om du vill sortera tal på rätt sätt måste du skicka med konstanten NUMERIC till metoden sort() som sorterar number enligt följande: [3,5,10,34,100].

Obs: Standardbeteende hos funktionen sort() är att hantera varje objekt som en sträng. Om du använder argumentet Array.NUMERIC försöker Flash-miljön konvertera icke-numeriska värden till heltal för sorteringsändamål. Ett fel inträffar om det inte går. Miljön kan t.ex. konvertera strängvärdet "6" till ett heltal, men ett fel inträffar om strängvärdet är "six".


var numbers:Array = new Array(3,5,100,34,10);

trace(numbers); // 3,5,100,34,10
numbers.sort();
trace(numbers); // 10,100,3,34,5
numbers.sort(Array.NUMERIC);
trace(numbers); // 3,5,10,34,100

sortOn

()

metod

AS3 function sortOn(fieldName:Object, options:Object = null):Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Sorterar elementen i en array efter ett eller flera fält i arrayen. Arrayen ska ha följande egenskaper:

Arrayen är en indexerad array, inte en associativ array.
Varje element i arrayen innehåller ett objekt med en eller flera egenskaper.
Alla objekt har minst en gemensam egenskap. Värdena för denna egenskap kan användas för att sortera arrayen. En sådan egenskap kallas fält.

Om du anger flera fieldName-parametrar är det första fältet det primära sorteringsfältet, det andra är nästa sorteringsfält och så vidare. I Flash sker sortering efter Unicode-värden. (ASCII är en del av Unicode.) Om något av elementen som jämförs inte innehåller det fält som anges i parametern fieldName, antas fältet vara inställt på undefined och elementen placeras utan någon speciell ordning i den sorterade arrayen.

Som standard, Array.sortOn() fungerar på följande sätt:

Sortering är skiftlägeskänslig (Z kommer före a).
Sortering är stigande (a kommer före b).
Arrayen ändras så att den återger sorteringsordningen. Flera element med samma sorteringsfält placeras efter varandra utan inbördes ordning i den sorterade arrayen.
Numeriska fält sorteras som om de vore strängar. 100 kommer före 99 eftersom "1" är ett lägre strängvärde än "9".

Flash Player 7 lägger till parametern options, som du kan använda för att åsidosätta standardsorteringen. Om du vill sortera en enkel array (till exempel en array som bara har ett fält) eller om du vill ange en sorteringsordning som parametern options inte stöder, använder du Array.sort().

Om du vill ange flera flaggor avgränsar du dem med operatorn bitvis OR (|):

     my_array.sortOn(someFieldName, Array.DESCENDING | Array.NUMERIC);

I Flash Player 8 fanns möjligheten att ange ett annat sorteringsalternativ för varje fält när du sorterade efter mer än ett fält. I Flash Player 8 och senare accepterar parametern options en array med sorteringsalternativ så att varje sorteringsalternativ motsvarar ett sorteringsfält i parametern fieldName. I följande exempel sorteras det primära sorteringsfältet, a, i fallande sortering, det sekundära sorteringsfältet, b, med numerisk sortering och det tredje sorteringsfältet, c, med skiftlägeskänslig sortering:

     Array.sortOn (["a", "b", "c"], [Array.DESCENDING, Array.NUMERIC, Array.CASEINSENSITIVE]);

Obs: Arrayerna fieldName och options måste ha samma antal element, annars ignoreras arrayen options. Alternativen Array.UNIQUESORT och Array.RETURNINDEXEDARRAY kan bara användas som första element i arrayen, annars ignoreras de.

Parametrar

fieldName:Object — En sträng som identifierar ett fält som ska användas som sorteringsvärde eller en array där det första elementet representerar det primära sorteringsfältet, det andra representerar det sekundära sorteringsfältet och så vidare.

options:Object (default = null) — Ett eller flera värden eller namn på definierade konstanter, avgränsade med operatorn bitviswise OR (|), som ändrar sorteringen. Följande värden är acceptabla för parametern options:

Array.CASEINSENSITIVE eller 1
Array.DESCENDING eller 2
Array.UNIQUESORT eller 4
Array.RETURNINDEXEDARRAY eller 8
Array.NUMERIC eller 16

Kodtips aktiveras om du använder flaggans strängform (till exempel DESCENDING) i stället för dess numeriska form (2).

Returnerar

Array — Vilket värde som returneras beror på om du skickar några parametrar:

Om du anger värdet 4 eller Array.UNIQUESORT för parametern options och två eller fler element som sorteras har identiska sorteringsfält, returneras värdet 0 och arrayen ändras inte.
Om du anger värdet 8 eller Array.RETURNINDEXEDARRAY för parametern options returneras en array som återger resultatet av sorteringen. Arrayen ändras inte.
I annat fall returneras ingenting och arrayen ändras för att återge sorteringsordningen.

Relaterade API-element

| (OR i bitform)
Array.sort()

Exempel ( Så här använder du exemplet )

I följande kod skapas ett tomt Array-objekt, vegetables, som fylls med fem anrop till push(). Varje gång push() anropas skapas ett nytt Vegetable-objekt genom ett anrop till konstruktorn Vegetable() som tar ett String- (name) och Number-objekt (price). Genom att anropa push() fem gånger med följande värden skapas följande array: [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. Därefter använder du metoden sortOn() med parametern name för att skapa följande array: [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44]. Metoden sortOn() anropas därefter på nytt med parametern price och konstanterna NUMERIC och DESCENDING, vilket skapar en array som är sorterad efter tal i fallande ordning: [asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29].


var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));

trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44

vegetables.sortOn("name");
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44

vegetables.sortOn("price", Array.NUMERIC | Array.DESCENDING);
trace(vegetables);
// asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29

class Vegetable {
    public var name:String;
    public var price:Number;

    public function Vegetable(name:String, price:Number) {
        this.name = name;
        this.price = price;
    }

    public function toString():String {
        return " " + name + ":" + price;
    }
}

I följande kod skapas ett tomt Array-objekt, records, som fylls med tre anrop till push(). Varje gång push() anropas läggs strängarna name och city och ett zip-nummer till i records. Tre for-slingor används för utskrift av arrayelementen. Den första for-slingan skriver ut elementen i den ordning de lades till. Den andra for-slingan körs efter records har sorterats efter name och därefter city med metoden sortOn(). Den tredje for-slingan skapar en annorlunda utskrift eftersomrecords sorteras om efter city och därefter name.



var records:Array = new Array();
records.push({name:"john", city:"omaha", zip:68144});
records.push({name:"john", city:"kansas city", zip:72345});
records.push({name:"bob", city:"omaha", zip:94010});

for(var i:uint = 0; i < records.length; i++) {
    trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, omaha
// john, kansas city
// bob, omaha

trace("records.sortOn('name', 'city');");
records.sortOn(["name", "city"]);
for(var i:uint = 0; i < records.length; i++) {
    trace(records[i].name + ", " + records[i].city);
}
// Results:
// bob, omaha
// john, kansas city
// john, omaha

trace("records.sortOn('city', 'name');");
records.sortOn(["city", "name"]);
for(var i:uint = 0; i < records.length; i++) {
    trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, kansas city
// bob, omaha
// john, omaha

I följande kod skapas ett tomt Array-objekt, users, som fylls med fyra anrop till push(). Varje gång push() anropas skapas ett User-objekt med konstruktorn User() där en String name samt en uint age läggs till i users. Den resulterande arrayuppsättningen är [Bob:3,barb:35,abcd:3,catchy:4].

Arrayen sorteras därefter på följande sätt:

Endast efter name som skapar arrayen [Bob:3,abcd:3,barb:35,catchy:4]
Efter name med konstanten CASEINSENSITIVE som skapar arrayen [abcd:3,barb:35,Bob:3,catchy:4]
Efter name med konstanterna CASEINSENSITIVE och DESCENDING som skapar arrayen [catchy:4,Bob:3,barb:35,abcd:3]
Endast efter age som skapar arrayen [abcd:3,Bob:3,barb:35,catchy:4]
Efter age med konstanten NUMERIC som skapar arrayen [Bob:3,abcd:3,catchy:4,barb:35]
Efter age med konstanterna DESCENDING och NUMERIC som skapar arrayen [barb:35,catchy:4,Bob:3,abcd:3]

En array med namnet indices skapas därefter med resultatet efter en sortering efter age med konstanterna NUMERIC och RETURNINDEXEDARRAY som skapar arrayen [Bob:3,abcd:3,catchy:4,barb:35], som sedan skrivs ut med en for-slinga.


class User {
    public var name:String;
    public var age:Number;
    public function User(name:String, age:uint) {
        this.name = name;
        this.age = age;
    }

    public function toString():String {
        return this.name + ":" + this.age;
    }
}

var users:Array = new Array();
users.push(new User("Bob", 3));
users.push(new User("barb", 35));
users.push(new User("abcd", 3));
users.push(new User("catchy", 4));

trace(users); // Bob:3,barb:35,abcd:3,catchy:4

users.sortOn("name");
trace(users); // Bob:3,abcd:3,barb:35,catchy:4

users.sortOn("name", Array.CASEINSENSITIVE);
trace(users); // abcd:3,barb:35,Bob:3,catchy:4

users.sortOn("name", Array.CASEINSENSITIVE | Array.DESCENDING);
trace(users); // catchy:4,Bob:3,barb:35,abcd:3

users.sortOn("age");
trace(users); // abcd:3,Bob:3,barb:35,catchy:4

users.sortOn("age", Array.NUMERIC);
trace(users); // Bob:3,abcd:3,catchy:4,barb:35

users.sortOn("age", Array.DESCENDING | Array.NUMERIC);
trace(users); // barb:35,catchy:4,Bob:3,abcd:3

var indices:Array = users.sortOn("age", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
var index:uint;
for(var i:uint = 0; i < indices.length; i++) {
    index = indices[i];
    trace(users[index].name, ": " + users[index].age);
}

// Results:
// Bob : 3
// abcd : 3
// catchy : 4
// barb : 35

splice

()

metod

AS3 function splice(startIndex:int, deleteCount:uint, ... values):Array

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Lägger till element i och tar bort element från en array. Den här metoden ändrar arrayen utan att skapa en kopia.

Obs: Om du vill åsidosätta den här metoden i en underklass till Array använder du ...args för parametrar enligt exemplet:

     public override function splice(...args) {
       // your statements here
     }

Parametrar

	`startIndex:int` — Ett heltal som anger indexvärdet för elementet i arrayen där inmatningen eller borttagningen börjar. Du kan använda ett negativt heltal för att ange en position i förhållande till arrayens slut (till exempel är -1 arrayens sista element).

	`deleteCount:uint` — Ett heltal som anger hur många element som ska tas bort. Antalet inkluderar det element som anges av parametern `startIndex`. Om du inte anger ett värde för parametern `deleteCount` tar metoden bort alla värden från elementet `startIndex` till det sista elementet i arrayen. Om värdet är 0 tas inga element bort.

	`... values` — En valfri lista med ett eller flera kommaavgränsade värden som ska infogas i en array vid den position som anges av parametern `startIndex`. Om det infogade värdet är av array-typ, bevaras arrayen oförändrad och infogas som ett element. Om du t.ex. skarvar en befintlig array med en längd på tre med en annan array med en längd på tre, kommer den nya arrayen bara att ha fyra element. Ett av dessa element är dock en array med en längd på tre.

Returnerar

Array — En array som innehåller de element som togs bort från originalarrayen.

Exempel ( Så här använder du exemplet )

I följande kod skapas ett Array-objekt, vegetables, med elementen [spinach, green pepper, cilantro, onion, avocado]. Metoden splice() anropas därefter med två parametrar 2 och 2, som tilldelar cilantro och onion till arrayen spliced. Arrayen vegetables innehåller därefter [spinach,green pepper,avocado]. Du anropar metoden splice() en andra gång med parametrarna 1, 0 och arrayen spliced för att tilldela [cilantro,onion] som det andra elementet i vegetables.


var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "cilantro",
                 "onion",
                 "avocado");

var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced);    // cilantro,onion

vegetables.splice(1, 0, spliced);
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado

Observera att cilantro och onion skrivs ut som om vegetables har 5 element även om det har fyra (och det andra elementet är en annan array som innehåller två element). Om du vill lägga till cilantro och onion var för sig använder du:

 
var vegetables:Array = new Array("spinach",
                 "green pepper",
                 "cilantro",
                 "onion",
                 "avocado");
 
 var spliced:Array = vegetables.splice(2, 2);
 trace(vegetables); // spinach,green pepper,avocado
 trace(spliced);    // cilantro,onion
 
 vegetables.splice(1, 0, "cilantro", "onion");
 trace(vegetables); // spinach,cilantro,onion,green pepper,avocado

toLocaleString

()

metod

public function toLocaleString():String

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Returnerar en sträng som representerar elementen i den angivna arrayen. Alla element i arrayen, från index 0 till det högsta indexvärdet, konverteras till en sammansatt sträng och avgränsas med komman. I ActionScript 3.0 returnerar den här metoden samma värde som metoden Array.toString().

Returnerar

String — En sträng med arrayelement.

Relaterade API-element

Array.toString()

toString

()

metod

public function toString():String

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Returnerar en sträng som representerar elementen i den angivna arrayen. Alla element i arrayen, från index 0 till det högsta indexvärdet, konverteras till en sammansatt sträng och avgränsas med komman. Om du vill använda en egen avgränsare använder du metoden Array.join().

Returnerar

String — En sträng med arrayelement.

Relaterade API-element

String.split()
Array.join()

Exempel ( Så här använder du exemplet )

Följande kod skapar en Array, konverterar värden till strängar och lagrar dem i variabeln vegnums med datatypen String.


var vegetables:Array = new Array();
vegetables.push(1);
vegetables.push(2);
vegetables.push(3);
vegetables.push(4);
vegetables.push(5);
var vegnums:String = vegetables.toString();
trace(vegnums+",6");
// 1,2,3,4,5,6

unshift

()

metod

AS3 function unshift(... args):uint

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Lägger till ett eller flera element i början av en array och returnerar arrayens nya längd. De andra arrayelementen flyttas från sin ursprungliga position, i, till i+1.

Parametrar

... args — Ett eller flera tal, element eller variabler som ska infogas i början av arrayen.

Returnerar

uint — Ett heltal som representerar arrayens nya längd.

Relaterade API-element

Array.pop()
Array.push()
Array.shift()

Exempel ( Så här använder du exemplet )

Följande kod skapar det tomma Array-objektet names. Strängarna Bill och Jeff läggs till med metoden push(). Därefter läggs strängarna Alfred och Kyle till i början av arrayen names med två anrop till metoden unshift().


var names:Array = new Array();
names.push("Bill");
names.push("Jeff");

trace(names); // Bill,Jeff

names.unshift("Alfred");
names.unshift("Kyle");

trace(names); // Kyle,Alfred,Bill,Jeff

Konstantdetaljer

CASEINSENSITIVE

Konstant

public static const CASEINSENSITIVE:uint = 1

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger skiftlägeskänslig sortering för sorteringsmetoderna i klassen Array. Du kan använda den här konstanten för parametern options i metoden sort() eller sortOn().

Värdet för konstanten är 1.

Relaterade API-element

Array.sort()
Array.sortOn()

DESCENDING

Konstant

public static const DESCENDING:uint = 2

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger fallande sortering för sorteringsmetoderna i klassen Array. Du kan använda den här konstanten för parametern options i metoden sort() eller sortOn().

Värdet för konstanten är 2.

Relaterade API-element

Array.sort()
Array.sortOn()

NUMERIC

Konstant

public static const NUMERIC:uint = 16

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger numerisk sortering (i stället för teckensträngssortering) för sorteringsmetoderna i klassen Array. Om du inkluderar konstanten i parametern options sorterar metoderna sort() och sortOn() tal som numeriska värden i stället för strängar med numeriska tecken. Utan konstanten NUMERIC behandlas varje arrayelement i sorteringen som en teckensträng och resultatet visas i Unicode-ordning.

Om du har en array med värdena [2005, 7, 35], och konstanten NUMERIC inte tas med i parametern options kommer den sorterade arrayen vara [2005, 35, 7] men om konstanten NUMERIC är med kommer den sorterade arrayen vara [7, 35, 2005].

Denna konstant används endast på tal i arrayen. Den används inte på strängar som innehåller numeriska data, till exempel ["23", "5"].

Värdet för konstanten är 16.

Relaterade API-element

Array.sort()
Array.sortOn()

RETURNINDEXEDARRAY

Konstant

public static const RETURNINDEXEDARRAY:uint = 8

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger att en sortering returnerar en array som består av arrayindexvärden. Du kan använda den här konstanten för parametern options i metoden sort() eller sortOn(), så att du får tillgång till flera vyer av arrayelementen samtidigt som den ursprungliga arrayen förblir oförändrad.

Värdet för konstanten är 8.

Relaterade API-element

Array.sort()
Array.sortOn()

UNIQUESORT

Konstant

public static const UNIQUESORT:uint = 4

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger det unika sorteringskravet för sorteringsmetoderna i klassen Array. Du kan använda den här konstanten för parametern options i metoden sort() eller sortOn(). Det unika sorteringsalternativet avbryter sorteringen om det finns två element eller fält med identiska värden.

Värdet för konstanten är 4.

Relaterade API-element

Array.sort()
Array.sortOn()

Exempel Så här använder du exemplet

ArrayExample.as

I följande exempel skapas ett nytt Array-objekt, myArr, utan argument och med den ursprungliga längden 0:

package {
    import flash.display.Sprite;

    public class ArrayExample extends Sprite {
        public function ArrayExample() {
            var myArr:Array = new Array();
            trace(myArr.length); // 0
        }
    }
}

Juridiska meddelanden | Onlinesekretesspolicy

Array - AS3

Klasser x

length

Array

Array

concat

every

filter

forEach

indexOf

insertAt

join

lastIndexOf

map

pop

push

removeAt

reverse

shift

slice

some

sort

sortOn

splice

toLocaleString

toString

unshift

CASEINSENSITIVE

DESCENDING

NUMERIC

RETURNINDEXEDARRAY

UNIQUESORT