Declaração de enum
Declara o nome de um tipo de dados enumerado e os nomes dos membros da enumeração.
[modifiers] enum enumName [ : typeAnnotation]{
enumValue1 [ = initializer1]
[,enumValue2 [ = initializer2]
[, ... [,enumValueN [ = initializerN ] ]]]
}
Argumentos
modificadores
Opcional. Modificadores de controlam a visibilidade e o comportamento da enumeração.enumName
Obrigatório. Nome do tipo enumerado.typeAnnotation
Opcional. O tipo de dados subjacente da enumeração. Deve ser um tipo de dados. O padrão é int.enumValue1, enumValue2,..., enumValueN
Opcional. Um membro do tipo enumerado.initializer1, initializer2,..., initializerN
Opcional. Uma expressão de constante que substitui o valor numérico do padrão de um membro de enumeração.
Comentários
Um enum declaração introduz um novo tipo de dados enumerado no programa. Um enum declaração pode aparecer apenas em contextos onde uma declaração de classe pode ser exibidos, ou seja, no escopo global, no escopo do pacote, ou no escopo de classe, mas não dentro de uma função ou método.
Você pode declarar o tipo subjacente de uma enumeração de ser qualquer tipo de dados (int, curto, longo, bytes, uint, ushort, ulong, ou sbyte). Os membros de enumeração implicitamente coagir para e dos dados subjacentes de tipo, permitindo a atribuições diretas de dados numéricos a variáveis digitadas como enum. Por padrão, o tipo de dados subjacente de uma enumeração é int.
Cada membro do tipo enumerado tem um nome e um inicializador opcional. Um inicializador deve ser um tempo de compilação, a expressão de constante é do mesmo tipo de enumeração especificado ou conversível desse tipo. O valor do primeiro membro do tipo enumerado é zero ou o valor de inicializador, se fornecido. O valor de cada membro subseqüente tipo enumerado é mais um, em seguida, o membro anterior ou o valor de inicializador, se fornecido.
Um enum valor que é acessado de forma que é semelhante ao acessar um membro de classe estática. O nome do membro deve ser qualificado com o nome da enumeração, por exemplo Color.Red. Ao atribuir um valor a uma variável de um enum o tipo, uma das seguintes pode ser usado: um nome totalmente qualificado (como Color.Red), uma representação de seqüência de caracteres do nome (como "Red"), ou um valor numérico.
Se um enum é atribuído a uma seqüência de caracteres que é conhecido em tempo de compilação, o compilador realizará a conversão necessária. Por exemplo, "Red" devem ser substituídas por Color.Red. Se a seqüência de caracteres não for conhecida no tempo de compilação, será feita uma conversão em tempo de execução. A conversão pode falhar se a seqüência não for um membro válido do tipo enumerado. Como a conversão leva tempo e os erros de tempo de execução podem ser gerados, Evite atribuir um enum a uma variável string.
Uma variável de um tipo enumerado pode armazenar valores fora do intervalo de valores declarados. Um uso desse recurso é permitir que combinações de membros usados como sinalizadores de bit, como no feito no exemplo a seguir. Convertendo um enum variável dos resultados de uma seqüência de caracteres na representação de seqüência de caracteres do nome do membro.
Exemplo 1
O exemplo a seguir mostra o comportamento de enumerações. Ele declara uma enumeração simple chamada CarType que possui membros 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);
A saída desse código é:
0: Honda
2: Nissan
1: Toyota
Exemplo 2
O exemplo a seguir mostra como usar uma enumeração para armazenar os sinalizadores de bit e também que uma enum variável deve ser capaz de armazenar valores não explicitamente na lista de membros. Ele define uma enumeração de FormatFlags que é usado para modificar o comportamento de um Format função.
// 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));
A saída desse código é:
12: hello, WORLD
ToUpperCase: HELLO, WORLD
18: %20%20hello,%20world%20%20