Istruzione enum
Consente di dichiarare il nome di un tipo di dati enumerato e il nome dei membri dell'enumerazione.
[modifiers] enum enumName [ : typeAnnotation]{
enumValue1 [ = initializer1]
[,enumValue2 [ = initializer2]
[, ... [,enumValueN [ = initializerN ] ]]]
}
Argomenti
modifiers
Facoltativo. Modificatori che controllano la visibilità e il comportamento dell'enumerazione.enumName
Obbligatorio. Nome del tipo enumerato.typeAnnotation
Facoltativo. Tipo di dati sottostante dell'enumerazione. Deve essere un tipo di dati integrale. Il valore predefinito è int.enumValue1, enumValue2, ..., enumValueN
Facoltativo. Membro di tipo enumerato.initializer1, initializer2, ..., initializerN
Facoltativo. Un'espressione costante che esegue l'override del valore numerico predefinito di un membro di enumerazione.
Note
Una dichiarazione enum consente di introdurre nel programma un nuovo tipo di dati enumerati. Può essere utilizzata solo in contesti in cui sono consentite le dichiarazioni di classe, ovvero nell'ambito globale, nell'ambito di un package o nell'ambito di una classe, ma non all'interno di una funzione o di un metodo.
È possibile dichiarare come tipo di dati sottostante di un'enumerazione qualsiasi tipo di dati integrale (int, short, long, byte, uint, ushort, ulong o sbyte). I membri dell'enumerazione vengono assegnati forzatamente in modo implicito da e al tipo di dati sottostante consentendo assegnazioni dirette di dati numerici alle variabili di tipo enum. Per impostazione predefinita, il tipo di dati sottostante di un'enumerazione è int.
Ad ogni membro di tipo enumerato è assegnato un nome e un inizializzatore facoltativo. Un inizializzatore deve essere costituito da un'espressione costante in fase di compilazione dello stesso tipo dell'enumerazione specificata o convertibile in quel tipo. Il valore del primo membro di tipo enumerato è zero o equivale al valore dell'inizializzatore, se specificato. Il valore di ogni successivo membro di tipo enumerato è maggiore di un'unità rispetto al valore del membro precedente o al valore dell'inizializzatore, se specificato.
Le modalità di accesso a un valore enum sono analoghe a quelle utilizzate per accedere a un membro di classe statico. Il nome del membro deve essere definito in modo completo mediante il nome dell'enumerazione, ad esempio Color.Red. Quando si assegna un valore a una variabile di tipo enum, è possibile utilizzare un nome completo (quale Color.Red), una rappresentazione del nome in forma di stringa (quale "Red") o un valore numerico.
Se enum viene assegnato a una stringa nota in fase di compilazione, il compilatore effettuerà la necessaria conversione. Ad esempio, "Red" verrà sostituito con Color.Red. Se la stringa non è nota in fase di compilazione, la conversione verrà eseguita in fase di esecuzione. Se la stringa non è un membro valido del tipo enumerato, la conversione potrebbe avere esito negativo. Dal momento che la conversione richiede diverso tempo e possono essere generati errori di runtime, evitare di assegnare un valore enum a una stringa variabile.
Una variabile di un tipo enumerato può contenere valori esterni all'intervallo dei valori dichiarati. Tale funzionalità può essere impiegata per consentire le combinazioni di membri utilizzati in qualità di flag di bit, come illustrato nell'esempio che segue. La conversione di una variabile enum in una stringa produce la rappresentazione in forma di stringa del nome del membro.
Esempio 1
Nell'esempio seguente viene mostrato il comportamento delle enumerazioni. In esso viene dichiarata una semplice enumerazione denominata CarType i cui membri sono Honda, Toyota e 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);
L'output del codice è il seguente:
0: Honda
2: Nissan
1: Toyota
Esempio 2
Nell'esempio seguente viene illustrato come utilizzare un'enumerazione per assegnarle flag di bit e per consentire a una variabile enum di contenere valori nell'elenco dei membri in modo non esplicito. In esso viene definita un'enumerazione FormatFlags utilizzata per modificare il comportamento di una funzione 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));
L'output del codice è il seguente:
12: hello, WORLD
ToUpperCase: HELLO, WORLD
18: %20%20hello,%20world%20%20