Entier non négatif spécifiant le nombre d'éléments contenus dans le tableau. Cette propriété est automatiquement mise à jour lorsque vous ajoutez de nouveaux éléments dans le tableau. Lorsque vous affectez une valeur à un élément de tableau (par exemple, my_array[index] = value), si index est un nombre et si index+1 est supérieur à la propriété length, la propriété length est mise à jour et définie sur la valeur index+1.

Remarque : si vous affectez une valeur plus courte que la valeur existante à la propriété length, le tableau sera tronqué.

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

Vous permet de créer un tableau contenant le nombre spécifié d'éléments. Si vous ne spécifiez aucun paramètre, un tableau contenant 0 élément est créé. Si vous spécifiez un nombre d'éléments, le tableau créé contient le nombre d'éléments indiqué par numElements.

Remarque : cette classe contient deux entrées de méthode de constructeur, car le constructeur gère les types variables d'arguments. Le constructeur se comporte différemment selon le type et le nombre d'arguments transmis, comme indiqué dans chaque entrée. ActionScript 3.0 ne prend pas en charge la surcharge d'une méthode ou d'un constructeur.

Voir aussi

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

Vous permet de créer un tableau contenant le nombre spécifié d'éléments. Tous les types de valeurs sont pris en charge. La valeur de l'index (ou de la position) du premier élément d'un tableau est toujours 0.

Remarque : cette classe contient deux entrées de constructeur, car celui-ci gère les types variables d'arguments. Le constructeur se comporte différemment selon le type et le nombre d'arguments transmis, comme indiqué dans chaque entrée. ActionScript 3.0 ne prend pas en charge la surcharge d'une méthode ou d'un constructeur.

Voir aussi

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

Concatène les éléments spécifiés dans les paramètres avec ceux contenus dans un tableau et crée un nouveau tableau. Si les paramètres spécifient un tableau, les éléments correspondants sont concaténés.

Paramètres

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

Exécute une fonction de test sur chaque élément du tableau jusqu'à ce que l'un d'eux renvoie false pour la fonction spécifiée. Cette méthode vous permet de déterminer si tous les éléments d'un tableau répondent à un critère défini, tel que des valeurs inférieures à un nombre spécifique.

Avec cette méthode, le second paramètre, thisObject, doit être réglé sur null si le premier paramètre, callback, est une fermeture de méthode. Supposons que vous créez une fonction dans un clip appelé me :

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

Supposons que vous utilisiez ensuite la méthode every() sur un tableau appelé myArray :

myArray.every(myFunction, me);

Parce que myFunction appartient à la classe Timeline, qui ne peut pas être bloquée par me, Flash Player renvoie une exception. Pour éviter le renvoi de cette erreur d'exécution, affectez la fonction à une variable, comme suit :

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

Paramètres

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

Voir aussi

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

Exécute une fonction de test sur chaque élément du tableau et construit un nouveau tableau contenant tous les éléments qui renvoient true pour la fonction spécifiée. Si un élément renvoie false, il ne figure pas dans le nouveau tableau.

Avec cette méthode, le second paramètre, thisObject, doit être réglé sur null si le premier paramètre, callback, est une fermeture de méthode. Supposons que vous créez une fonction dans un clip appelé me :

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

Supposons que vous utilisez ensuite la méthode filter() sur un tableau appelé myArray :

myArray.filter(myFunction, me);

Parce que myFunction appartient à la classe Timeline, qui ne peut pas être bloquée par me, Flash Player renvoie une exception. Pour éviter le renvoi de cette erreur d'exécution, affectez la fonction à une variable, comme suit :

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

Paramètres

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

Voir aussi

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

Exécute une fonction sur chaque élément du tableau.

Avec cette méthode, le second paramètre, thisObject, doit être réglé sur null si le premier paramètre, callback, est une fermeture de méthode. Supposons que vous créez une fonction dans un clip appelé me :

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

Supposons que vous utilisiez ensuite la méthode forEach() sur un tableau appelé myArray :

myArray.forEach(myFunction, me);

Parce que myFunction appartient à la classe Timeline, qui ne peut pas être bloquée par me, Flash Player renvoie une exception. Pour éviter le renvoi de cette erreur d'exécution, affectez la fonction à une variable, comme suit :

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

Paramètres

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

Recherche un élément dans un tableau en utilisant l'opérateur d'égalité stricte (===) et renvoie la position d'index de l'élément.

Paramètres

Voir aussi

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

Convertit les éléments d'un tableau en chaînes, insère le séparateur spécifié entre les éléments, les concatène, puis renvoie la chaîne obtenue. Un tableau imbriqué est toujours séparé par une virgule (,), et non pas par le séparateur transmis à la méthode join().

Paramètres

Voir aussi

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

Recherche un élément dans un tableau en travaillant à rebours à partir du dernier élément et renvoie la position d'index de l'élément correspondant en utilisant l'opérateur d'égalité stricte ( === ).

Paramètres

Voir aussi

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

Exécute une fonction sur les éléments d'un tableau et construit un nouveau tableau en fonction des résultats de la fonction appliquée à chaque élément du tableau d'origine.

Avec cette méthode, le second paramètre, thisObject, doit être réglé sur null si le premier paramètre, callback, est une fermeture de méthode. Supposons que vous créez une fonction dans un clip appelé me :

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

Supposons que vous utilisiez ensuite la méthode map() sur un tableau appelé myArray :

myArray.map(myFunction, me);

Parce que myFunction appartient à la classe Timeline, qui ne peut pas être bloquée par me, Flash Player renvoie une exception. Pour éviter le renvoi de cette erreur d'exécution, affectez la fonction à une variable, comme suit :

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

Paramètres

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

Voir aussi

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

Supprime le dernier élément d'un tableau et renvoie la valeur de cet élément.

Voir aussi

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

Ajoute un ou plusieurs éléments à la fin d'un tableau et renvoie la nouvelle longueur du tableau.

Paramètres

Voir aussi

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

Inverse le tableau.

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

Supprime le premier élément d'un tableau et renvoie cet élément. Les éléments restants du tableau sont décalés de leur position d'origine, i, vers i-1.

Voir aussi

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

Renvoie un nouveau tableau constitué d'un éventail d'éléments issus du tableau d'origine, sans modifier ce dernier. Le tableau renvoyé inclut l'élément startIndex et tous les éléments, excepté l'élément endIndex.

Si vous ne transmettez aucun paramètre, une duplication du tableau d'origine est créée.

Paramètres

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

Exécute une fonction de test sur chaque élément du tableau jusqu'à ce que l'un d'eux renvoie true. Cette méthode vous permet de déterminer si un élément de tableau répond au critère défini, tel qu'une valeur inférieure à un nombre spécifique.

Avec cette méthode, le second paramètre, thisObject, doit être réglé sur null si le premier paramètre, callback, est une fermeture de méthode. Supposons que vous créez une fonction dans un clip appelé me :

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

Supposons que vous utilisiez ensuite la méthode some() sur un tableau appelé myArray :

myArray.some(myFunction, me);

Parce que myFunction appartient à la classe Timeline, qui ne peut pas être bloquée par me, Flash Player renvoie une exception. Pour éviter le renvoi de cette erreur d'exécution, affectez la fonction à une variable, comme suit :

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

Paramètres

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

Voir aussi

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

Trie les éléments d'un tableau. Cette méthode trie selon les valeurs Unicode (ASCII est un sous-ensemble de Unicode).

Par défaut, Array. sort() fonctionne de la façon suivante :

• Le tri tient compte de la casse (Z précède a ).
• Le tri est ascendant (a précède b ).
• Le tableau est modifié afin de refléter l'ordre de tri ; les éléments multiples dont les champs de tri sont identiques sont placés consécutivement dans le tableau trié dans un ordre quelconque.
• Tous les éléments, quel que soit leur type de données, sont triés comme s'il s'agissait de chaînes : ainsi, 100 précède 99 car "1" est une valeur de chaîne inférieure à "9".

Pour trier un tableau à l'aide de réglages autres que les réglages par défaut, vous pouvez utiliser l'une des options de tri décrites dans la section sortOptions de la description du paramètre ...args, ou vous pouvez créer une fonction personnalisée. Si vous créez une fonction personnalisée, vous pouvez appeler la méthode sort() et utiliser le nom de votre fonction personnalisée en tant que premier argument (compareFunction).

Paramètres

Voir aussi

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

Trie les éléments d'un tableau selon un ou plusieurs champs du tableau. Le tableau doit être doté des caractéristiques suivantes :

• Le tableau est indexé et non associatif.
• Chaque élément du tableau contient un objet doté d'une ou de plusieurs propriétés.
• Tous les objets ont au moins une propriété en commun dont les valeurs peuvent être utilisées pour trier le tableau. Ce type de propriété est connu sous le nom de field.

Si vous transmettez plusieurs paramètres fieldName, le premier champ représente le champ de tri principal, le deuxième représente le champ de tri suivant, etc. Flash trie selon les valeurs Unicode (ASCII est un sous-ensemble de Unicode). Si l'un des éléments comparés ne contient pas le champ spécifié dans le paramètre fieldName, le champ est considéré comme étant réglé sur undefined et les éléments sont placés de manière consécutive dans le tableau trié dans un ordre quelconque.

Par défaut, Array. sortOn() fonctionne de la façon suivante :

• Le tri tient compte de la casse (Z précède a ).
• Le tri est ascendant (a précède b ).
• Le tableau est modifié afin de refléter l'ordre de tri ; les éléments multiples dont les champs de tri sont identiques sont placés consécutivement dans le tableau trié dans un ordre quelconque.
• Les champs numériques sont triés comme s'il s'agissait de chaînes : ainsi, 100 précède 99 car "1" est une valeur de chaîne inférieure à "9".

Flash Player 7 a ajouté le paramètre options, que vous pouvez utiliser pour annuler le comportement de tri par défaut. Pour trier un tableau simple (par exemple, un tableau contenant un seul champ) ou pour spécifier un ordre de tri non pris en charge par le paramètre options, utilisez Array.sort().

Pour définir plusieurs indicateurs, séparez-les à l'aide de l'opérateur OR (|) au niveau du bit :

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

La fonctionnalité ajoutée à Flash Player 8 permet de spécifier une option de tri différente pour chaque champ lors d'un tri selon plusieurs champs. Dans Flash Player 8 et les versions ultérieures, le paramètre options accepte un tableau d'options de tri de telle sorte que chaque option de tri correspond à un champ de tri dans le paramètre fieldName. L'exemple suivant trie le champ de tri principal, a, selon un tri décroissant, le deuxième champ de tri, b, selon un tri numérique et le troisième champ de tri, c, selon un tri non sensible à la casse :

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

Remarque : les tableaux fieldName et options doivent contenir le même nombre d'éléments ; sinon, le tableau options est ignoré. En outre, les options Array.UNIQUESORT et Array.RETURNINDEXEDARRAY ne peuvent être utilisées qu'en tant que premier élément du tableau, sinon elles sont ignorées.

Paramètres

Voir aussi

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

Ajoute et supprime des éléments dans un tableau. Cette méthode modifie le tableau sans faire de copie.

Remarque : pour annuler cette méthode dans une sous-classe de Array, utilisez ...args pour les paramètres, comme indiqué dans l'exemple ci-dessous :

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

Paramètres

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

Renvoie une chaîne représentant les éléments du tableau spécifié. Chaque élément du tableau, de la position d'index 0 à la position d'index la plus élevée, est converti en chaîne concaténée et séparé par des virgules. Dans l'implémentation d'ActionScript 3.0, cette méthode renvoie la même valeur que la méthode Array.toString().

Voir aussi

Renvoie une chaîne représentant les éléments du tableau spécifié. Chaque élément du tableau, de la position d'index 0 à la position d'index la plus élevée, est converti en chaîne concaténée et séparé par des virgules. Pour spécifier un séparateur personnalisé, utilisez la méthode Array.join().

Voir aussi

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

Ajoute un ou plusieurs éléments au début d'un tableau et renvoie la nouvelle longueur du tableau. Les autres éléments du tableau sont décalés de leur position d'origine, i, vers i+1.

Paramètres

Voir aussi

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

Spécifie un tri sans respect de la casse pour les méthodes de tri de la classe Array. Vous pouvez utiliser cette constante pour le paramètre options de la méthode sort() ou sortOn().

La valeur de cette constante est 1.

Voir aussi

Spécifie un tri par ordre décroissant pour les méthodes de tri de la classe Array. Vous pouvez utiliser cette constante pour le paramètre options de la méthode sort() ou sortOn().

La valeur de cette constante est 2.

Voir aussi

Spécifie un tri numérique (et non de type chaîne de caractères) pour les méthodes de tri de la classe Array. Si vous incluez cette constante au paramètre options, les méthodes sort() et sortOn() sont obligées de trier les nombres en tant que valeurs numériques, et non en tant que chaînes de caractères numériques. Si vous ne spécifiez pas la constante NUMERIC, le tri traite chaque élément de tableau en tant que chaîne de caractères et donne les résultats selon l'ordre Unicode.

Supposons par exemple que vous disposez du tableau de valeurs [2005, 7, 35]. Si la constante NUMERIC n'est pas incluse dans le paramètre options, le tableau trié correspond à [2005, 35, 7], mais si la constante NUMERIC est incluse, le tableau trié correspond à [7, 35, 2005].

Cette constante s'applique uniquement aux nombres contenus dans le tableau ; elle ne s'applique pas aux chaînes qui contiennent des données numériques telles que ["23", "5"].

La valeur de cette constante est 16.

Voir aussi

Spécifie que le tri renvoie un tableau composé d'index de tableau. Vous pouvez utiliser cette constante dans le paramètre options de la méthode sort() ou sortOn(), afin de disposer de plusieurs vues des éléments du tableau sans modifier le tableau d'origine.

La valeur de cette constante est 8.

Voir aussi

Spécifie le critère de tri unique pour les méthodes de tri de la classe Array. Vous pouvez utiliser cette constante pour le paramètre options de la méthode sort() ou sortOn(). L'option de tri unique met fin au tri si deux éléments ou champs triés ont des valeurs identiques.

La valeur de cette constante est 4.

Voir aussi