demonstrativo 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
modifiers
Opcional.Modificador 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 de tipo enumerado.initializer1,..., initializer2 initializerN
Opcional.Uma expressão de constante que substituirá o valor numérico do padrão de um membro de enumeração.
Comentários
An enum declaração apresenta um novo tipo de dados enumerado no programa. An 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 qualquer tipo de dados (int, curto, longo, byte, uint, ushort, ulong, ou sbyte). sistema autônomo membros da enumeração implicitamente coagir e para o tipo de dados, permitindo a atribuições diretas de dados numéricos a variáveis digitadas sistema autônomo enum. Por padrão, o tipo de dados de uma enumeração é int.
Cada membro de tipo enumerado tem um nome e um inicializador opcional.Um inicializador deve ser um time de compilar, expressão constante que é do mesmo tipo de enumeração conversível no tipo ou especificada.O valor do primeiro membro do tipo enumerado é zero ou valor de inicializador, se fornecido.O valor de cada membro de tipo enumerado subseqüente é mais um e, em seguida, o membro anterior ou o valor de inicializador, se fornecido.
An enum valor é 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 tipo, uma das seguintes pode ser usado: um nome totalmente qualificado (por exemplo, Color.Red), uma representação de seqüência do nome (sistema autônomo "Red"), ou um valor numérico.
Se um enum é atribuído a uma seqüência de caracteres que é conhecida no time de compilar, o compilador irá executar a conversão necessária. Por exemplo, "Red" deve ser substituído por Color.Red. Se a seqüência de caracteres não for conhecida no time de compilar, será feita uma conversão em time de execução.Essa conversão pode falhar se a seqüência de caracteres não é um membro válido de tipo enumerado.Como a conversão é demorada e erros em time de execução podem ser gerados, evite atribuir um enum em uma seqüência de caracteres variável.
Uma variável de um tipo enumerado pode Isenção valores fora do intervalo de valores declarados.Um uso desse recurso é permitir combinações de membros usados sistema autônomo sinalizadores de bit, sistema autônomo em concluído no exemplo a seguir.Convertendo um enum variável para uma seqüência de caracteres resultados na representação da cadeia de caracteres do nome do membro.
Exemplo 1
O exemplo a seguir mostra o comportamento de enumerações.Ele declara uma enumeração simples 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 manter os sinalizadores de bit e também que um enum variável deve ser capaz de armazenar valores não explicitamente na lista de membros. Ele define uma enumeração 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