Bienvenidos a una entrada más de nuestro blog. En ocasiones, cuando realizamos la programación de la solución a algún problema o una determinada situación. Es imposible determinar con anterioridad el tipo de datos que necesitaremos al momento de ejecutar el programa.
Ya que por la misma naturaleza cambiante del problema, es imposible determinarlo. Para este tipo de casos, existe una herramienta muy útil, la cual son los datos tipo Variant.
A continuación te muestro un artículo muy interesante que nos habla un poco al respecto y nos muestra como se pueden utilizar dichas variables variant, enfocado un poco al lenguaje Delphi:
“Las variables de tipo Variant dan una gran flexibilidad a Delphi permitiendo el almacenamiento de cualquier tipo de dato básico dentro de las mismas.
Estas variables son muy útiles cuando se necesitan procesar muchos datos en tiempo de ejecución antes de saber su tipo, pero debido a los errores que puede causar hay que tener cuidado al utilizarlas.
Lo que no pueden contener es ninguna estructura de datos, objetos ni punteros. Por ejemplo, no se puede hacer:
var
Variable: Variant;
begin
Variable := nil;
Ya que provocaría un error al compilar. Pero si se puede hacer:
Variable := NULL;
Y mucho ojo porque no es lo mismo una variable Nula que una variable Vacia. Cuando se crea una variable Variant y no se hace nada con ella sigue siendo una variable Vacia, pero no nula. Será Nula si nosotros se lo decimos como hemos visto anteriormente.
¿Pero como sabemos que tipo tipo de dato contiene una variable Variant? Pues para eso tenemos la función VarType que nos devuelve el tipo de dato que contiene una variable Variant. Aquí tenemos una función que nos devuelve el tipo de dato de un Variant:
function TipoVariable( Variable: Variant ): String;
var iTipo: Integer;
begin
iTipo := VarType( Variable );
case iTipo of
varEmpty : Result := ‘Vacía’;
varNull : Result := ‘Nula’;
varSmallInt : Result := ‘SmallInt’;
varInteger : Result := ‘Integer’;
varSingle : Result := ‘Single’;
varDouble : Result := ‘Double’;
varCurrency : Result := ‘Currency’;
varDate : Result := ‘Date’;
varOleStr : Result := ‘OleStr’;
varDispatch : Result := ‘Dispatch’;
varError : Result := ‘Error’;
varBoolean : Result := ‘Boolean’;
varVariant : Result := ‘Variant’;
varUnknown : Result := ‘Desconocida’;
varByte : Result := ‘Byte’;
varWord : Result := ‘Word’;
varLongWord : Result := ‘LongWord’;
varInt64 : Result := ‘Int64’;
varStrArg : Result := ‘StrArg’;
varString : Result := ‘String’;
varAny : Result := ‘Any’;
end;
Result := ‘Tipo ‘ + Result;
end;
Veamos un ejemplo de su utilización volcando el contenido en un Memo:
var
Variable: Variant;
begin
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := NULL;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := 125;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := 1250;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := 125000;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := -1800;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := -1900000;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := ‘Cadena de texto’;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
Variable := True;
Memo.Lines.Add( ‘Variable=’ + VarToStr( Variable ) );
Memo.Lines.Add( TipoVariable( Variable ) );
El resultado que mostrará en pantalla será el siguiente:
Variable=
Tipo Vacía
Variable=
Tipo Nula
Variable=125
Tipo Byte
Variable=1250
Tipo Word
Variable=125000
Tipo LongWord
Variable=-1800
Tipo SmallInt
Variable=-1900000
Tipo Integer
Variable=Cadena de texto
Tipo String
Variable=True
Tipo Boolean
Como vemos según el dato que guardamos en la variable va adaptándose de un tipo a otro”.
Como podemos observar, estas variables variant pueden ser muy útiles sobre todo en tiempo de ejecución. En C++ existe algo similar llamadas Uniones, las cuales estudiaremos en nuestra siguiente sesión.
0 Comentarios