Les méthodes propres à E4X peuvent utiliser des objets QName, quels qu’ils soient, à l’aide de chaînes. Les méthodes E4X figurent dans les classes QName, Namespace, XML et XMLList. Parce qu’elles extraient une chaîne, elles peuvent également extraire un objet QName. Cette interchangeabilité explique comment une méthode telle que
A l’instar des classes XML, XMLList et Namespace, la classe QName implémente des normes de gestion XML performantes définies dans la spécification ECMAScript pour XML (E4X) (ECMA-357, édition 2).
Un identificateur complet renvoie un objet QName. Si l’objet QName d’un élément XML est spécifié sans identifier d’espace de noms, la propriété
Ce code produit les résultats suivants :
Remarque : cette classe utilise deux entrées de constructeur, car chaque forme accepte des paramètres différents. Le constructeur se comporte différemment selon le type et le nombre de paramètres 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.
QName (uri:Namespace, localName:String); QName (uri:String, localName: QName); QName (uri:String, localName: String);
Si vous transmettez
Remarque : cette classe utilise deux entrées de constructeur, car chaque forme accepte des paramètres différents. Le constructeur se comporte différemment selon le type et le nombre de paramètres 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.
Le format varie selon la propriété
Ifuri == ""toString returnslocalName else ifuri == nulltoString returns ~~::localName elsetoString returnsuri ::localName
Utilisez les méthodes et les propriétés de cette classe pour accéder aux constantes et fonctions mathématiques et les manipuler. Toutes les propriétés et les méthodes de la classe Math sont statiques et doivent être appelées à l’aide de la syntaxe
Plusieurs méthodes de la classe Math utilisent la mesure d’un angle en radians en tant que paramètre. Vous pouvez utiliser l’équation suivante pour calculer les valeurs en radian avant d’appeler la méthode, puis exprimer la valeur calculée en tant que paramètre. Vous pouvez également utiliser toutes les valeurs situées à droite de l’équation (l’angle étant exprimé en radians plutôt qu’en
Pour calculer une valeur radian, utilisez la formule suivante :
radians = degrees ~~ Math.PI/180
Pour convertir les radians en degrés, utilisez la formule suivante :
degrees = radians ~~ 180/Math.PI
Dans l’exemple suivant, l’équation est utilisée en tant que paramètre pour calculer le sinus d’un angle de 45° :
Remarque : les fonctions Math acos, asin, atan, atan2, cos, exp, log, pow, sin et sqrt risquent de produire un résultat légèrement différent selon les algorithmes utilisés par le processeur ou le système d’exploitation. Les moteurs d’exécution de Flash font appel au processeur (ou au système d’exploitation si le processeur ne prend pas en charge les calculs en virgule flottante) lorsqu’ils effectuent des calculs pour les fonctions indiquées et que les résultats sont légèrement différents selon le processeur ou le système d’exploitation utilisé.
La méthode
La méthode
Vous pouvez stocker divers types de données dans un élément de tableau, y compris les nombres, les chaînes, les objets et même d’autres tableaux. Vous pouvez créer un tableau multidimensionnel en concevant un tableau indexé et en affectant à chacun de ses éléments un tableau indexé différent. Ce type de tableau est considéré comme étant multidimensionnel car il peut être utilisé pour représenter des données dans un tableau.
Les tableaux sont sparse arrays, ce qui signifie qu’un élément peut occuper la position d’index 0 et un autre la position d’index 5, mais qu’aucun autre élément n’occupe une position comprise entre 0 et 5. Dans ce cas, les éléments compris entre la position 1 et la position 4 ne sont pas définis. Ce terme indique généralement l’absence d’un élément, plutôt que la présence d’un élément doté de la valeur
L’affectation au tableau s’effectue par référence plutôt que par valeur. lorsque vous affectez une variable de tableau à une autre variable de tableau, elles renvoient toutes deux au même tableau :
N’utilisez pas la classe Array pour créer des associative arrays (également appelés hashes), qui sont des structures de données qui contiennent des éléments nommés et non pas des éléments chiffrés. Pour créer des tableaux associatifs, utilisez la classe Object. Bien que ActionScript vous permette de créer des tableaux associatifs à l’aide de la classe Array, vous ne pouvez pas associer les méthodes ou les propriétés de cette dernière à un tableau associatif.
Vous pouvez étendre la classe Array et bloquer ou ajouter des méthodes. Vous devez cependant affecter à la sous-classe la propriété
Remarque : si vous transmettez un paramètre numérique unique au constructeur Array, il est implicitement interprété comme la propriété
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.
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.
function callback(item:*, index:int, array:Array):Boolean;
Avec cette méthode, le second paramètre,
function myFunction(obj:Object):void {
//your code here
}
Supposons que vous utilisiez ensuite la méthode
myArray.every(myFunction, me);
Etant donné que
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.every(myFunction, me);
function callback(item:*, index:int, array:Array):Boolean;
Avec cette méthode, le second paramètre,
function myFunction(obj:Object):void {
//your code here
}
Supposons que vous utilisez ensuite la méthode
myArray.filter(myFunction, me);
Etant donné que
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.filter(myFunction, me);
function callback(item:*, index:int, array:Array):void;
Avec cette méthode, le second paramètre,
function myFunction(obj:Object):void {
//your code here
}
Supposons que vous utilisiez ensuite la méthode
myArray.forEach(myFunction, me);
Etant donné que
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.forEach(myFunction, me);
function callback(item:*, index:int, array:Array):String;
Avec cette méthode, le second paramètre,
function myFunction(obj:Object):void {
//your code here
}
Supposons que vous utilisiez ensuite la méthode
myArray.map(myFunction, me);
Etant donné que
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.map(myFunction, me);
Si vous ne transmettez aucun paramètre, le nouveau tableau est une duplication (clone superficiel) du tableau d’origine.
function callback(item:*, index:int, array:Array):Boolean;
Avec cette méthode, le second paramètre,
function myFunction(obj:Object):void {
//your code here
}
Supposons que vous utilisiez ensuite la méthode
myArray.some(myFunction, me);
Etant donné que
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.some(myFunction, me);
Les conseils de code sont activés si vous utilisez le format chaîne de l’indicateur (par exemple,
Si vous transmettez plusieurs paramètres
Par défaut,
Flash Player 7 a ajouté le paramètre
Pour définir plusieurs indicateurs, séparez-les à l’aide de l’opérateur OR (
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
Remarque : les tableaux
Ce tableau est ensuite trié des façons suivantes :
Un tableau appelé
Cette méthode utilise la syntaxe et l’ordre des arguments de
Par défaut,
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
Remarque : Le comportement par défaut de la fonction
Remarque : pour annuler cette méthode dans une sous-classe de Array, utilisez
public override function splice(...args) {
// your statements here
}
La valeur de cette constante est 1.
La valeur de cette constante est 2.
Supposons par exemple que vous disposez du tableau de valeurs
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
La valeur de cette constante est 16.
La valeur de cette constante est 8.
La valeur de cette constante est 4.
Remarque : si vous affectez une valeur plus courte que la valeur existante à la propriété
Pour créer un objet RegExp, utilisez le constructeur
Pour plus d’informations, voir le chapitre « Utilisation d’expressions régulières » dans le Guide du développeur d’ActionScript 3.0.
Remarques :
Dans la première expression, vous devez taper deux fois le caractère barre oblique inversée, car le premier paramètre de la méthode constructeur
Aucun autre caractère de la chaîne
Si l’indicateur
Si l’indicateur
L’objet
Dans l’exemple suivant, l’indicateur
Le résultat du code est le suivant :
0 She,,e 10 seashells,sea,ells 27 seashore,sea,ore
Si l’indicateur
Si l’indicateur
Utilisez l’indicateur
Si la méthode
Vous pouvez définir la propriété
La classe Date gère l’heure d’été différemment, en fonction du système d’exploitation et de la version du moteur d’exécution. Flash Player 6 et les versions ultérieures gèrent l’heure d’été sur les systèmes d’exploitation suivants comme suit :
Flash Player 5 gère l’heure d’été sur les systèmes d’exploitation suivants comme suit :
Pour utiliser la classe Date, construisez une occurrence de Date à l’aide de l’opérateur
ActionScript 3.0 intègre plusieurs nouvelles propriétés accesseur que vous pouvez substituer à de nombreuses méthodes de la classe Date qui accèdent à des occurrences de Date ou les modifient. ActionScript 3.0 inclut également plusieurs nouvelles variations de la méthode
Pour calculer l’heure relative ou le temps écoulé, voir la méthode
Le constructeur
Si vous transmettez une chaîne au constructeur de la classe Date, la date peut être exprimée dans divers formats, mais doit inclure au moins le mois, la date et l’année. Par exemple,
Elle s’avère utile si vous voulez transmettre une date UTC au constructeur de la classe Date. Le constructeur de la classe Date acceptant l’intervalle exprimé en millisecondes en tant qu’argument, vous pouvez utiliser la méthode Date.UTC() pour convertir une date UTC en intervalle correspondant et transmettre cette valeur en tant qu’argument au constructeur de la classe Date :
function addMonths(num:Number):void {
currentMonth = currentMonth + num;
if(currentMonth > 12) {
currentYear++;
currentMonth = currentMonth - 12;
}
}
Day Mon DD HH:MM:SS TZD YYYY
Par exemple :
Wed Apr 12 15:30:17 GMT-0700 2006
La désignation TZD (Time Zone Designation) prend toujours la forme
MM/DD/YYYY HH:MM:SS TZD
HH:MM:SS TZD Day Mon/DD/YYYY
Mon DD YYYY HH:MM:SS TZD
Day Mon DD HH:MM:SS TZD YYYY
Day DD Mon HH:MM:SS TZD YYYY
Mon/DD/YYYY HH:MM:SS TZD
YYYY/MM/DD HH:MM:SS TZD
L’appel de cette méthode ne modifie pas les autres champs de l’objet
Vous pouvez éventuellement utiliser cette méthode pour définir également le mois et le jour du mois. L’appel de cette méthode ne modifie pas les autres champs, mais les méthodes
Day Mon Date HH:MM:SS TZD YYYY
Par exemple :
Wed Apr 12 15:30:17 GMT-0700 2006
Toutes les classes qui ne déclarent pas de classe de base explicite étendent la classe Object intégrée.
Vous pouvez utiliser la classe Object pour créer des associative arrays. Sous sa forme de base, un tableau associatif est une occurrence de la classe Object et chaque paire clé/valeur est représentée par une propriété et sa valeur. Vous pouvez également déclarer un tableau associatif à l’aide du type de données Object pour la raison suivante : cela vous permet d’utiliser ensuite un littéral d’objet pour alimenter votre tableau associatif (uniquement au moment de la déclaration). L’exemple suivant crée un tableau associatif à l’aide d’un littéral d’objet, accède aux éléments à l’aide de l’opérateur point et d’accès au tableau, puis ajoute une nouvelle paire clé/valeur en créant une nouvelle propriété :
ActionScript 3.0 dispose de deux types d’héritage : par classe et par prototype :
L’héritage de classe et l’héritage de prototype peuvent coexister, comme illustré dans l’exemple suivant :
Si vous utilisez des fonctions au lieu de classes, vous pouvez générer des arborescences d’héritage de prototype personnalisées. Avec les classes, l’arborescence d’héritage de prototype reflète à l’identique l’arborescence d’héritage de classe. Cependant, les objets prototype étant dynamiques, vous pouvez ajouter et supprimer des propriétés associées aux prototypes lors de l’exécution.
L’exemple crée les objets de valeur
Les types de propriétés suivants forcent la méthode à renvoyer la valeur
ActionScript 3.0 gère également les objets de classe, qui sont des représentations directes des définitions de classe. Si vous l’appelez sur un objet de classe, la méthode
Remarque : les méthodes de la classe Object sont créées dynamiquement sur le prototype correspondant. Pour redéfinir cette méthode dans une sous-classe d’Object, n’utilisez pas le mot-clé
Remarque : les méthodes de la classe Object sont créées dynamiquement sur le prototype correspondant. Pour redéfinir cette méthode dans une sous-classe d’Object, n’utilisez pas le mot-clé
Array.length property, is not enumerable.
Les propriétés que vous créez sont énumérables, contrairement aux propriétés intégrées qui ne le sont généralement pas.
Remarque : les méthodes de la classe Object sont créées dynamiquement sur le prototype correspondant. Pour redéfinir cette méthode dans une sous-classe d’Object, n’utilisez pas le mot-clé
Par défaut, l’implémentation de cette méthode n’entraîne pas le formatage selon les paramètres régionaux et renvoie la même chaîne que
Remarque : les méthodes de la classe Object sont créées dynamiquement sur le prototype correspondant. Pour redéfinir cette méthode dans une sous-classe d’Object, n’utilisez pas le mot-clé
Remarque : les méthodes de la classe Object sont créées dynamiquement sur le prototype correspondant. Pour redéfinir cette méthode dans une sous-classe d’Object, n’utilisez pas le mot-clé
Remarque : les méthodes de la classe Object sont créées dynamiquement sur le prototype correspondant. Pour redéfinir cette méthode dans une sous-classe d’Object, n’utilisez pas le mot-clé
Si vous utilisez le mot-clé
Les utilisateurs chevronnés peuvent opter pour le mot-clé
Remarque : la propriété
Si vous accédez à la propriété
prototype property of the Circle class points to its superclass Shape. The identifier Shape refers to the constructor function of the Shape class.
prototype property and the __proto__ property together to move two levels up the inheritance hierarchy (or prototype chain). The Circle.prototype.__proto__ property contains a reference to the superclass of the Shape class.
L’objet prototype d’une classe est une occurrence spéciale de cette classe, qui propose un mécanisme de partage d’état parmi toutes les occurrences d’une classe. Lors de l’exécution, si une propriété ne figure pas dans une occurrence de classe, elle est recherchée dans le délégué, à savoir l’objet prototype de la classe. Si l’objet prototype ne contient pas la propriété, le processus se poursuit et le délégué de l’objet prototype effectue des recherches dans des niveaux de plus en plus élevés de la hiérarchie jusqu’à ce que le moteur d’exécution de Flash trouve la propriété.
Remarque : dans ActionScript 3.0, l’héritage de prototype ne constitue pas le principal mécanisme d’héritage. Ce rôle incombe à l’héritage de classe, qui assure l’héritage des propriétés fixes dans les définitions de classe.
Exemples d’erreurs liées à la sécurité :
Vous pouvez cependant faire référence à des propriétés non définies d’une classe dynamique sans entraîner le renvoi d’une exception ReferenceError. Pour plus d’informations, voir le mot-clé
D’autres cas de figure entraînent le renvoi de cette exception, notamment :
Les propriétés des constantes de la classe int,
Similaire au type de données int dans Java et C++, le type de données int s’avère utile pour les compteurs de boucles et les cas où un nombre à virgule flottante n’est pas nécessaire. La valeur par défaut d’une variable de type int correspond à
Si vous manipulez des nombres supérieurs à
L’exemple suivant appelle la méthode
L’exemple suivant affecte la valeur de la propriété
var smallest:int = int.MIN_VALUE;
var n1:int = new int(3.4); var n2:int = new int(-10);
var myint:int = new int(9); trace(myint.toString(2)); // 1001 trace(myint.toString(8)); // 11
L’exemple suivant renvoie une valeur hexadécimale.
var r:int = new int(250); var g:int = new int(128); var b:int = new int(114); var rgb:String = "0x"+ r.toString(16)+g.toString(16)+b.toString(16); trace(rgb); // 0xfa8072
var numSocks:int = new int(2); trace(numSocks.valueOf()); // 2
trace("int.MIN_VALUE = "+int.MIN_VALUE);
trace("int.MAX_VALUE = "+int.MAX_VALUE);
Ce code
int.MIN_VALUE = -2147483648 int.MAX_VALUE = 2147483647
trace("int.MIN_VALUE = "+int.MIN_VALUE);
trace("int.MAX_VALUE = "+int.MAX_VALUE);
Ce code
int.MIN_VALUE = -2147483648
int.MAX_VALUE = 2147483647
Les propriétés de la classe Number sont statiques, ce qui signifie qu’il n’est pas nécessaire de disposer d’un objet pour les utiliser ; par conséquent, il n’est pas nécessaire d’utiliser le constructeur.
Le type de données Number est conforme à la norme IEEE-754 relative aux nombres à deux décimales.
Il s’avère utile lorsque vous utilisez des valeurs à virgule flottante. Les moteurs d’exécution de Flash gèrent mieux les types de données int et uint que le type de données Number, mais Number est utile lorsque la plage de valeurs requises dépasse la plage valide des types de données int et uint. La classe Number permet de représenter des valeurs d’entier qui dépassent nettement la plage valide des types de données int et uint. Le type de données Number utilise jusqu’à 53 bits pour représenter les valeurs d’entier, alors que int et uint sont limités à 32 bits. La valeur par défaut d’une variable de type Number est
L’infini négatif est une valeur numérique spéciale renvoyée lorsqu’une opération mathématique ou une fonction renvoie une valeur négative supérieure à celle pouvant être représentée.
L’infini positif est une valeur numérique spéciale renvoyée lorsqu’une opération mathématique ou une fonction renvoie une valeur supérieure à celle pouvant être représentée.
Les méthodes d’une classe sont légèrement différentes des objets Function. A l’encontre d’un objet Function standard, une méthode est étroitement liée à l’objet de classe associé. De ce fait, une méthode ou une propriété possède une définition partagée par toutes les occurrences d’une même classe. Les méthodes peuvent être extraites d’une occurrence et traitées comme si elles étaient « liées » (en d’autres termes, comme des méthodes qui conservent le lien à l’occurrence d’origine). Pour une méthode liée, le mot-clé
Les paramètres sont spécifiés sous forme d’objet Array, contrairement à
Renvoie la valeur spécifiée en tant que valeur renvoyée par la fonction appelée.
Dans presque tous les cas, l’opérateur d’appel de fonction (
Dans certains cas, il peut être souhaitable que
Vous pouvez transmettre la valeur
Renvoie la valeur spécifiée en tant que valeur renvoyée par la fonction appelée.
Si un objet XMLList ne comporte qu’un seul élément XML, vous pouvez utiliser les méthodes de classe XML directement sur l’objet XMLList. Dans l’exemple suivant,
Si vous tentez d’utiliser des méthodes de classe XML avec un objet XMLList contenant plusieurs objets XML, une exception est renvoyée. Vous pouvez par contre, effectuer une itération sur la collection XMLList (à l’aide d’une instruction
Pour renvoyer tous les descendants, utilisez le paramètre astérisque (~~). Si aucun paramètre n’est transmis, la chaîne « ~~ » est transmise et renvoie tous les descendants de l’objet XML.
Pour renvoyer à chaque fois l’objet XML entier, utilisez la méthode
Pour créer un objet Boolean, vous pouvez utiliser le constructeur ou la fonction globale, ou affecter une valeur littérale. Utilisez la technique de votre choix, car elles sont toutes trois équivalentes dans ActionScript 3.0 (à l’encontre de JavaScript, où un objet Boolean et le type de primitive Boolean sont deux entités distinctes).
Les lignes de code suivantes sont équivalentes :
Vous pouvez également créer une sous-classe de la classe Error et générer des occurrences de cette sous-classe.
Cette exception est également renvoyée dans les cas suivants :
Les arguments sont stockés sous forme d’éléments de tableau : le premier est accessible sous la forme
A l’encontre des versions précédentes d’ActionScript, ActionScript 3.0 n’intègre pas de propriété
ActionScript 3.0 intègre un nouveau mot-clé
Dans la mesure où le paramètre
Lorsque l’exécution revient à
Tous les index de chaîne étant de base zéro, l’index du dernier caractère pour une chaîne
Vous pouvez appeler l’une des méthodes de la classe String que vous utilisiez la méthode constructeur
Lorsqu’ils définissent une variable de type chaîne sur
var s:String = undefined;règle la valeur sur
Remarque : les littéraux de chaîne utilisant moins de temps système que les objets String et étant généralement plus faciles à utiliser, il est recommandé de faire appel à eux plutôt qu’à la classe String, sauf si vous avez une bonne raison d’utiliser un objet String plutôt qu’un littéral de chaîne.
Cette méthode est similaire à
Les valeurs Unicode sont définies sur la page
Cette méthode est similaire à
Les valeurs Unicode sont définies sur la page
var myPattern:RegExp = /sh./g;
// The dot (.) matches any character.
var str:String = "She sells seashells by the seashore.";
trace(str.match(myPattern));
// Output: she,sho
myPattern = /sh./gi;
// This time, make it case insensitive (with the i flag).
str = "She sells seashells by the seashore.";
trace(str.match(myPattern));
// Output: She,she,sho
myPattern = RegExp = new RegExp("sh(.)", "gi")
// Note the grouping parentheses.
str = "She sells seashells by the seashore.";
trace(str.match(myPattern));
// Output: She,e,she,e,sho,o
// Note that the result array is
// [[She,e],[she,e],[sho,o]]
Si
S’il n’existe aucune correspondance, la méthode renvoie un tableau vide. Si vous ne transmettez pas de valeur (ou si vous transmettez une valeur non définie) en tant que paramètre
Si vous spécifiez une chaîne en tant que paramètre
L’exemple suivant illustre l’utilisation des codes de remplacement
Si vous spécifiez une fonction en tant que paramètre
Considérons par exemple ce qui suit :
L’appel de la méthode
La seconde fois, les critères correspondent à la sous-chaîne
Dans l’exemple suivant, seule la première occurrence de « sh » (le respect de la casse étant activé) est remplacée :
Dans l’exemple suivant, toutes les occurrences de « sh » (le respect de la casse étant activé) sont remplacées, car l’indicateur
Dans l’exemple suivant, toutes les occurrences de « sh » sont remplacées, car l’indicateur
var str:String = "She sells seashells by the seashore.";
var myPattern:RegExp = /sh/;
// This time, make it case insensitive (with the i flag).
trace(str.match(myPattern));
// Output: 13
// (The substring match starts at character position 13.)
var myPattern:RegExp = /sh/i;
trace(str.match(myPattern));
// Output: 0
// (The substring match starts at character position 0
// -- the first character of the source string.)
Si le paramètre
Si le paramètre
Si le paramètre
Si le paramètre
Si le paramètre
Cette méthode convertit tous les caractères (pas seulement A-Z) pour lesquels il existe des équivalents minuscules Unicode :
Ces mappages de casse sont définis sur la page
Cette méthode convertit tous les caractères (pas seulement a-z) pour lesquels il existe des équivalents majuscules Unicode :
Ces mappages de casse sont définis sur la page
valueOf method returns
the primitive value, rather than a reference to the new instance.
Tous les index de chaîne étant de base zéro, l’index du dernier caractère pour une chaîne
Certaines méthodes, telles que
Le nom de classe renvoie à l’objet Class, comme illustré dans l’exemple ci-dessous :
class Foo {
}
L’instruction
Utilisez l’instruction
Les méthodes et propriétés statiques d’une classe sont héritées par l’objet Class de la classe. En retour, Class déclare
En règle générale, il est inutile de déclarer ou de créer manuellement des variables de type Class. Cependant, dans le code ci-dessous, une propriété Class publique
Un autre fichier SWF peut charger le fichier Library.swf généré, puis instancier les objets de type Circle. L’exemple suivant illustre une façon d’accéder aux ressources d’un fichier SWF enfant (d’autres techniques font appel à
ActionScript 3.0 vous permet de créer des classes intégrées destinées aux ressources externes (telles que les images, les sons ou les polices) qui sont compilées dans des fichiers SWF. Dans les versions antérieures d’ActionScript, vous associez ces ressources à la méthode
Par exemple, si vous utilisez un compilateur MXML pour générer des fichiers SWF, vous devez créer une classe intégrée de la manière suivante :
Pour l’instancier, vous écrivez le code suivant :
Cette classe utilise deux formes de la méthode de constructeur, car chaque forme accepte des paramètres différents.
A l’instar des classes XML, XMLList et QName, cette classe implémente des normes de gestion XML performantes définies dans la spécification ECMAScript pour XML (E4X) (ECMA-357, édition 2).
L’exemple définit des espaces de nom et des couleurs qui correspondent à des états de souris pour un bouton rectangulaire. Lorsque le bouton est dessiné, l’exemple applique la couleur appropriée (rouge lorsque la souris quitte la zone active (out) ; jaune pour le survol (over) ; blanc pour abaissé (down)) en référençant la variable
La valeur du paramètre
La valeur du paramètre
Remarque : cette classe utilise deux entrées de méthode de constructeur, car chaque forme accepte des paramètres différents. 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.
Remarque : cette classe utilise deux entrées de constructeur, car chaque forme accepte des paramètres différents. Le constructeur se comporte différemment selon le type et le nombre de paramètres 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.
La méthode
Remarque : la classe XML et les classes apparentées intégrées à ActionScript 2.0 ont été renommées XMLDocument et transférées dans le package flash.xml. La classe XML figure dans ActionScript 3.0 à des fins de compatibilité ascendante.
La méthode
Utilisez l’opérateur
Le paramètre
Si une référence de nom complet s’impose, vous pouvez transmettre un objet QName. Un objet QName définit un espace de noms et le nom local, que vous pouvez utiliser pour définir le nom complet d’un attribut. De ce fait, appeler
Le paramètre
Utilisez un astérisque (~~) pour extraire tous les enfants dans un document XML. Exemple :
La méthode
Remarque : cette méthode ne doit pas être appliquée à une occurrence de la classe XML, mais à
Pour renvoyer tous les descendants, utilisez le paramètre « ~~ ». Si aucun paramètre n’est transmis, la chaîne « ~~ » est transmise et renvoie tous les descendants de l’objet XML.
Pour recenser tous les éléments, utilisez le paramètre astérisque (~~). L’astérisque est également le paramètre par défaut.
La méthode
trace(xml.a.(b == "11"));
Si vous appelez cette méthode pour un enfant XML qui n’est pas un élément (texte, attributs, commentaires, pi, etc.),
Utilisez l’opérateur
<menu> <item>burger</item> <saleItem>fries</saleItem> <item>soda</item> </menu>
Si vous appelez cette méthode pour un enfant XML qui n’est pas un élément (texte, attributs, commentaires, pi, etc.),
Utilisez l’opérateur
<menu>
<saleItem>fries</saleItem>
<item>burger</item>
<item>soda</item>
</menu>
rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns# dc: http://purl.org/dc/elements/1.1/ (default): http://purl.org/rss/1.0/
Utilisez l’opérateur
<body> <p>Hello</p> <p>Bob</p> <hr/> </body>
<body> <p>Hi</p> <hr/> </body>;
<ns:body xmlns:ns = "myNS"> <p>Bob</p> <hr/> </ns:body>
<body> <img src="hello.jpg"/> </body>
Remarque : cette méthode ne doit pas être appliquée à une occurrence de la classe XML, mais à
Pour renvoyer à chaque fois l’objet XML entier, utilisez la méthode
Lorsque vous créez un objet XML, il place en mémoire cache la valeur actuelle de la propriété
Remarque : si vous essayez d’utiliser la fonction
La fonction
La valeur renvoyée varie selon le type de données et la valeur de l’argument, comme décrit dans le tableau suivant :
A l’encontre des versions antérieures d’ActionScript, la fonction
Le tableau suivant affiche le résultat de divers types d’entrées :
Le vecteur résultant est renseigné avec les valeurs contenues dans les éléments de l’argument
Quoi qu’il en soit, le type de données de tous les éléments de l’argument
Si la valeur
Si un vecteur est transmis en tant qu’argument
De même, si un élément de l’argument
Par exemple, le code suivant génère une erreur de compilation en mode strict, ou une erreur TypeError à l’exécution, car il tente d’affecter un Vector.<Sprite> à une variable Vector.<DisplayObject> (Sprite est une sous-classe de DisplayObject) :
La version alternative du code suivante copie avec succès les éléments d’une occurrence de Vector.<Sprite> sur une occurrence de Vector.<DisplayObject> :
Le tableau suivant décrit les valeurs renvoyées pour divers types d’entrées.
Le tableau suivant décrit les valeurs renvoyées pour divers types d’entrées.
Cette fonction est différente de la fonction
Il existe une autre différence majeure entre cette fonction et
Le tableau suivant contient l’ensemble de séquences d’échappement qui ne sont pas décodées par la fonction
La fonction
Il existe une autre différence majeure entre cette fonction et
Le tableau suivant répertorie tous les caractères qui ne sont pas convertis en séquences d’échappement UTF-8 par la fonction
Le tableau suivant répertorie l’ensemble complet des caractères de base qui ne sont pas convertis en séquences d’échappement UTF-8 par la fonction
Le tableau suivant répertorie tous les caractères qui ne sont pas convertis en séquences d’échappement par la fonction
Remarque : Utilisez la fonction
Remarque : La valeur
Le tableau ci-dessous décrit la valeur renvoyée par
Le tableau ci-dessous décrit la valeur renvoyée par
La valeur
La valeur
La valeur
Les résultats varient lorsque
Veillez à ne pas confondre
La plage de valeurs représentée par la classe uint est comprise entre 0 et 4 294 967 295 (2^32-1).
Pour créer un objet uint, déclarez une variable de type uint et affectez-lui une valeur littérale. La valeur par défaut d’une variable de type uint correspond à
La classe uint est surtout utilisée pour les valeurs de couleur de pixel (ARVB et RVBA), ainsi que les cas où le type de données int ne fonctionne pas correctement. Par exemple, le nombre 0xFFFFFFFF, qui représente la valeur de la couleur blanche avec une valeur alpha 255, ne peut pas être représenté à l’aide du type de données int, car elle excède la plage de valeurs int valides.
L’exemple suivant crée un objet uint et appelle la méthode
var myuint:uint = 1234; trace(myuint.toString()); // 1234
L’exemple suivant affecte la valeur de la propriété
var smallest:uint = uint.MIN_VALUE; trace(smallest.toString()); // 0
var n1:uint = 3; var n2:uint = new uint(10);
var myuint:uint = 9; trace(myuint.toString(2)); // 1001 trace(myuint.toString(8)); // 11L’exemple suivant crée des valeurs hexadécimales :
var r:uint = 250; var g:uint = 128; var b:uint = 114; var rgb:String = "0x" + r.toString(16) + g.toString(16) + b.toString(16); trace(rgb); // 0xfa8072
var numSocks:uint = 2; trace(numSocks.valueOf()); // 2
trace("uint.MIN_VALUE = " + uint.MIN_VALUE);
trace("uint.MAX_VALUE = " + uint.MAX_VALUE);
Les valeurs sont les suivantes :
uint.MIN_VALUE = 0 uint.MAX_VALUE = 4294967295
trace("uint.MIN_VALUE = " + uint.MIN_VALUE);
trace("uint.MAX_VALUE = " + uint.MAX_VALUE);
Les valeurs sont les suivantes :
uint.MIN_VALUE = 0 uint.MAX_VALUE = 4294967295
Tout comme pour un tableau, vous pouvez utiliser l’opérateur d’accès au tableau (
Le type de base du vecteur est spécifié à l’aide d’une syntaxe de paramètres de type postfix. La syntaxe de paramètres de type est une séquence constituée d’un point (
Dans la première ligne de cet exemple, la variable
Une variable déclarée avec le type de données Vector.<T> peut stocker uniquement une occurrence de Vector construite avec le même type de base
Pour convertir un objet Vector avec un type de base
Outre la restriction concernant le type de données, la classe Vector possède d’autres restrictions qui la distinguent de la classe Array :
Grâce à ses restrictions, un vecteur présente trois avantages principaux par rapport à une occurrence d’Array dont les éléments sont tous des occurrences d’une seule classe :
Lorsque vous appelez le constructeur
Pour créer une occurrence de Vector à partir d’un tableau ou d’un autre vecteur (notamment avec un type de base différent), utilisez la fonction globale
Pour créer une occurrence de Vector préremplie, utilisez la syntaxe suivante au lieu d’utiliser les paramètres spécifiés ci-dessous :
Les informations ci-dessous s’appliquent à la syntaxe suivante :
function callback(item:T, index:int, vector:Vector.<T>):Boolean {
// your code here
}
La fonction de rappel doit renvoyer une valeur booléenne.
Avec cette méthode, le second paramètre,
Néanmoins, supposons que vous créiez une fonction sur une image du scénario principal à l’aide de Flash Professional et que vous souhaitiez qu’elle soit appelée dans un contexte
function myFunction(item:T, index:int, vector:Vector.<T>):Boolean {
// your code here
}
Supposons que vous utilisiez ensuite la méthode
myVector.every(myFunction, someObject);
Etant donné que
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):Boolean {
//your code here
};
myVector.every(myFunction, someObject);
function callback(item:T, index:int, vector:Vector.<T>):Boolean;
Avec cette méthode, le second paramètre,
Néanmoins, supposons que vous créiez une fonction sur une image du scénario principal à l’aide de Flash Professional et que vous souhaitiez qu’elle soit appelée dans un contexte
function myFunction(item:T, index:int, vector:Vector.<T>):Boolean {
// your code here
}
Supposons que vous utilisiez ensuite la méthode
var result:Vector.<T> = myVector.filter(myFunction, someObject);
Etant donné que
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):Boolean {
//your code here
};
myVector.filter(myFunction, someObject);
function callback(item:T, index:int, vector:Vector.<T>):void;
Toute valeur renvoyée depuis l’appel de fonction est supprimée.
Avec cette méthode, le second paramètre,
Néanmoins, supposons que vous créiez une fonction sur une image du scénario principal à l’aide de Flash Professional et que vous souhaitiez qu’elle soit appelée dans un contexte
function myFunction(item:T, index:int, vector:Vector.<T>):void {
// your code here
}
Supposons que vous utilisiez ensuite la méthode
myVector.forEach(myFunction, someObject);
Etant donné que
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):void {
//your code here
};
myVector.forEach(myFunction, someObject);
Si ce paramètre est négatif, il est considéré comme
function callback(item:T, index:int, vector:Vector.<T>):T;
Avec cette méthode, le second paramètre,
Néanmoins, supposons que vous créiez une fonction sur une image du scénario principal à l’aide de Flash Professional et que vous souhaitiez qu’elle soit appelée dans un contexte
function myFunction(item:Object, index:int, vector:Vector.<T>):T {
// your code here
}
Supposons que vous utilisiez ensuite la méthode
myVector.map(myFunction, someObject);
Etant donné que
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):void {
//your code here
};
myVector.map(myFunction, someObject);
Etant donné que cette fonction peut accepter plusieurs arguments, le type de données des arguments n’est pas vérifié au moment de la compilation, même en mode strict. En revanche, si un argument n’étant pas une occurrence du type de base est transmis, une exception se produit au moment de l’exécution.
Si vous ne transmettez aucun paramètre, le nouveau vecteur est une duplication (clone simple) du vecteur d’origine. Si vous transmettez une valeur de 0 pour les deux paramètres, un nouveau vecteur vide de même type que le vecteur d’origine est créé.
function callback(item:T, index:int, vector:Vector.<T>):Boolean
La fonction de rappel doit renvoyer une valeur booléenne.
Avec cette méthode, le second paramètre,
Néanmoins, supposons que vous créiez une fonction sur une image du scénario principal et que vous souhaitiez qu’elle soit appelée dans un contexte
function myFunction(item:Object, index:int, vector:Vector.<T>):Boolean {
// your code here
}
Supposons que vous utilisiez ensuite la méthode
myVector.some(myFunction, someObject);
Etant donné que
var myFunction:Function = function(item:T, index:int, vector:Vector.<T>):Boolean {
//your code here
};
myVector.some(myFunction, someObject);
La méthode spécifiée doit prendre deux arguments du type de base (
La logique de la fonction
Remarque : pour annuler cette méthode dans une sous-classe de Vector, utilisez
public override function splice(...args) {
// your statements here
}
Etant donné que cette fonction peut accepter plusieurs arguments, le type de données des arguments n’est pas vérifié au moment de la compilation, même en mode strict. En revanche, si un argument n’étant pas une occurrence du type de base est transmis, une exception se produit au moment de l’exécution.
Chaque élément du vecteur possède toujours une valeur qui correspond à une occurrence du type de base ou à la valeur
Lorsque la propriété