Documentación de Flash CS3

Programación con ActionScript 3.0 > El lenguaje ActionScript y su sintaxis > Tipos de datos > Conversiones de tipos

Conversiones de tipos

Se dice que se produce una conversión de tipo cuando se transforma un valor en otro valor con un tipo de datos distinto. Las conversiones de tipo pueden ser implícitas o explícitas. A veces Flash Player realiza una conversión implícita, también denominada coerción, en tiempo de ejecución. Por ejemplo, si se asigna el valor 2 a una variable de tipo Boolean, Flash Player convertirá el valor 2 en el valor booleano true antes de asignar el valor a la variable. La conversión explícita, también denominada conversión, se produce cuando el código ordena al compilador que trate una variable de un tipo de datos como si perteneciera a un tipo de datos distinto. Si se usan valores simples, la conversión convierte realmente los valores de un tipo de datos a otro. Para convertir un objeto a otro tipo, hay que incluir el nombre del objeto entre paréntesis y anteponerle el nombre del nuevo tipo. Por ejemplo, el siguiente código recibe un valor booleano y lo convierte en un entero:

var myBoolean:Boolean = true;
var myINT:int = int(myBoolean);
trace(myINT); // 1

Subtemas

Conversiones implícitas

Las conversiones implícitas se realizan en tiempo de ejecución en algunos contextos:

• En sentencias de asignación
• Cuando se pasan valores como argumentos de función
• Cuando se devuelven valores desde funciones
• En expresiones que utilizan determinados operadores, como el operador suma (+)

Para tipos definidos por el usuario, las conversiones implícitas se realizan correctamente cuando el valor que se va a convertir es una instancia de la clase de destino o una clase derivada de la clase de destino. Si una conversión implícita no se realiza correctamente, se producirá un error. Por ejemplo, el código siguiente contiene una conversión implícita correcta y otra incorrecta:

class A {}
class B extends A {}

var objA:A = new A();
var objB:B = new B();
var arr:Array = new Array();

objA = objB; // La conversión se realiza correctamente.
objB = arr; // La conversión no se realiza correctamente.

Para tipos simples, las conversiones implícitas se realizan llamando a los mismos algoritmos internos de conversión que utilizan las funciones de conversión explícita. En las secciones siguientes se describen en mayor detalle estas conversiones de tipos simples.

Conversiones explícitas

Resulta útil usar conversiones explícitas cuando se compila en modo estricto, ya que a veces no se desea que una discordancia de tipos genere un error en tiempo de compilación. Esto puede ocurrir, por ejemplo, cuando se sabe que la coerción convertirá los valores correctamente en tiempo de ejecución. Por ejemplo, al trabajar con datos recibidos desde un formulario, puede ser interesante basarse en la coerción para convertir determinados valores de cadena en valores numéricos. El código siguiente genera un error de tiempo de compilación aunque se ejecuta correctamente en modo estándar:

var quantityField:String = "3";
var quantity:int = quantityField; // error en tiempo de compilación en modo estricto

Si se desea seguir utilizando el modo estricto pero se quiere convertir la cadena en un entero, se puede utilizar la conversión explícita de la manera siguiente:

var quantityField:String = "3";
var quantity:int = int(quantityField); // La conversión explícita se realiza correctamente.

Conversión a int, uint y Number

Se puede convertir cualquier tipo de datos a uno de los tres tipos numéricos: int, uint y Number. Si Flash Player no puede convertir el número por alguna razón, se asigna el valor predeterminado 0 para los tipos de datos int y uint, y el valor predeterminado NaN para el tipo de datos Number. Si se convierte un valor booleano a un número, true se convierte en el valor 1 y false se convierte en el valor 0.

var myBoolean:Boolean = true;
var myUINT:uint = uint(myBoolean);
var myINT:int = int(myBoolean);
var myNum:Number = Number(myBoolean);
trace(myUINT, myINT, myNum); // 1 1 1
myBoolean = false;
myUINT = uint(myBoolean);
myINT = int(myBoolean);
myNum = Number(myBoolean);
trace(myUINT, myINT, myNum); // 0 0 0

Los valores de cadena que sólo contienen dígitos pueden convertirse correctamente en uno de los tipos numéricos. Los tipos numéricos también pueden convertir cadenas que parecen números negativos o cadenas que representan un valor hexadecimal (por ejemplo, 0x1A). El proceso de conversión omite los caracteres de espacio en blanco iniciales y finales del valor de cadena. También se puede convertir cadenas que parecen números de coma flotante mediante Number(). La inclusión de un separador decimal hace que uint() e int() devuelvan un entero, truncando el separador decimal y los caracteres que siguen. Por ejemplo, los siguientes valores de cadena pueden convertirse en números:

trace(uint("5"));     // 5
trace(uint("-5"));    // 4294967291. Empieza desde el principio a partir de MAX_VALUE
trace(uint(" 27 "));  // 27
trace(uint("3.7"));   // 3
trace(int("3.7"));    // 3
trace(int("0x1A"));   // 26
trace(Number("3.7")); // 3.7

Los valores de cadena que contienen caracteres no numéricos devuelven 0 cuando se convierten con int() o uint(), y NaN cuando se convierten conNumber(). El proceso de conversión omite el espacio en blanco inicial y final, pero devuelve 0 o NaN si una cadena contiene espacio en blanco separando dos números.

trace(uint("5a"));    // 0
trace(uint("ten"));   // 0
trace(uint("17 63")); // 0

En ActionScript 3.0 la función Number() ya no admite números octales (de base 8). Si se suministra una cadena con un cero inicial a la función Number() de ActionScript 2.0, el número se interpreta como un número octal y se convierte en su equivalente decimal. Esto no es así con la función Number() de ActionScript 3.0, que omite el cero inicial. Por ejemplo, el código siguiente genera resultados distintos cuando se compila con versiones distintas de ActionScript:

trace(Number("044")); 
// ActionScript 3.0 44
// ActionScript 2.0 36

La conversión no es necesaria cuando se asigna un valor de un tipo numérico a una variable de un tipo numérico distinto. Incluso en modo estricto, los tipos numéricos se convierten implícitamente a los otros tipos numéricos. Esto significa que en algunos casos pueden producirse valores inesperados cuando se supera el rango de un tipo. Todos los ejemplos siguientes se compilan en modo estricto, aunque algunos generarán valores inesperados:

var myUInt:uint = -3; // Asignar valor de tipo int/Number a variable de tipo uint
trace(myUInt); // 4294967293

var myNum:Number = sampleUINT; // Asignar valor de tipo int/uint a variable de tipo Number
trace(myNum) // 4294967293

var myInt:int = uint.MAX_VALUE + 1; // Asignar valor de tipo Number a variable de tipo uint
trace(myInt); // 0

myInt = int.MAX_VALUE + 1; // Asignar valor de tipo uint/Number a variable de tipo int
trace(myInt); // -2147483648

En la tabla siguiente se resumen los resultados de convertir a los tipos de datos Number, int o uint desde otros tipos de datos.

Conversión a Boolean

La conversión a Boolean desde cualquiera de los tipos de datos numéricos (uint, int y Number) produce false si el valor numérico es 0 y true en caso contrario. Para el tipo de datos Number, el valor NaN también produce false. En el siguiente ejemplo se muestran los resultados de convertir los números -1, 0 y 1:

var myNum:Number;
for (myNum = -1; myNum<2; myNum++)
{
    trace("Boolean(" + myNum +") is " + Boolean(myNum));
}

El resultado del ejemplo muestra que de los tres números, sólo 0 devuelve un valor false:

Boolean(-1) is true
Boolean(0) is false
Boolean(1) is true

La conversión a Boolean desde un valor String devuelve false si la cadena es null o una cadena vacía (""). De lo contrario, devuelve true.

var str1:String;       // La cadena no inicializada es null.
trace(Boolean(str1));  // false

var str2:String = "";  // cadena vacía
trace(Boolean(str2));  // false

var str3:String = " "; // sólo espacio en blanco
trace(Boolean(str3));  // true

La conversión a Boolean desde una instancia de la clase Object devuelve false si la instancia es null y true en caso contrario:

var myObj:Object;      // El objeto no inicializado es null.
trace(Boolean(myObj)); // false

myObj = new Object();  // crear instancia 
trace(Boolean(myObj)); // true

En modo estricto, las variables Boolean reciben un tratamiento especial en el sentido de que se puede asignar valores de cualquier tipo de datos a una variable Boolean sin realizar una conversión. La coerción implícita desde todos los tipos de datos al tipo de datos Boolean se produce incluso en modo estricto. Es decir, a diferencia de lo que ocurre para casi todos los demás tipos de datos, la conversión a Boolean no es necesaria para evitar errores en modo estricto. Todos los ejemplos siguientes se compilan en modo estricto y se comportan de la manera esperada en tiempo de ejecución:

var myObj:Object = new Object();  // crear instancia 
var bool:Boolean = myObj;
trace(bool); // true
bool = "random string";
trace(bool); // true
bool = new Array();
trace(bool); // true
bool = NaN;
trace(bool); // false

En la tabla siguiente se resumen los resultados de convertir al tipo de datos Boolean desde otros tipos de datos:

Conversión a String

La conversión al tipo de datos String desde cualquiera de los tipos de datos numéricos devuelve una representación del número como una cadena. La conversión al tipo de datos String desde un valor booleano devuelve la cadena "true" si el valor es true y devuelve la cadena "false" si el valor es false.

La conversión al tipo de datos String desde una instancia de la clase Object devuelve la cadena "null" si la instancia es null. De lo contrario, la conversión al tipo String de la clase Object devuelve la cadena "[object Object]".

La conversión a String desde una instancia de la clase Array devuelve una cadena que consta de una lista delimitada por comas de todos los elementos de la matriz. Por ejemplo, la siguiente conversión al tipo de datos String devuelve una cadena que contiene los tres elementos de la matriz:

var myArray:Array = ["primary", "secondary", "tertiary"];
trace(String(myArray)); // principal, secundario, terciario

La conversión a String desde una instancia de la clase Date devuelve una representación de cadena de la fecha que contiene la instancia. Por ejemplo, el ejemplo siguiente devuelve una representación de cadena de la instancia de la clase Date (la salida muestra el resultado para el horario de verano de la costa del Pacífico de EE.UU.):

var myDate:Date = new Date(2005,6,1);
trace(String(myDate)); // Fri Jul 1 00:00:00 GMT-0700 2005

En la tabla siguiente se resumen los resultados de convertir al tipo de datos String desde otros tipos de datos.

Flash CS3

Enviarme un mensaje de correo electrónico cuando se añadan comentarios a esta página | Informe de comentarios

Página actual: http://livedocs.adobe.com/flash/9.0_es/main/00000048.html

Añadir comentario