enum, instruction
Déclare le nom d'un type de données énuméré et les noms des membres de l'énumération.
[modifiers] enum enumName [ : typeAnnotation]{
enumValue1 [ = initializer1]
[,enumValue2 [ = initializer2]
[, ... [,enumValueN [ = initializerN ] ]]]
}
Arguments
modifiers
Facultatif. Modificateurs qui contrôlent la visibilité et le comportement de l'énumération.enumName
Obligatoire. Nom du type énuméré.typeAnnotation
Facultatif. Type de données sous-jacent de l'énumération. Il doit s'agir d'un type de données entier. La valeur par défaut est int.enumValue1, enumValue2, ..., enumValueN
Facultatif. Membre du type énuméréinitializer1, initializer2, ..., initializerN
Facultatif. Expression constante qui se substitue à la valeur numérique par défaut d'un membre d'une énumération.
Notes
Une déclaration enum introduit un nouveau type de données énuméré dans le programme. Une déclaration enum peut uniquement apparaître dans des contextes qui acceptent une déclaration de classe, c'est-à-dire au niveau de la portée globale, de la portée de package ou de la portée de la classe, mais pas à l'intérieur d'une fonction ou d'une méthode.
Vous pouvez déclarer le type sous-jacent d'une énumération avec n'importe quel type de données intégral (int, short, long, byte, uint, ushort, ulong ou sbyte). Les membres d'une énumération sont implicitement convertis en et à partir du type de données sous-jacent, ce qui permet l'assignation directe de données numériques à des variables de type enum. Par défaut, le type sous-jacent d'une énumération est int.
Chaque membre du type énuméré a un nom et, éventuellement, un initialiseur. Un initialiseur doit être une expression constante de compilation du même type que l'énumération spécifiée, ou convertible en ce type. La valeur du premier membre de type énuméré est zéro ou la valeur de l'initialiseur si cette dernière est précisée. La valeur de chaque membre du type énuméré suivant est incrémentée de un par rapport au membre précédent ou à la valeur de l'initialiseur, si elle est fournie.
L'accès à une valeur enum est similaire à celui d'un membre de classe statique. Le nom du membre doit être qualifié avec le nom de l'énumération, par exemple Color.Red. Lorsque vous assignez une valeur à une variable de type enum, vous pouvez utiliser un nom qualifié complet (comme Color.Red), une représentation de chaîne du nom (telle que "Red") ou une valeur numérique.
Si une chaîne connue au moment de la compilation est assignée à un type enum, le compilateur effectuera la conversion requise. Ainsi, "Red" serait remplacé par Color.Red. Si la chaîne n'est pas connue au moment de la compilation, une conversion sera effectuée au moment de l'exécution. Cette conversion peut échouer si la chaîne n'est pas un membre valide du type énuméré. Dans la mesure où la conversion prend du temps et où des erreurs d'exécution peuvent se produire, évitez d'assigner un type enum à une chaîne variable.
Une variable d'un type énuméré peut contenir des valeurs situées en dehors de la plage des valeurs déclarées. Cette fonctionnalité autorise notamment les combinaisons d'éléments utilisés comme indicateurs de bits, comme c'est le cas dans l'exemple ci-dessous. La conversion d'une variable enum en une chaîne donne pour résultat la représentation sous forme de chaîne du nom du membre.
Exemple 1
L'exemple suivant illustre le comportement des énumérations. Il déclare une énumération simple appelée CarType qui possède les membres Honda, Toyota et Nissan.
enum CarType {
Honda, // Value of zero, since it is first.
Toyota, // Value of 1, the successor of zero.
Nissan // Value of 2.
}
// Declare a variable of type CarType, and give it the value Honda.
var myCar : CarType = CarType.Honda;
print(int(myCar) + ": " + myCar);
myCar = "Nissan"; // Change the value to "Nissan".
print(int(myCar) + ": " + myCar);
myCar = 1; // 1 is the value of the Toyota member.
print(int(myCar) + ": " + myCar);
Le résultat généré par ce code est le suivant :
0: Honda
2: Nissan
1: Toyota
Exemple 2
L'exemple ci-dessous montre comment utiliser une énumération pour stocker des indicateurs de bits et comment une variable enum peut stocker des valeurs qui ne figurent pas explicitement dans la liste des membres. Il définit une énumération FormatFlags utilisée pour modifier le comportement d'une fonction Format.
// Explicitly set the type to byte, as there are only a few flags.
enum FormatFlags : byte {
// Can't use the default values, since we need explicit bits
ToUpperCase = 1, // Should not combine ToUpper and ToLower.
ToLowerCase = 2,
TrimLeft = 4, // Trim leading spaces.
TrimRight = 8, // Trim trailing spaces.
UriEncode = 16 // Encode string as a URI.
}
function Format(s : String, flags : FormatFlags) : String {
var ret : String = s;
if(flags & FormatFlags.ToUpperCase) ret = ret.toUpperCase();
if(flags & FormatFlags.ToLowerCase) ret = ret.toLowerCase();
if(flags & FormatFlags.TrimLeft) ret = ret.replace(/^\s+/g, "");
if(flags & FormatFlags.TrimRight) ret = ret.replace(/\s+$/g, "");
if(flags & FormatFlags.UriEncode) ret = encodeURI(ret);
return ret;
}
// Combine two enumeration values and store in a FormatFlags variable.
var trim : FormatFlags = FormatFlags.TrimLeft | FormatFlags.TrimRight;
// Combine two enumeration values and store in a byte variable.
var lowerURI : byte = FormatFlags.UriEncode | FormatFlags.ToLowerCase;
var str : String = " hello, WORLD ";
print(trim + ": " + Format(str, trim));
print(FormatFlags.ToUpperCase + ": " + Format(str, FormatFlags.ToUpperCase));
print(lowerURI + ": " + Format(str, lowerURI));
Le résultat généré par ce code est le suivant :
12: hello, WORLD
ToUpperCase: HELLO, WORLD
18: %20%20hello,%20world%20%20