Exportar (0) Imprimir
Expandir todo

enum (Instrucción)

Declara el nombre de un tipo de datos enumerado y los nombres de los miembros de la enumeración.


[modifiers] enum enumName [ : typeAnnotation]{
   enumValue1 [ = initializer1]
   [,enumValue2 [ = initializer2]
   [, ... [,enumValueN [ = initializerN ] ]]]
}

modifiers

Opcional. Modificadores que controlan la visibilidad y el comportamiento de la enumeración.

enumName

Requerido. Nombre del tipo enumerado.

typeAnnotation

Opcional. Tipo de datos subyacente de la enumeración. Debe ser un tipo de datos integral. El valor predeterminado es int.

enumValue1, enumValue2, ..., enumValueN

Opcional. Un miembro de tipo enumerado

initializer1, initializer2, ..., initializerN

Opcional. Expresión constante que reemplaza el valor numérico predeterminado de un miembro de enumeración.

Una declaración enum inserta un tipo de datos enumerado nuevo en el programa. Puede aparecer únicamente en contextos donde pueda aparecer una declaración de clase, es decir, en un ámbito global, en un ámbito de paquete o en un ámbito de clase, pero no dentro de una función o método.

Puede declararse el tipo subyacente de una enumeración para que sea cualquier tipo de datos integral (int, short, long, byte, uint, ushort, ulong o sbyte). Los miembros de la enumeración se convierten implícitamente en el tipo de datos subyacente y viceversa, con lo que posibilita la realización de asignaciones directas de datos numéricos a variables de tipo enum. De manera predeterminada, el tipo de datos subyacente de una enumeración es int.

Cada miembro de tipo enumerado tiene un nombre y un inicializador opcional. Un inicializador debe ser una expresión constante en tiempo de compilación del mismo tipo que la enumeración especificada, o convertible a ese tipo. El valor del primer miembro de tipo enumerado es cero o el valor del inicializador, si se ha proporcionado. El valor de cada uno de los siguientes miembros de tipo enumerado será uno más que el miembro anterior o el valor del inicializador, si se ha proporcionado.

A un valor enum se tiene acceso de un modo similar a como se obtiene acceso a un miembro de clase estática. El nombre del miembro deberá completarse con el nombre de la enumeración (por ejemplo, Color.Red). Cuando se asigna un valor a una variable de un tipo enum, se puede utilizar un nombre completo (como Color.Red), una representación de cadena del nombre (como "Red") o un valor numérico.

Si se asigna una cadena a un tipo enum que se conoce en tiempo de compilación, el compilador realizará la conversión necesaria. Por ejemplo, "Red" se reemplazaría por Color.Red. Si no se conoce la cadena en tiempo de compilación, se realizará una conversión en tiempo de ejecución. Esa conversión puede dar error si la cadena no es un miembro válido del tipo enumerado. Puesto que la conversión conlleva tiempo y se pueden generar errores de tiempo de compilación, deberá evitarse la asignación de un valor enum a una cadena variable.

Una variable de un tipo enumerado puede albergar valores fuera del intervalo de valores declarados. Un uso de esta característica consiste en permitir combinaciones de miembros utilizados como indicadores de bits, como en el ejemplo siguiente. La conversión de una variable enum en una cadena tiene como resultado la representación de cadena del nombre del miembro.

El siguiente ejemplo muestra el comportamiento de las enumeraciones. Declara una enumeración sencilla, denominada CarType, con los miembros Honda, Toyota y 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);

El resultado de este código es:

0: Honda
2: Nissan
1: Toyota

El siguiente ejemplo muestra cómo utilizar una enumeración para albergar indicadores de bits y en qué medida una variable enum ha de ser capaz de albergar valores en la lista de miembros de forma no explícita. Define una enumeración FormatFlags que se utiliza para modificar el comportamiento de una función 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));

El resultado de este código es:

12: hello, WORLD
ToUpperCase:   HELLO, WORLD  
18: %20%20hello,%20world%20%20

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft