Eine nicht negative Ganzzahl, die die Anzahl von Elementen im Array angibt. Diese Eigenschaft wird automatisch aktualisiert, wenn dem Array neue Elemente hinzugefügt werden. Sobald Sie einem Array-Element einen Wert zuweisen (z. B. my_array[index] = value) und wenn index eine Zahl und index+1 größer als die length-Eigenschaft ist, wird die length-Eigenschaft auf index+1 aktualisiert.

Hinweis: Wenn Sie der length-Eigenschaft einen Wert zuweisen, der kleiner ist als die tatsächliche Länge des Arrays, wird das Array abgeschnitten.

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

Ermöglicht das Erstellen eines Arrays mit der angegebenen Anzahl an Elementen. Wenn Sie keine Parameter angeben, wird ein Array erstellt, der 0 Elemente enthält. Wenn Sie eine bestimmte Anzahl an Elementen angeben, wird ein Array mit numElements Elementen erstellt.

Hinweis: Diese Klasse zeigt zwei Konstruktormethodeneinträge, da der Konstruktor Argumente verschiedenen Typs akzeptiert. Der Konstruktor verhält sich unterschiedlich, je nach Typ und Anzahl der übergebenen Argumente, wie sie in den einzelnen Einträgen beschrieben sind. Überladene Methoden oder Konstruktoren werden von ActionSript 3.0 nicht unterstützt.

Siehe auch

package {
    import flash.display.Sprite;

    public class Array_Array extends Sprite {

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

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

Ermöglicht das Erstellen eines Arrays mit der angegebenen Anzahl an Elementen. Sie können Werte beliebigen Typs angeben. Das erste Element in einem Array hat immer den Index oder die Position 0.

Hinweis: Diese Klasse zeigt zwei Konstruktoreinträge, da der Konstruktor Argumente verschiedenen Typs akzeptiert. Der Konstruktor verhält sich unterschiedlich, je nach Typ und Anzahl der übergebenen Argumente, wie sie in den einzelnen Einträgen beschrieben sind. Überladene Methoden oder Konstruktoren werden von ActionSript 3.0 nicht unterstützt.

Siehe auch

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

Verkettet die in den Parametern angegebenen Elemente mit den Elementen in einem Array und erstellt ein neues Array. Wenn die Parameter ein Array angeben, werden die Elemente dieses Arrays verkettet.

Parameter

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

Führt für jedes Element im Array eine Testfunktion aus, bis ein Element erreicht wird, das für die angegebene Funktion false zurückgibt. Sie verwenden diese Methode, um zu ermitteln, ob alle Elemente in einem Array ein Kriterium erfüllen, z. B. dass die Werte unter einer bestimmten Zahl liegen.

Für diese Methode muss der zweite Parameter (thisObject) den Wert null haben, wenn der erste Parameter (callback) ein Methodenabschluss ist. Angenommen, Sie erstellen eine Funktion in einem Movieclip mit dem Namen me:

     function myFunction(obj:Object):void { //Hier eigenen Code eingeben }
     

Nehmen Sie weiter an, Sie wenden dann die Methode every() auf ein Array mit dem Namen myArray an:

     myArray.every(myFunction, me);
     

Da myFunction ein Mitglied der Timeline-Klasse ist, die von me nicht überschrieben werden kann, wird Flash Player eine Ausnahme auslösen. Sie können diesen Laufzeitfehler vermeiden, indem Sie die Funktion wie folgt einer Variable zuweisen:

     var myFunction:Function = function(obj:Object):void { //Hier eigenen Code eingeben }; myArray.every(myFunction, me);
     

Parameter

function callback(item:*, index:int, array:Array):Boolean;

Siehe auch

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

Führt für jedes Element im Array eine Testfunktion aus und erstellt ein neues Array für alle Elemente, die für die angegebene Funktion true zurückgeben. Gibt ein Element false zurück, wird es nicht in den neuen Array aufgenommen.

Für diese Methode muss der zweite Parameter (thisObject) den Wert null haben, wenn der erste Parameter (callback) ein Methodenabschluss ist. Angenommen, Sie erstellen eine Funktion in einem Movieclip mit dem Namen me:

     function myFunction(obj:Object):void { //Hier eigenen Code eingeben }
     

Nehmen Sie weiter an, Sie wenden dann die Methode filter() auf ein Array mit dem Namen myArray an:

 
     myArray.filter(myFunction, me);
     

Da myFunction ein Mitglied der Timeline-Klasse ist, die von me nicht überschrieben werden kann, wird Flash Player eine Ausnahme auslösen. Sie können diesen Laufzeitfehler vermeiden, indem Sie die Funktion wie folgt einer Variable zuweisen:

     var myFunction:Function = function(obj:Object):void { //Hier eigenen Code eingeben }; myArray.filter(myFunction, me);
     

Parameter

    function callback(item:*, index:int, array:Array):Boolean;

Siehe auch

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

Führt für jedes Element im Array eine Funktion aus.

Für diese Methode muss der zweite Parameter (thisObject) den Wert null haben, wenn der erste Parameter (callback) ein Methodenabschluss ist. Angenommen, Sie erstellen eine Funktion in einem Movieclip mit dem Namen me:

     function myFunction(obj:Object):void { //Hier eigenen Code eingeben }
     

Nehmen Sie weiter an, Sie wenden dann die Methode forEach() auf ein Array mit dem Namen myArray an:

     myArray.forEach(myFunction, me);
     

Da myFunction ein Mitglied der Timeline-Klasse ist, die von me nicht überschrieben werden kann, wird Flash Player eine Ausnahme auslösen. Sie können diesen Laufzeitfehler vermeiden, indem Sie die Funktion wie folgt einer Variable zuweisen:

     var myFunction:Function = function(obj:Object):void { //Hier eigenen Code eingeben }; myArray.forEach(myFunction, me);
     

Parameter

    function callback(item:*, index:int, array:Array):void;

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

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

Sucht nach einem Element in einem Array unter Verwendung strikter Gleichheit (===), und gibt die Indexposition des Elements zurück.

Parameter

Siehe auch

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

Wandelt die Elemente in einem Array in Strings um, fügt zwischen ihnen das angegebene Trennzeichen ein, verkettet die Elemente und gibt den resultierenden String zurück. Ein verschachteltes Array wird immer durch ein Komma getrennt und nicht durch das Trennzeichen, das an die join()-Methode übergeben wurde.

Parameter

Siehe auch

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

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

Sucht rückwärts, vom letzten Element aus, nach einem Element in einem Array und gibt die Indexposition des Elements zurück, das unter Verwendung des strikten Gleichheitsoperators (===) übereinstimmt.

Parameter

Siehe auch

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

Führt für jedes Element in einem Array eine Funktion aus, und erstellt ein neues Array mit Elementen, die den Ergebnissen der Funktion entsprechen.

Für diese Methode muss der zweite Parameter (thisObject) den Wert null haben, wenn der erste Parameter (callback) ein Methodenabschluss ist. Angenommen, Sie erstellen eine Funktion in einem Movieclip mit dem Namen me:

     function myFunction(obj:Object):void { //Hier eigenen Code eingeben }
     

Nehmen Sie weiter an, Sie wenden dann die Methode map() auf ein Array mit dem Namen myArray an:

     myArray.map(myFunction, me);
     

Da myFunction ein Mitglied der Timeline-Klasse ist, die von me nicht überschrieben werden kann, wird Flash Player eine Ausnahme auslösen. Sie können diesen Laufzeitfehler vermeiden, indem Sie die Funktion wie folgt einer Variable zuweisen:

     var myFunction:Function = function(obj:Object):void { //Hier eigenen Code eingeben }; myArray.map(myFunction, me);
     

Parameter

    function callback(item:*, index:int, array:Array):void;

Siehe auch

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

Entfernt das letzte Element aus einem Array und gibt den Wert dieses Elements zurück.

Siehe auch

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

Fügt am Ende eines Arrays ein oder mehrere Elemente hinzu und gibt die neue Länge des Arrays zurück.

Parameter

Siehe auch

var letters:Array = new Array();

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

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

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

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

Kehrt die Reihenfolge der Array-Elemente im Array um.

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

Entfernt das erste Element aus einem Array und gibt dieses Element zurück. Die verbleibenden Array-Elemente werden von ihrer ursprünglichen Position, i, nach i-1 verschoben.

Siehe auch

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

Gibt ein neues Array zurück, das aus mehreren Elementen des ursprünglichen Arrays besteht, ohne das ursprüngliche Array dabei zu ändern. Das zurückgegebene Array umfasst das Element startIndex und alle Elemente bis (ausschließlich) zum Element endIndex.

Wenn Sie keine Parameter übergeben, wird eine Kopie des ursprünglichen Arrays erstellt.

Parameter

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

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

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

Führt für jedes Element im Array eine Testfunktion aus, bis ein Element erreicht wird, das true zurückgibt. Verwenden Sie diese Methode, um festzustellen, ob alle Elemente in einem Array ein Kriterium erfüllen, z. B. dass die Werte unter einer bestimmten Zahl liegen.

Für diese Methode muss der zweite Parameter (thisObject) den Wert null haben, wenn der erste Parameter (callback) ein Methodenabschluss ist. Angenommen, Sie erstellen eine Funktion in einem Movieclip mit dem Namen me:

     function myFunction(obj:Object):void { //Hier eigenen Code eingeben }
     

Nehmen Sie weiter an, Sie wenden dann die Methode some() auf ein Array mit dem Namen myArray an:

     myArray.some(myFunction, me);
     

Da myFunction ein Mitglied der Timeline-Klasse ist, die von me nicht überschrieben werden kann, wird Flash Player eine Ausnahme auslösen. Sie können diesen Laufzeitfehler vermeiden, indem Sie die Funktion wie folgt einer Variable zuweisen:

     var myFunction:Function = function(obj:Object):void { //Hier eigenen Code eingeben }; myArray.some(myFunction, me);
     

Parameter

    function callback(item:*, index:int, array:Array):Boolean;

Siehe auch

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

Sortiert die Elemente in einem Array. Diese Methode sortiert nach Unicode-Werten. (ASCII ist eine Untergruppe von Unicode.)

In der Standardeinstellung funktioniert Array.sort() wie folgt:

• Bei der Sortierung wird Groß-/Kleinschreibung beachtet (Z kommt vor a).
• Die Sortierung erfolgt aufsteigend (a kommt vor b).
• Das Array wird entsprechend der Sortierreihenfolge geändert. Elemente mit identischen Sortierfeldern werden im sortierten Array ohne bestimmte Reihenfolge nacheinander platziert.
• Alle Elemente werden, unabhängig von ihrem Datentyp, so sortiert, als seien sie Strings. 100 kommt demnach vor 99, da "1" ein kleinerer Stringwert ist als "9".

Um ein Array in einer von den Standardeinstellungen abweichenden Reihenfolge zu sortieren, können Sie entweder eine der im Abschnitt sortOptions des ...args-Parameters beschriebenen Sortierreihenfolgen verwenden oder eine eigene benutzerdefinierte Funktion für die Sortierung erstellen. Wenn Sie eine benutzerdefinierte Funktion erstellen möchten, rufen Sie die Methode sort() auf und verwenden den Namen der benutzerdefinierten Funktion als erstes Argument (compareFunction).

Parameter

Siehe auch

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

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

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

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

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

Sortiert die Elemente in einem Array nach mindestens einem Feld im Array. Das Array muss folgende Merkmale aufweisen:

• Es handelt sich um ein indiziertes und kein assoziatives Array.
• Jedes Element des Arrays enthält ein Objekt mit mindestens einer Eigenschaft.
• Sämtliche Objekte haben mindestens eine Eigenschaft gemeinsam, anhand deren Werte die Objekte im Array sortiert werden können. Eine solche Eigenschaft wird als field bezeichnet.

Wenn Sie mehrere fieldName-Parameter übergeben, stellt das erste Feld das primäre Sortierfeld dar, das zweite Feld das nächste Sortierfeld usw. Flash sortiert nach Unicode-Werten. (ASCII ist eine Untergruppe von Unicode.) Wenn eines der zu vergleichenden Elemente das im fieldName-Parameter angegebene Feld nicht enthält, wird davon ausgegangen, dass das Feld auf undefined gesetzt wurde, und die Elemente werden im sortierten Array ohne bestimmte Reihenfolge nacheinander platziert.

In der Standardeinstellung funktioniert Array.sortOn() wie folgt:

• Bei der Sortierung wird Groß-/Kleinschreibung beachtet (Z kommt vor a).
• Die Sortierung erfolgt aufsteigend (a kommt vor b).
• Das Array wird entsprechend der Sortierreihenfolge geändert. Elemente mit identischen Sortierfeldern werden im sortierten Array ohne bestimmte Reihenfolge nacheinander platziert.
• Numerische Felder werden so sortiert, als seien sie Strings. 100 kommt demnach vor 99, da "1" ein kleinerer Stringwert ist als "9".

Flash Player 7 umfasst den options-Parameter, mit dem Sie das Standardverhalten der Sortierung außer Kraft setzen können. Wenn Sie ein einfaches Array (z. B. ein Array mit nur einem Feld) sortieren oder eine nicht vom options-Parameter unterstützte Sortierreihenfolge festlegen möchten, verwenden Sie Array.sort().

Wenn Sie mehrere Flags übergeben möchten, trennen Sie diese mithilfe des bitweisen OR-Operators (|):

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

In Flash Player 8 haben Sie die Möglichkeit, bei einer Sortierung nach mehreren Feldern für jedes Feld eine andere Sortieroption anzugeben. In Flash Player 8 kann für den options-Parameter ein Array mit Sortieroptionen angegeben werden, bei dem jede Sortieroption einem Sortierfeld im fieldName-Parameter entspricht. Im folgenden Beispiel wird nach dem primären Sortierfeld a in absteigender Reihenfolge, dann nach dem sekundären Sortierfeld b anhand einer numerischen Sortierung und schließlich nach dem Sortierfeld c mit einer Sortierung ohne Beachtung der Groß-/Kleinschreibung sortiert.

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

Hinweis: Die Arrays fieldName und options müssen die gleiche Anzahl von Elementen aufweisen. Andernfalls wird das Array options ignoriert. Außerdem können die Optionen Array.UNIQUESORT und Array.RETURNINDEXEDARRAY nur als erstes Element im Array verwendet werden, da sie ansonsten ignoriert werden.

Parameter

Siehe auch

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

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

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

Fügt einem Array Elemente hinzu bzw. entfernt diese. Bei dieser Methode werden Änderungen am Array vorgenommen, ohne eine Kopie zu erstellen.

Hinweis: Um diese Methode in einer Unterklasse von Array zu überschreiben, verwenden Sie, wie im folgenden Beispiel gezeigt, ...args für die Parameter:

  public override function splice(...args) { // Hier eigene Anweisungen eingeben }
  

Parameter

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

 
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

Gibt einen String zurück, der die Elemente im angegebenen Array repräsentiert. Alle Array-Elemente von Index 0 bis zum höchsten Index werden in einen verketteten, durch Kommata getrennten String umgewandelt. In der ActionScript 3.0-Implementierung gibt diese Methode denselben Wert wie die Methode Array.toString() zurück.

Siehe auch

Gibt einen String zurück, der die Elemente im angegebenen Array repräsentiert. Alle Array-Elemente von Index 0 bis zum höchsten Index werden in einen verketteten, durch Kommata getrennten String umgewandelt. Verwenden Sie die Array.join()-Methode, um ein benutzerdefiniertes Trennzeichen anzugeben.

Siehe auch

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

Fügt am Anfang eines Arrays ein oder mehrere Elemente hinzu und gibt die neue Länge des Arrays zurück. Die anderen Elemente im Array werden von ihrer ursprünglichen Position, i, nach i+1 verschoben.

Parameter

Siehe auch

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

Legt als Sortiermethode für die Array-Klasse eine Sortierung ohne Beachtung der Groß- und Kleinschreibung fest. Sie können diese Konstante als Wert für den options-Parameter in der Methode sort() oder sortOn() verwenden.

Diese Konstante hat den Wert 1.

Siehe auch

Legt als Sortiermethode für die Array-Klasse eine absteigende Sortierreihenfolge fest. Sie können diese Konstante als Wert für den options-Parameter in der Methode sort() oder sortOn() verwenden.

Diese Konstante hat den Wert 2.

Siehe auch

Legt als Sortiermethode für die Array-Klasse eine numerische (statt einer stringbasierten) Sortierreihenfolge fest. Wenn Sie diese Konstante dem options-Parameter hinzufügen, sortieren die sort()- und sortOn()-Methoden Zahlen als numerische Werte und nicht als Strings numerischer Zeichen. Ohne die Konstante NUMERIC werden bei der Sortierung alle Array-Elemente wie Strings behandelt, und die Ergebnisse werden in der Unicode-Reihenfolge dargestellt.

Wenn beispielsweise bei einem Array der Werte [2005, 7, 35] die Konstante NUMERIC not dem options-Parameter hinzugefügt ist, lautet das sortierte Array [2005, 35, 7]. Wurde die Konstante NUMERIC jedoch is, lautet das sortierte Array [7, 35, 2005].

Diese Konstante gilt nur für Zahlen im Array. Sie gilt jedoch nicht für Strings mit numerischen Daten wie ["23", "5"].

Diese Konstante hat den Wert 16.

Siehe auch

Legt fest, dass eine Sortierung ein Array zurückgibt, der aus Arrayindizes besteht. Diese Konstante können Sie für den Parameter options in den Methoden sort() oder sortOn() verwenden, sodass Sie Zugriff auf mehrere Ansichten zu Array-Elementen haben, während das Originalarray unverändert bleibt.

Diese Konstante hat den Wert 8.

Siehe auch

Legt als Sortiermethode für die Array-Klasse eine eindeutige Sortierreihenfolge fest. Sie können diese Konstante als Wert für den options-Parameter in der Methode sort() oder sortOn() verwenden. Bei der eindeutigen Sortierung wird der Vorgang beendet, sobald zwei beliebige zu sortierende Elemente bzw. Felder den gleichen Wert enthalten.

Diese Konstante hat den Wert 4.

Siehe auch