Convertir una variable String a otro tipo

Delphi posee un amplio repertorio de funciones para convertir una cadena de texto a otro tipo de variable. Veamos de que funciones disponemos:

function StringToWideChar( const Source: string; Dest: PWideChar; DestSize: Integer ): PWideChar;

Esta función devuelve la cadena Source en formato de caractéres unicode. Por ejemplo:

var
  sTexto: String;
  PWS: PWideChar;
begin
  sTexto := 'Convirtiendo texto a caracteres Unicode (16 bits)';
  New( PWS );
  StringToWideChar( sTexto, PWS, Length( sTexto ) + 1 );
  ShowMessage( PWS );
  Dispose( PWS );
end;

function StrToCurr( const S: string ): Currency; overload;

Convierte una cadena de texto S a un valor Currency. Por ejemplo:

StrToCurr( '1234,5678' ) devuelve 1234,5678
StrToCurr( '1234,,5678' ) provoca el error: '1234,,5678' is not a valid floating point value

function StrToCurrDef( const S: string; const Default: Currency ): Currency; overload;

Esta función es igual que StrToCurr aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToCurrDef( '1234,5678', 0 ) devuelve 1234,5678
StrToCurrDef( '1234,,5678', 0 ) devuelve 0 y no provoca ningún error

function StrToDate( const S: string ): TDateTime; overload;

Convierte la cadena de texto S a un valor de fecha. Por ejemplo:

StrToDate( '17/06/2007' ) devuelve 17/06/2007
StrToDate( '17-06-2007' ) provoca el error: '17-06-2007' is not valid date

function StrToDateDef( const S: string; const Default: TDateTime ): TDateTime; overload;

Esta función es igual que StrToDate aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToDateDef( '17/06/2007', StrToDate( '1/1/2007' ) ) devuelve 17/06/2007
StrToDateDef( '17-06-2007', StrToDate( '1/1/2007' ) ) devuelve 01/01/2007 y no provoca ningún error
StrToDateDef( '17/15/2007', StrToDate( '1/1/2007' ) ) devuelve 01/01/2007 y no provoca ningún error

function StrToDateTime( const S: string ): TDateTime; overload;

Convierte la cadena de texto S a un valor de fecha y hora. Por ejemplo:

StrToDateTime( '17/06/2007 12:25' ) devuelve 17/06/2007 12:25:00
StrToDateTime( '17-06-2007 12:25' ) provoca el error: '17-06-2007 12:25' is not a valid date an time

function StrToDateTimeDef( const S: string; const Default: TDateTime ): TDateTime; overload;

Esta función es igual que StrToDateTime aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToDateTimeDef( '17/06/2007 12:25', StrToDateTime( '1/1/2007 0:0:0' ) ) devuelve 17/06/2007 12:25:00
StrToDateTimeDef( '17-06-2007 12:25', StrToDateTime( '1/1/2007 0:0:0' ) ) devuelve 01/01/2007 12:00:00 sin errores
StrToDateTimeDef( '17/15/2007 12:25', StrToDateTime( '1/1/2007 0:0:0' ) ) devuelve 01/01/2007 12:00:00 sin errores

function StrToFloat( const S: string ): Extended; overload;

Convierte la cadena de texto S a un valor Extended. Por ejemplo:

StrToFloat( '1234,56789' ) devuelve 1234,56789
StrToFloat( '1234,,56789' ) provoca el error: '1234,,56789' is not valid floating point value

function StrToFloatDef( const S: string; const Default: Extended ): Extended; overload;

Esta función es igual que StrToFloat aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToFloatDef( '1234,56789', 0 ) devuelve 1234,56789
StrToFloatDef( '1234,,56789', 0 ) devuelve 0 y no provoca ningún error

function StrToInt( const S: string ): Integer;

Convierte la cadena de texto S a un valor Integer (permite caracteres hexadecimales). Por ejemplo:

StrToInt( '1234' ) devuelve 1234
StrToInt( '$FFFF' ) devuelve 65535
StrToInt( 'FFFF' ) provoca el error: 'FFFF' is not a valid integer value

function StrToIntDef( const S: string; const Default: Integer ): Integer;

Esta función es igual que StrToInt aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToIntDef( '1234', 0 ) devuelve 1234
StrToIntDef( '$FFFF', 0 ) devuelve 65535
StrToIntDef( 'FFFF', 0 ) devuelve 0 y no provoca ningún error
StrToIntDef( '', 0 ) devuelve 0 y no provoca ningún error

function StrToInt64( const S: string ): Int64;

Convierte la cadena de texto S a un valor Int64 (permite caracteres hexadecimales). Por ejemplo:

StrToInt64( '12345678' ) devuelve 12345678
StrToInt64( '$FFFFFFFF' ) devuelve 4294967295

function StrToInt64Def( const S: string; Default: Int64 ): Int64;

Esta función es similar a StrToInt64 aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToInt64Def( '12345678', 0 ) devuelve 12345678
StrToInt64Def( '$FFFFFFFF', 0 ) devuelve 4294967295
StrToInt64Def( 'FFFFFFFF', 0 ) devuelve 0 y no provoca níngun error
StrToInt64Def( '', 0 ) devuelve 0 y no provoca níngun error

function StrToTime( const S: string ): TDateTime; overload;

Convierte la cadena de texto S a un valor TTime o TDateTime. Por ejemplo:

StrToTime( '12:32:54' ) devuelve 12:32:54
StrToTime( '12:32' ) devuelve 12:32:00
StrToTime( '12:32:67' ) provoca el error: '12:32:67' is not a valid time

function StrToTimeDef( const S: string; const Default: TDateTime ): TDateTime; overload;

Esta función es igual a StrToTime aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToTimeDef( '12:32:54', StrToTime( '00:00:00' ) ) devuelve 12:32:54
StrToTimeDef( '12:32', StrToTime( '00:00:00' ) ) devuelve 12:32:00
StrToTimeDef( '12:32:67', TimeToStr( '00:00:00' ) ) devuelve 0:00:00 y no provoca ningún error

function StrToBool( const S: string ): Boolean;

Convierte la cadena de texto S a un valor Boolean. Por ejemplo:

StrToBool( 'True' ) devuelve True
StrToBool( 'False' ) devuelve False
StrToBool( 'Fals' ) provoca el error: 'Fals' is not valid boolean value

function StrToBoolDef( const S: string; const Default: Boolean ): Boolean;

Esta función es igual a StrToBool aceptando además como segundo parámetro el valor que deseamos que tenga por defecto en el caso de que falle la conversión. Por ejemplo:

StrToBoolDef( 'True', False ) devuelve True
StrToBoolDef( 'False', False ) devuelve False
StrToBoolDef( 'Tru', False ) devuelve False y no provoca ningún error
StrToBoolDef( 'Fals', False ) devuelve False y no provoca ningún error

procedure Val( S; var V; var Code: Integer );

Este procedimiento convierte la cadena de texto S a un valor numérico. Si la conversión falla nos devuelve en la variable Code la posición en la cadena de texto S donde está el error. Por ejemplo:

var
  s: String;
  e: Extended;
begin
  s := '1234.5678';
  Val( s, e, iCodigo );

  if iCodigo = 0 then
    ShowMessage( 'Conversión correcta: ' + FloatToStr( e ) )
  else
    ShowMessage( 'Error en la posición: ' + IntToStr( iCodigo ) )
end;

Al ejecutar este bloque de código devolverá:

Conversion correcta: 1234,5678

Pero si sustituimos la primera línea por:

s := '1234,5678';

Entonces mostrará el mensaje:

Error en la posición 5.

Aquí hay que tener mucho cuidado, porque al contrario que la función FloatToStr si ponemos la notación decimal igual que la tenemos en Windows provocará un error. En este caso la notación correcta es el punto y no la coma (se podría solucionar cambiando la variable DecimalSeparator).

Pruebas realizadas en Delphi 7.

El objeto StringList (y III)

IMPORTAR Y EXPORTAR ELEMENTOS DE LA LISTA

Se pueden guardar los elementos de la lista en un archivo de texto utilizando para ello el método SaveToFile:

procedure SaveToFile( const FileName: string ); virtual;

Por ejemplo vamos a guardar nuestra lista de clientes en el mismo directorio donde ejecutamos el programa:

Clientes.SaveToFile( ExtractFilePath( Application.ExeName ) + 'clientes.txt' );

Si más adelante deseamos recuperar el listado utilizamos el procedimiento:

procedure LoadFromFile( const FileName: string ); virtual;

Por ejemplo:

Clientes.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'clientes.txt' );

Si tenemos dos listas en memoria también podemos copiar elementos de una lista a otra. Por ejemplo:

var
  Animales, Animales2: TStringList;
begin
  Animales := TStringList.Create;
  Animales2 := TStringList.Create;

  Animales.Add( 'PERRO' );
  Animales.Add( 'GATO' );
  Animales.Add( 'LEÓN' );

  Animales2.Add( 'VACA' );
  Animales2.Add( 'PATO' );
  Animales2.Add( 'ÁGUILA' );

  // Añadimos a la lista de ANIMALES el contenido de ANIMALES2 y ordenamos la lista
  Animales.AddStrings( Animales2 );
  Animales.Sort;

  // Mostramos el resultado en un campo Memo
  Memo.Lines.Add( Animales.Text );

  Animales2.Free;
  Animales.Free;
end;

El resultado de la lista Animales después de ordenarla sería:

ÁGUILA
GATO
LEÓN
PATO
PERRO
VACA

Otra de las cosas que se pueden hacer es asignar los elementos de una lista a otra, eliminando los elementos de la lista original (sería algo así como copiar y pegar). Por ejemplo si queremos sustituir todos los elementos de la lista Animales por los de Animales2 habría que hacer:

Animales.Assign( Animales2 );

lo cual elimina todos los elementos de la lista Animales e inserta todos los de Animales2.

LISTAS ORDENADAS AUTOMÁTICAMENTE

Anteriormente vimos como una lista podía ordenarse con el método Sort, pero resulta algo molesto y lento tener que volver a ordenar la lista cada vez que se inserta, modifica o elimina un elemento de la misma. Para evitar eso los objetos StringList disponen de la propiedad booleana Sorted la cual una vez esta activa ordenará todos los elementos de la lista automáticamente independientemente de las operaciones que se realicen en la misma.

Vamos a crear una nueva lista ordenada:

var
  Vehiculos: TStringList;
begin
  Vehiculos := TStringList.Create;
  Vehiculos.Sorted := True;
  Vehiculos.Add( 'RENAULT' );
  Vehiculos.Add( 'PEUGEOT' );
  Vehiculos.Add( 'MERCEDES' );
  Memo.Lines.Add( Vehiculos.Text );
  Vehiculos.Free;
end;

Al ejecutar este código mostrará en el campo Memo los elemento ya ordenados:

MERCEDES
PEUGEOT
RENAULT

Tanto si insertamos o eliminamos elementos, la lista seguirá ordenada:

Vehiculos.Delete( 3 );
Vehiculos.Add( 'BMW' );

Quedaría se la siguiente manera:

BMW
MERCEDES
PEUGEOT

Lo que no se puede hacer en una lista ordenada es modificar sus elementos:

Vehiculos[1] := 'AUDI';

Ya que provocaría el error:

Operation not allowed on sorted list (operación no permitida en una lista ordenada).

Para ello habría que desconectar la propiedad Sorted, modificar el elemento y volver a activarla:

  Vehiculos.Sorted := False;
  Vehiculos[1] := 'AUDI';
  Vehiculos.Sorted := True;

Ahora si tendríamos el efecto deseado:

AUDI
BMW
PEUGEOT

Otra de las operaciones que no se pueden hacer en una lista ordenada es añadir elementos duplicados. En el caso anterior si hacemos:

Vehiculos.Add( 'BMW' )

no hará absolutamente nada. Para poder añadir elementos duplicados en una lista ordenada hay que modificar la propiedad Duplicates la cual puede contener los siguientes valores:

dupIgnore -> Ignora el añadir elementos duplicados (así es como está por defecto)
dupAccept -> Acepta elementos duplicados
dupError -> Da un error al añadir elementos duplicados

Si hacemos lo siguiente:

Vehiculos.Duplicates := dupAccept;
Vehiculos.Add( 'BMW' );

Entonces si funcionará correctamente:

AUDI
BMW
BMW
PEUGEOT

Pero si activamos:

Vehiculos.Duplicates := dupError;
Vehiculos.Add( 'BMW' );

Nos mostrará el mensaje:

String list does not allow duplicates (StringList no acepta duplicados).

ASOCIANDO OBJETOS A LOS ELEMENTOS DE UNA LISTA

Una de las características más importantes de una lista TStringList es la de asociar a cada elemento de la lista la instacia de un objeto creado. Vamos a ver un ejemplo donde voy a crear la clase TProveedor y voy a utilizarla para crear una lista de proveedores donde cada elemento tiene su propio objeto:

type
  TProveedor = class
    sNombre: String;
    cSaldo: Currency;
    bPagado: Boolean;
  end;

var
  Proveedores: TStringList;
  Proveedor: TProveedor;
begin
  Proveedores := TStringList.Create;

  Proveedor := TProveedor.Create;
  with Proveedor do
  begin
    sNombre := 'SUMINISTROS PALAZÓN';
    cSaldo := 1200.24;
    bPagado := False;
  end;

  Proveedores.AddObject( 'B78234539', Proveedor );

  Proveedor := TProveedor.Create;
  with Proveedor do
  begin
    sNombre := 'ELECTRIDAUTON, S.L.';
    cSaldo := 2460.32;
    bPagado := True;
  end;

  Proveedores.AddObject( 'B98654782', Proveedor );

  Proveedor := TProveedor.Create;
  with Proveedor do
  begin
    sNombre := 'FONTANERIA MARTINEZ, S.L.';
    cSaldo := 4800.54;
    bPagado := False;
  end;

  Proveedores.AddObject( 'B54987374', Proveedor );
end;

Hemos creado una lista de proveedores e instanciado tres proveedores asociandolos a la lista mediante el C.I.F. del proveedor. Ahora bien, ¿como accedemos a cada proveedore de la lista? Pues muy fácil. El objeto StringList dispone de la propiedad Objects la cual nos devuelve la referencia a un objeto en cuestión. Por ejemplo vamos a buscar a FONTANERIA MARTINEZ por su C.I.F.:

var
  iProveedor: Integer;
begin
  iProveedor := Proveedores.IndexOf( 'B54987374' );

  if iProveedor > -1  then
  begin
    Proveedor := Proveedores.Objects[iProveedor] as TProveedor;
    Memo.Lines.Add( '' );
    Memo.Lines.Add( 'BUSCANDO AL PROVEEDOR: B54987374' );
    Memo.Lines.Add( '' );
    Memo.Lines.Add( 'NOMBRE: ' + Proveedor.sNombre );
    Memo.Lines.Add( 'SALDO: ' + CurrToStr( Proveedor.cSaldo ) );
    Memo.Lines.Add( 'PAGADO: ' + BoolToStr( Proveedor.bPagado, True ) );
  end;
end;

El resultado sería:

BUSCANDO AL PROVEEDOR: B54987374

NOMBRE: FONTANERIA MARTINEZ, S.L.
SALDO: 4800,54
PAGADO: False

Esto es algo mucho más útil que utilizar un array:

var
  Proveedores: array of TProveedor;
  ....

ya que es mucho más flexible y no hay que preocuparse por los huecos al añadir o eliminar registros. Esto nos permite volcar información de registros de la base de datos a memoria mapeando el contenido de un registro (Clientes, Facturas, etc) dentro de su clase correspondiente (Por ejemplo: se podrían cargar una cantidad indeterminada de albaranes del mismo cliente para sumarlos y pasarlos a factura).

Para añadir objetos a un StringList aparte de la función AddObject se pueden insertar objetos mediante el procedimiento:

procedure InsertObject( Index: Integer; const S: string; AObject: TObject ); override;

el cual inserta el elemento en la posición que deseemos desplazando el resto de la lista. Otra de las ventajas de asociar objetos a un StringList en vez de utilizar un array es que al liberarlo de memoria también elimina cada instancia de objeto asociado a cada elemento de la lista:

Proveedores.Free;

no teniendo así que preocuparnos con errores de liberación de memoria.

Con esto terminados de vez las características más importantes de la clase TStringList.

Pruebas realizadas en Delphi 7.

El objeto StringList (II)

Vamos a seguir viendo las características de la clase TStringList.

ELIMINANDO ELEMENTOS DE LA LISTA

Con el método Delete se elimina un elementos de la lista la cual vuelve a reagrupar sus elemento asignando un nuevo índice. Actualmente la lista de clientes contiene:

CARLOS ABENZA MARTINEZ
PASCUAL CAMPOY FERNANDEZ
MARIA PALAZÓN PÉREZ
PEDRO SANCHEZ GARCIA
ROSA GUILLÉN LUNA
LUIS GARCIA ROJO
MANUEL ESCUDERO BERNAL

Vamos a eliminar a ROSA de la lista:

Clientes.Delete( 4 );

Ahora el cliente LUIS tiene un índice de 4 (en vez de 5 como antes), es decir, al contrario de un array dinámico, si en un objeto StringList se elimina un elemento de la lista no queda ningún hueco, ya que vuelven a agruparse sus elementos.

Un error común para eliminar todos los elementos de la lista sería hacer lo siguiente:

var
  i: Integer;
begin
  for i := 0 to Clientes.Count - 1 do
    Clientes.Delete( i );
end;

Nos daría el error:

List index out of bounds(3)

¿Por qué ocurre esto? Pues por la sencilla razón de que cada que se elimina un elemento, al reagruparse el resto de los elementos se va también disminuyendo el número de los mismos y sus índices, con lo cual cuando intenta acceder a un elemento que ya no existe provoca un error. La manera correcta de hacerlo sería:

var
  i: Integer;
begin
  for i := 0 to Clientes.Count - 1 do
    Clientes.Delete( 0 );
end;

Como vemos arriba se elimina sólo el primer elemento y como se van eliminando como si fuera una pila de platos al final desaparecen todos. Naturalmente una clase StringList dispone del método Clear que elimina todos los elementos de la lista:

Clientes.Clear;

MOVIENDO ELEMENTOS EN LA LISTA

Supongamos que tenemos la anterior lista de clientes:

CARLOS ABENZA MARTINEZ
PASCUAL CAMPOY FERNANDEZ
MARIA PALAZÓN PÉREZ
PEDRO SANCHEZ GARCIA
LUIS GARCIA ROJO
MANUEL ESCUDERO BERNAL

Vamos a mover a MARIA a la primera posición de la lista:

Clientes.Move( 2, 0 );

El comando Move acepta como primer parámetro en que posición esta el elemento que deseamos mover y como segundo parámetro su destino. En el caso anterior llevamos a MARIA de la posición 2 a la 0:

MARIA PALAZÓN PÉREZ
CARLOS ABENZA MARTINEZ
PASCUAL CAMPOY FERNANDEZ
PEDRO SANCHEZ GARCIA
LUIS GARCIA ROJO
MANUEL ESCUDERO BERNAL

Ahora bien, no hay que confundirse el mover elementos en la lista con intercambiarlos. El mover un elemento sólo lo elimina de la posición actual y lo lleva a la posición deseada, pero mantiene el orden natural de la lista. Si lo que queremos es intercambiar dos elementos para ello disponemos del método Exchange el cual tiene los mismos parámetros que Move salvo que lo que hace es intercambiar las posiciones de ambos elementos.

Vamos a ver como cambiar la posición de MANUEL (que es la 5) con la de CARLOS (que es la 1):

Clientes.Exchange( 5, 1 );

Su resultado sería:

MARIA PALAZÓN PÉREZ
MANUEL ESCUDERO BERNAL
PASCUAL CAMPOY FERNANDEZ
PEDRO SANCHEZ GARCIA
LUIS GARCIA ROJO
CARLOS ABENZA MARTINEZ

BUSCANDO ELEMENTOS EN LA LISTA

Se puede averiguar la posición de un elemento en la lista con con los métodos IndexOf e IndexOfName:

function IndexOf( const S: string ): Integer; override;
function IndexOfName(const Name: string): Integer; virtual;

El método IndexOf toma como parámetro el nombre del elemento que se desea buscar y devuelve su índice si lo encuentra (el primer elemento es el cero) y -1 si no lo encuentra. Por ejemplo:

Clientes.IndexOf( 'PEDRO SANCHEZ GARCIA' ) devuelve 3
Clientes.IndexOf( 'PEDRO SANCHEZ' ) devuelve -1

La función IndexOf sólo busca el primer elemento encontrado en la lista, de modo que si hay dos elementos iguales sólo muestra el índice del primero (de ahí la importancia de tener la lista ordenada).

Después tenemos la función IndexOfName destinada a buscar elementos de tipo NOMBRE = VALOR como vimos anteriormente con el diccionario:

Diccionario.IndexOfName( 'BOOK' )  devuelve 0
Diccionario.IndexOfName( 'MOUSE' ) devuelve 1
Diccionario.IndexOfName( 'TABLE' ) devuelve 2

Por último tenemos la función Find utilizada para buscar elementos sólo si la lista esta ordenada. Por ejemplo:

var
  iPosicion: Integer;
  bEncontrado: Boolean;
begin
  Clientes.Sort; // ordenamos la lista
  bEncontrado := Clientes.Find( 'PEDRO SANCHEZ GARCIA', iPosicion );
end;

La función Find es similar a función IndexOf añadiendo como segundo parámetro una variable donde depositar la posición del elemento buscado y cuyo valor devuelto en la función será True o False dependiendo si ha encontrado el elemento en la lista.

Después de ejecutar este código la lista quedaría de la siguiente manera:

CARLOS ABENZA MARTINEZ
LUIS GARCIA ROJO
MANUEL ESCUDERO BERNAL
MARIA PALAZÓN PÉREZ
PASCUAL CAMPOY FERNANDEZ
PEDRO SANCHEZ GARCIA

La variable bEncontrado valdría True y iPosicion sería igual a 5.

En el próximo artículo terminaremos de ver todas las funcionalidades de un StringList.

Pruebas realizadas en Delphi 7.

El objeto StringList (I)

Un objeto de la clase TStringList es muy útil para procesar listas de cadenas de texto en memoria. Cada elemento de la lista puede ordenarse, insertar nuevos elementos, eliminar otros, etc.

La lista pueder ser construida de vacío o bien se pueden cargar los elementos desde un archivo de texto separando cada elemento por comas.

La clase TStringList hereda de la clase TStrings, aunque no se recomienda esta última por ser algo incompleta.

CREANDO UNA LISTA

Veamos un sencillo ejemplo para crear una lista de clientes:

var Clientes: TStringList;
begin
  Clientes := TStringList.Create;
  Clientes.Add( 'PEDRO SANCHEZ GARCIA' );
  Clientes.Add( 'MARIA PALAZÓN PÉREZ' );
  Clientes.Add( 'CARLOS ABENZA MARTINEZ' );
  Clientes.Add( 'ANA GONZALEZ RUIZ' );
end;

ACCEDIENDO A LOS ELEMENTOS DE LA LISTA

A los elementos de la lista se accede como si fuera un array dinámico (el primer elemento es el 0). Si escribimos:

ShowMessage( Clientes[2] );

nos mostrará CARLOS ABENZA MARTINEZ.

En cualquier momento se puede modificar un elemento de la lista:

Clientes[3] := 'ROSA GUILLÉN LUNA';

Se puede recorrer cada elemento y mostrarlo en un campo Memo:

var
  i: Integer;
begin
  for i := 0 to Clientes.Count - 1 do
    Memo.Lines.Add( Clientes[i] );
end;

Como muestra arriba se puede averiguar el número de elementos de la lista mediante la propiedad Count. Aunque hay una manera mucho más fácil de mostrar los elementos. Un objeto StringList dispone de la propiedad Text que nos devuelve todos los elementos de la lista separados en líneas. Por ejemplo:

ShowMessage( Clientes.Text ) nos devuelve:

  PEDRO SANCHEZ GARCIA
  MARIA PALAZÓN PÉREZ
  CARLOS ABENZA MARTINEZ
  ROSA GUILLÉN LUNA

También podemos obtener cada elemento separado por comas:

ShowMessage( Clientes.CommaText ) nos devuelve:

"PEDRO SANCHEZ GARCIA","MARIA PALAZÓN PÉREZ","CARLOS ABENZA MARTINEZ","ROSA GUILLÉN LUNA"

Nos ha devuelto el resultado separando cada elemento con comas además de encerrar cada uno con comillas dobles. Si nos interesa cambiar las comillas dobles por comillas simples, un StringList dispone de la propiedad QuoteChar la cual define el carácter delimitador de la cadena. Después solo hay que consultar el resultado mediante el valor DelimitedText en lugar de Text:

  Clientes.QuoteChar := '''';  // o también Clientes.QuoteChar := #39;
  ShowMessage( Clientes.DelimitedText );

El resultado sería:

'PEDRO SANCHEZ GARCIA','MARIA PALAZÓN PÉREZ','CARLOS ABENZA MARTINEZ','ROSA GUILLÉN LUNA'

Y por supuesto se puede cambiar el separador de los elementos de la lista (la coma):

  Clientes.Delimiter := '-';
  ShowMessage( Clientes.DelimitedText );

Lo cual mostraría:

'PEDRO SANCHEZ GARCIA'-'MARIA PALAZÓN PÉREZ'-'CARLOS ABENZA MARTINEZ'-'ROSA GUILLÉN LUNA'

ALMACENANDO VALORES DOBLES

Otra característica que hace extremadamente potente a los StringList es la posibilidad de almacenar valores dobles, es decir, cada elemento de la lista puede contener un nombre y un valor a la vez. Veamos un ejemplo:

var
  Diccionario: TStringList;
begin
  Diccionario := TStringList.Create;
  Diccionario.CommaText := 'BOOK=LIBRO, MOUSE=RATON, TABLE=MESA';
  Memo.Lines.Add( 'BOOK = ' + Diccionario.Values['BOOK'] );
  Memo.Lines.Add( 'MOUSE = ' +Diccionario.Values['MOUSE'] );
  Memo.Lines.Add( 'TABLE = ' +Diccionario.Values['TABLE'] );
  Diccionario.Free;
end;

El resultado que nos mostraría dentro del campo Memo sería:

  BOOK = LIBRO
  MOUSE = RATON
  TABLE = MESA

Se podría también utilizar para almacenar un registro de una base de datos en memoria antes de ejecutar la SQL:

var
  Tabla: TStringList;
begin
  Tabla := TStringList.Create;
  Tabla.CommaText := 'ID=1, NOMBRE=CARLOS, DNI=65872841R, SALDO=130.25';
  Memo.Lines.Add( 'ID = ' + Tabla.Values['ID'] );
  Memo.Lines.Add( 'NOMBRE = ' + Tabla.Values['NOMBRE'] );
  Memo.Lines.Add( 'DNI = ' +Tabla.Values['DNI'] );
  Memo.Lines.Add( 'SALDO = ' + Tabla.Values['SALDO'] );
  Tabla.Free;
end;

Su resultado sería:

  ID = 1
  NOMBRE = CARLOS
  DNI = 65872841R
  SALDO = 130.25

OPERACIONES QUE SE PUEDEN REALIZAR DENTRO DE UNA LISTA

Una de las operaciones más básicas de una lista es la ordenación mediante el comando Sort:

  Clientes.Sort;
  Memo.Lines.Add( Clientes.Text );

La lista quedaría de la siguiente manera:

  CARLOS ABENZA MARTINEZ
  MARIA PALAZÓN PÉREZ
  PEDRO SANCHEZ GARCIA
  ROSA GUILLÉN LUNA

Para añadir elementos hemos visto el comando Add:

Clientes.Add( 'LUIS GARCIA ROJO' );

También se puede utilizar el comando Append:

Clientes.Append( 'MANUEL ESCUDERO BERNAL' );

La diferencia esta en que Add devuelve la posición donde se ha insertado el elemento, en cambio Append no devuelve nada. La lista quedaría de la siguiente manera:

CARLOS ABENZA MARTINEZ
MARIA PALAZÓN PÉREZ
PEDRO SANCHEZ GARCIA
ROSA GUILLÉN LUNA
LUIS GARCIA ROJO
MANUEL ESCUDERO BERNAL

Para añadir elementos a la lista también disponemos del comando Insert el cual toma como primer parámetro en que posición de la lista deseamos insertar el elemento y como segundo parámetro el elemento en cuestión. Por ejemplo vamos a introducir un cliente entre CARLOS y MARIA:

Clientes.Insert( 1, 'PASCUAL CAMPOY FERNANDEZ' );

Y la lista quedaría así:

CARLOS ABENZA MARTINEZ
PASCUAL CAMPOY FERNANDEZ
MARIA PALAZÓN PÉREZ
PEDRO SANCHEZ GARCIA
ROSA GUILLÉN LUNA
LUIS GARCIA ROJO
MANUEL ESCUDERO BERNAL

En el próximo artículo seguiremos viendo más cosas que se pueden hacer con un StringList.

Pruebas realizadas en Delphi 7.

Operaciones con cadenas de texto (y V)

Aquí finalizamos con las funciones de manipulación de cadenas de texto:

procedure SetLength( var S; NewLength: Integer );

Establece el tamaño de una cadena de texto o un array dinámico. Por ejemplo:

var
  sTexto: String;
begin
  sTexto := '123456789';
  SetLength( sTexto, 4 );
end;

Después de ejecutar esto sTexto será igual a 1234 (hemos recortado la cadena).

También se utiliza para establecer el tamaño de un array dinámico antes de utilizarlo.

var
  Valores: array of Integer;
begin
  SetLength( Valores, 3 );
  Valores[0] := 10;
  Valores[1] := 20;
  Valores[2] := 30;

  // Ampliamos el tamaño del array
  SetLength( Valores, 5 );
  Valores[3] := 40;
  Valores[4] := 50;
end;

procedure SetString( var S: string; Buffer: PChar; len: Integer );

El procedimiento SetString fija la longitud de la cadena S antes de copiar el número de caracteres determinado por len de la cadena Buffer. Vamos a ver un ejemplo que copia el contenido de un array de caracteres a un string:

var
  Original: array[1..3] of char;
  sDestino: String
begin
  Original[1] := 'A';
  Original[2] := 'B';
  Original[3] := 'C';
  SetString( sDestino, PChar( Addr( Original ) ), 3 );
end;

Ahora la variable sDestino vale 'ABC'.

function StringOfChar( Ch: Char; Count: Integer ): string;

Esta función devuelve una nueva cadena de texto creada con el carácter Ch y repetido tantas veces como determine el parámetro Count. Por ejemplo:

  StringOfChar( '0', 5 ) devuelve 00000
  StringOfChar( 'A', 6 ) devuelve AAAAAA

Esta función viene bien para completar con ceros por la derecha o por la izquierda los números que se pasan a formato texto.

function StringReplace( const S, OldPattern, NewPattern: string; Flags: TReplaceFlags ): string;

Esta función devuelve una cadena de texto reemplazando las subcadenas encontradas dentro de la cadena S que coincidan con OldPattern y serán sustituidas por la cadena NewPattern. Los valores del parámetro Flags pueden ser:

rfReplaceAll: reemplaza todas las cadenas encontradas
rfIgnoreCase: no distingue mayúsculas de minúsculas

Por ejemplo:

StringReplace( 'CAMBIANDO-EL-TEXTO', '-', '.', [] ) devuelve:

  CAMBIANDO.EL-TEXTO

StringReplace( 'CAMBIANDO-EL-TEXTO', '-', '.', [rfReplaceAll] ) devuelve:

  CAMBIANDO.EL.TEXTO

StringReplace( 'CAMBIANDO EL TEXTO', 'EL', 'mi', [rfReplaceAll,rfIgnoreCase] ) devuelve:

  CAMBIANDO mi TEXTO

StringReplace( 'CAMBIANDO EL TEXTO', 'EL', 'mi', [rfReplaceAll] ) devuelve:

  CAMBIANDO mi TEXTO

StringReplace( 'cambiando el texto', 'EL', 'mi', [rfReplaceAll] ) devuelve:

  cambiando el texto

StringReplace( 'cambiando el texto', 'EL', 'mi', [rfReplaceAll,rfIgnoreCase] ) devuelve:

  cambiando mi texto

function StrScan( const Str: PChar; Chr: Char ): PChar;

Devuelve un puntero al primer carácter que encuentre dentro de la cadena Str. Por ejemplo:

StrScan( 'BUSCANDO UN CARÁCTER', 'T' ) devuelve TER
StrScan( 'BUSCANDO UN CARÁCTER', 'U' ) devuelve USCANDO UN CARÁCTER

function StuffString( const AText: string; AStart, ALength: Cardinal; const ASubText: string ): string;

Esta función devuelve la cadena AText insertando dentro de la misma ASubText en la posición AStart y con la longitud ALength (aunque realmente no inserta sino que es una sustitución del texto que hay en esa misma posición). Veamos un ejemplo:

StuffString( 'INSERTANDO UN TEXTO EN UNA CADENA', 12, 2, 'EL' ) devuelve:

  INSERTANDO EL TEXTO EN UNA CADENA

StuffString( 'INSERTANDO UN TEXTO EN UNA CADENA', 12, 15, 'UNA' ) devuelve:

  INSERTANDO UNA CADENA

Si nos fijamos en el segundo ejemplo hemos sustituido UN TEXTO EN UNA por UNA (15 caracteres).

function Trim( const S: string ): string; overload;
function Trim( const S: WideString ): WideString; overload;

La función Trim devuelve la cadena S eliminando los espacios en blanco y los caracteres de control que halla a la izquierda y derecha (pero no en medio). Por ejemplo:

  Trim( '  ESTO ES UNA PRUEBA  ' ) devuelve 'ESTO ES UNA PRUEBA'

function TrimLeft( const S: string ): string; overload;
function TrimLeft( const S: WideString ): WideString; overload;

Esta función es similar a Trim salvo que sólo elimina los espacios en blanco y caracteres de control por la izquierda. Por ejemplo:

TrimLeft( '  ESTO ES UNA PRUEBA  ' ) devuelve 'ESTO ES UNA PRUEBA  '

function TrimRight( const S: string ): string; overload;
function TrimRight( const S: WideString ): WideString; overload;

Esta función es igual a Trim salvo que sólo elimina los espacios en blanco y caracteres de control por la derecha. Por ejemplo:

TrimRight( '  ESTO ES UNA PRUEBA  ' ) devuelve '  ESTO ES UNA PRUEBA'

function UpCase( Ch: Char ): Char;

Convierte un carácter a mayúsculas. Por ejemplo:

UpCase( 'a' ) devuelve A
UpCase( 'ú' ) devuelve ú

Como vemos en el segundo ejemplo no funciona correctamente con caracteres Ansi. Mejor utilizar en su lugar la función AnsiUpperCase.

function UpperCase( const S: string ): string;

Convierte la cadena S a mayúsculas. Por ejemplo:

UpperCase( 'Hola' ) devuelve HOLA
UpperCase( 'Programación en Delphi' ) devuelve PROGRAMACIóN EN DELPHI

El segundo ejemplo no respeta las vocales con tilde. Mejor utilizar AnsiUpperCase.

function WrapText( const Line, BreakStr: string; nBreakChars: TSysCharSet; MaxCol: Integer ):string; overload;
function WrapText( const Line, MaxCol: Integer = 45 ):string; overload;

La función WrapText parte la cadena Line en múltiples líneas de texto separadas por defecto con los caracteres de control #13 y #10, en tamaños máximos de palabra definidos por MaxCol. Veamos algunos ejemplos:

WrapText( 'Partiendo una cadena de texto', 15 ) devuelve

  Partiendo una
  cadena de texto

WrapText( 'Partiendo una cadena de texto', 10 ) devuelve:

  Partiendo
  una
  cadena de
  texto

WrapText( 'Partiendo una cadena de texto', 5 ) devuelve:

  Partiendo
  una
  cadena
  de
  texto

Es decir, parte la cadena en frases cuyo tamaño máximo es definido por MaxCol pero respetando en ancho de cada palabra (aunque se pase del límite). También podemos definir con que caracteres vamos a separar las palabras así como que deseamos de separador. Si quisieramos separar la frase mediante por punto sería de la siguiente manera:

WrapText( 'Partiendo.una.cadena.de.texto', '-', ['.'], 5 ) devuelve

  Partiendo.-una.-cadena.-de.-texto

Hemos definido el separador (quitando #13 y #10) y también le hemos indicado el carácter que divide cada palabra (el punto).

Con esto finalizan las funciones de manipulación de texto.

Pruebas realizadas en Delphi 7.

Operaciones con cadenas de texto (IV)

Vamos a seguir con las funciones para tratamiento de cadenas de texto:

procedure Delete( var S: string; Index, Count:Integer );

Este procedimiento elimina de la cadena S (pasada por variable) un número de caracteres situados en la posición Index y cuya longitud viene determinada por Count. El primer elemento comienza por 1. Por ejemplo:

var
  sTexto: String;
begin
  sTexto := 'CORTANDO UNA CADENA DE TEXTO';
  Delete( sTexto, 10, 14 );
end;

Ahora la variable sTexto contiene:

CORTANDO TEXTO

porque hemos eliminado UNA CADENA DE.

function DupeString( const AText: string; ACount: Integer ): string;

Esta función devuelve la cadena AText repetida tantas veces como se indique en ACount. Por ejemplo:

DupeString( 'HOLA ', 3 ) devuelve HOLA HOLA HOLA

function High( X );

Devuelve el valor más alto de un tipo de variable. Vamos a ver un ejemplo que utiliza esta función con distintos tipos de variable y muestra el resultado en un Memo:

var
  Numeros: array[1..4] of Integer;
begin
  Memo.Lines.Add( 'High( Char )=' + IntToStr( Ord( High( Char ) ) ) );
  Memo.Lines.Add( 'High( Integer )=' + IntToStr( High( Integer ) ) );
  Memo.Lines.Add( 'High( Word )=' + IntToStr( High( Word ) ) );
  Memo.Lines.Add( 'High( DWord )=' + IntToStr( High( DWord ) ) );
  Memo.Lines.Add( 'High( Boolean )=' + BoolToStr( High( Boolean ), True ) );
  Numeros[1] := 13;
  Numeros[2] := 6;
  Numeros[3] := 16;
  Numeros[4] := 5;
  Memo.Lines.Add( 'High( Numeros )=' + IntToStr( High( Numeros ) ) );
end;

El resultado que muestra sería:

  High( Char )=255
  High( Integer )=2147483647
  High( Word )=65535
  High( DWord )=4294967295
  High( Boolean )=True
  High( Numeros )=4

Como vemos en el último caso, nos devuelve el último índice del del array Numeros.

procedure Insert( Source: string; var S: string; Index: Integer );

Este procedimiento inserta dentro de la cadena S (pasada como variable) la cadena Source en la posición Index. Por ejemplo:

var
  sTexto: String;
begin
  sTexto := 'AMPLIANDO TEXTO';
  Insert( ' UNA CADENA DE', sTexto, 10 );
end;

Ahora sTexto contiene:

AMPLIANDO UNA CADENA DE TEXTO

function LastDelimiter( const Delimiters, S: string ): Integer;

Esta función nos devuelve la posición del último delimitador determinado por Delimiters que encuentre en la cadena S. Con unos ejemplos se ve mas claro:

  LastDelimiter( ',', 'PABLO,JUAN,MARIA,MARCOS' ) devuelve 17
  LastDelimiter( '.', '1.2.3.4.5' ) devuelve 8
  LastDelimiter( '-:', 'A:1-B:2-C:3' ) devuelve 10

En el último ejemplo hemos utilizado dos delimitadores. Esta función sería muy interesante para crear un parser de código fuente HTML buscando delimitadores <>.

function Length( S ): Integer;

Devuelve la longitud máxima de una cadena de texto o de un array. Por ejemplo:

var
  Valores: array of Integer;
begin
  ShowMessage( Length( 'HOLA' ) );
  SetLength( Valores, 3 );
  ShowMessage( IntToStr( Length( Valores ) );
end;

Los comandos ShowMessage nos mostraría los valores 4 para la cadena HOLA y el valor 3, que es la longitud del array dinámico.

function LowerCase( const S: string ): string;

Convierte los caracteres de la cadena S a minúsculas. Se recomenda utilizar en su lugar la función AnsiLowerCase para caracteres internacionales de 8 bits. Por ejemplo:

LowerCase( 'Programando con Delphi' ) devuelve:

  programando con delphi

LowerCase( 'MANIPULANDO CADA CARÁCTER DE LA CADENA' )

  manipulando cada carÁcter de la cadena

Como vemos en este último ejemplo la palabra CARÁCTER ha dejado la Á en mayúsculas. Por ello se recomienda utilizar la función AnsiLowerCase para evitar estas incidencias.

procedure Move( const Source; var Dest; Count: Integer );

Este procedimiento (que debería llamarse quizás Copy) copia la cantidad de bytes Count de Source a la variable Dest. Por ejemplo:

var
  sOrigen, sDestino: String;
begin
  sOrigen  := 'COPIANDO TEXTO';
  sDestino := '--------------';
  Move( sOrigen[10], sDestino[3], 5 );
end;

El valor de la variable destino sería:

 --TEXTO-------

function Pos( Substr: string; S: string ): Integer;

Devuelve la posición de la cadena Substr dentro de la cadena S (Distingue mayúsculas de minúsculas). Si no la encuentra nos devuelve un cero (el primer elemento es el 1). Por ejemplo:

Pos( 'PALABRA', 'BUSCANDO UNA PALABRA' ) devuelve 14
Pos( 'palabra', 'BUSCANDO UNA PALABRA' ) devuelve  0

procedure ProcessPath( const EditText: string; var Drive: Char; var DirPart: string; var FilePart: string );

Este interesante procedimiento divide la cadena EditText la cual se supone que es una ruta como:

C:\Archivos de programa\MSN Messenger\msnmsgr.exe

en unidad, directorio y archivo. Vamos un ejemplo volcando la información en un Memo:

var
  sRuta, sDirectorio, sArchivo: String;
  cUnidad: Char;
begin
  sRuta := 'C:\Archivos de programa\MSN Messenger\msnmsgr.exe';
  ProcessPath( sRuta, cUnidad, sDirectorio, sArchivo );
  Memo.Lines.Add( 'sUnidad=' + cUnidad );
  Memo.Lines.Add( 'sDirectorio=' + sDirectorio );
  Memo.Lines.Add( 'sArchivo=' + sArchivo );
end;

El resultado sería:

sUnidad=C
sDirectorio=\Archivos de programa\MSN Messenger
sArchivo=msnmsgr.exe

Nota: para que funcione esta función la ruta que le pasemos debe ser real, en caso contrario da un error.

En el próximo artículo terminaremos con este tipo de funciones.

Pruebas realizadas en Delphi 7.

Operaciones con cadenas de texto (III)

Seguimos con funciones para manejo de cadenas de caracteres:

function AnsiReverseString( const AText: AnsiString ): AnsiString;

Esta función devuelve la cadena AText con los caracteres invertidos (de derecha a izquierda). Por ejemplo:

AnsiReverseString( 'Al revés' ) devuelve:

  séver lA

AnsiReverseString( 'INVIRTIENDO UNA CADENA DE TEXTO' ) devuelve:
 
  OTXET ED ANEDAC ANU ODNEITRIVNI

function AnsiRightStr( const AText: AnsiString; const ACount: Integer ): AnsiString;

Esta función devuelve la parte derecha de la cadena AText según el número de caracteres que le indiquemos en ACount. Por ejemplo:

AnsiRightStr( 'PROGRAMANDO CON DELPHI', 6 )  devuelve DELPHI
AnsiRightStr( 'PROGRAMANDO CON DELPHI', 11 ) devuelve CON DELPHI
AnsiRightStr( 'PROGRAMANDO CON DELPHI', 18 ) devuelve RAMANDO CON DELPHI

function AnsiStartsStr( const ASubText, AText: string ): Boolean;

Devuelve True si la cadena ASubText está al comienzo de la cadena AText (distingue mayúsculas y minúsculas). Veamos como funciona:

AnsiStartsStr( 'C:\', 'C:\Mis documentos\' ) devuelve True
AnsiStartsStr( 'c:\', 'C:\Mis documentos\' ) devuelve False

function AnsiStartsText( const ASubText, AText: string ): Boolean;

Esta función es igual a AnsiStartsStr salvo que no distingue mayúsculas de minúsculas. En el caso anterior:

AnsiStartsText( 'C:\', 'C:\Mis documentos\' ) devuelve True
AnsiStartsText( 'c:\', 'C:\Mis documentos\' ) devuelve True

function AnsiUpperCase( const S: string ): string;

Devuelve la cadena S convertida toda en mayúsculas. Veamos un par de ejemplos:

AnsiUpperCase( 'Programando con Delphi' ) devuelve:

  PROGRAMANDO CON DELPHI

AnsiUpperCase( 'manipulando cada carácter de la cadena' ) devuelve:

  MANIPULANDO CADA CARÁCTER DE LA CADENA

procedure AppendStr( var Dest: string; const S: string ); deprecated;

Este procedimiento esta obsoleto. Añade a la cadena Dest el contenido dela cadena S. Utilizar en su lugar el operador + o la función Contat.

function CompareStr( const S1, S2: string ): Integer;

Compara las cadenas de texto S1 y S2 y devuelve cero si son iguales. Si son distintas devuelve un número positivo o negativo según la diferencia de caracteres. La operación de diferencia de caracteres se realiza a nivel de cada carácter utilizando su valor equivalente en ASCII. Por ejemplo:

CompareStr( 'HOLA', 'HOLA' ) devuelve   0
CompareStr( 'HOLA', 'HOLa' ) devuelve -32
CompareStr( 'HOLa', 'HOLA' ) devuelve  32
CompareStr( 'HOLA', 'HOYA' ) devuelve -13

Esta función esta obsoleta. Se recomienda utilizar AnsiCompareStr en su lugar.

function CompareText( const S1, S2: string ): Integer;

Similar a la función CompareStr pero sin tener en cuenta mayúsculas y minúsculas. Según el ejemplo anterior:

CompareText( 'HOLA', 'HOLA' ) devuelve   0
CompareText( 'HOLA', 'HOLa' ) devuelve   0
CompareText( 'HOLa', 'HOLA' ) devuelve   0
CompareText( 'HOLA', 'HOYA' ) devuelve -13

Esta función esta obsoleta. Se recomienda utilizar AnsiCompareText en su lugar.

function Concat( s1 [, s2,..., sn]: string ): string;

Esta función devuelve concatenadas un número indeterminado de cadenas de texto que le pasemos como parámetro, aunque se recomienda utilizar el operador + en su lugar. Veamos un ejemplo:

Concat( '12', '34', '56', '78' ) devuelve 12345678
Concat( 'COMO', ' ESTÁN', ' USTEDES' ) devuelve COMO ESTÁN USTEDES

function Copy( S; Index, Count: Integer ): string;
function Copy( S; Index, Count: Integer ): array;

Ambas funciones devuelven una subcadena de la cadena S en la posición Index (el primer elemento es 1) y con una longitud de Count. Por ejemplo:

Copy( '123456', 1, 3 ) devuelve 123
Copy( '123456', 4, 2 ) devuelve 45
Copy( 'CAPTURANDO UNA PALABRA', 16, 7 ) devuelve PALABRA

También puede utilizarse para copiar elementos entre arrays de cualquier tipo. Por ejemplo vamos a crear un array de enteros y vamos a copiar una parte del mismo a otro:

var Origen, Destino: array of Integer;
    i: Integer;
begin
  SetLength( Origen, 6 );
  Origen[0] := 10;
  Origen[1] := 20;
  Origen[2] := 30;
  Origen[3] := 40;
  Origen[4] := 50;
  Origen[5] := 60;
  Destino := Copy( Origen, 2, 4 );
  for i := 0 to Length( Destino ) - 1 do
    Memo.Lines.Add( Format( 'Destino[%d]=%d', [i,Destino[i]] ) );
end;

El resultado lo hemos volcado a pantalla dentro de un campo Memo mostrando lo siguiente:

Destino[0]=30
Destino[1]=40
Destino[2]=50
Destino[3]=60

En el próximo artículo seguiremos con más funciones.

Pruebas realizadas en Delphi 7.

Operaciones con cadenas de texto (II)

Continuamos viendo funciones para manejo de cadenas de caracteres:

function AnsiIndexStr( const AText: string; const AValues: array of string ): Integer;

Esta función comprueba si alguna de las cadenas contenidas en el array AValues coincide extactamente con la cadena AText (distingue mayúsculas y minúsculas). Si la encuentra nos devuelve el número de índice del array donde se encuentra (empieza por cero), en caso contrario nos devuelve -1. Por ejemplo:

AnsiIndexStr( 'JUAN', ['CARLOS','PABLO','JUAN','ROSA'] ) devuelve  2
AnsiIndexStr( 'JUAN', ['CARLOS','PABLO','Juan','ROSA'] ) devuelve -1

Como vemos en el primer ejemplo nos dice que JUAN se encuentra en la posición 2 del array. Sin embargo en el sedungo ejemplo devuelve -1 porque JUAN es distinto de Juan.

function AnsiIndexText( const AText: string; const AValues: array of string ): Integer;

Funciona exactamente igual que la función AnsiIndexStr salvo que no distingue mayúsculas y minúsculas. Según el ejemplo anterior ambas llamadas a la función devuelven idéntico resultado:

AnsiIndexText( 'JUAN', ['CARLOS','PABLO','JUAN','ROSA'] ) devuelve 2
AnsiIndexText( 'JUAN', ['CARLOS','PABLO','Juan','ROSA'] ) devuelve 2

function AnsiLeftStr( const AText: AnsiString; const ACount: Integer ): AnsiString;

Esta función devuelve la parte izquierda de la cadena AText según el número de caracteres que le indiquemos en ACount. Sería algo así:

AnsiLeftStr( 'PROGRAMANDO CON DELPHI', 6 )  devuelve PROGRA
AnsiLeftStr( 'PROGRAMANDO CON DELPHI', 11 ) devuelve PROGRAMANDO
AnsiLeftStr( 'PROGRAMANDO CON DELPHI', 18 ) devuelve PROGRAMANDO CON DE

function AnsiLowerCase( const S: string ): string;

Devuelve la cadena S convertida toda en minúsculas (si tiene letras, naturalmente). Veamos un par de ejemplos:

AnsiLowerCase( 'Programando con Delphi' ) devuelve:

  programando con delphi

AnsiLowerCase( 'MANIPULANDO CADA CARÁCTER DE LA CADENA' ) devuelve:
 
  manipulando cada carácter de la cadena

Como vemos nos ha respetado la tílde en la palabra carácter.

function AnsiMatchStr( const AText: string; const AValues: array of string ): Boolean;

Esta función nos dice si alguna de las cadenas contenidas en el array AValues coincide exactamente con la cadena AText (comprobando mayúsculas y minúsculas). Aunque esta función pueda parecer igual a AnsiIndexStr se diferencia en que sólo responde True o False si la encontrado o no, al contrario que AnsiIndexStr que nos devuelve que la posición donde la ha encontrado. Con un ejemplo se ve mas claro:

AnsiMatchStr( 'JUAN', ['CARLOS','PABLO','JUAN','ROSA'] ) devuelve True
AnsiMatchStr( 'JUAN', ['CARLOS','PABLO','Juan','ROSA'] ) devuelve False

Nota: La ayuda de Delphi 7 dice que esta función devuelve un Integer y realmente devuelve un Boolean, será un error de documentación (ya estamos acostumbrados a la 'magnífica' documentación de Borland). En cambio si está corregido en la función:

function AnsiMatchText( const AText: string; const AValues: array of string ): Boolean;

Similar a la función anterior AnsiMatchStr pero sin diferenciar mayúsculas y minúsculas. Siguiendo el mismo ejemplo:

AnsiMatchText( 'JUAN', ['CARLOS','PABLO','JUAN','ROSA'] ) devuelve True
AnsiMatchText( 'JUAN', ['CARLOS','PABLO','Juan','ROSA'] ) devuelve True

function AnsiMidStr( const AText: AnsiString; const AStart, ACount: Integer ): AnsiString;

Devuelve un trozo de la cadena AText cuya posición comienza en AStart (el primer elemento es el 1) y cuyo número de caracteres viene determinado por ACount. Por ejemplo:

AnsiMidStr( 'PROGRAMANDO CON DELPHI', 7, 5 ) devuelve MANDO
AnsiMidStr( 'PROGRAMANDO CON DELPHI', 17, 6 ) devuelve DELPHI

function AnsiPos( const Substr, S: string ): Integer;

Devuelve la posición de la cadena Substr que está dentro de la cadena S. Si no la encuentra devuelve un cero (el primer elemento comienza por 1). También distingue entre mayúsculas y minúsculas. Veamos como funciona:

AnsiPos( 'PALABRA', 'BUSCANDO UNA PALABRA' ) devuelve 14
AnsiPos( 'Palabra', 'BUSCANDO UNA PALABRA' ) devuelve  0

function AnsiReplaceStr( const AText, AFromText, AToText: string ): string;

Esta función nos devuelve la cadena AText reemplazando las palabras que contenga según la variable AFromText sustituyéndolas por AToText. Tiene encuentra mayúsculas y minúsculas:

AnsiReplaceStr( 'CORRIGIENDO TEXTO DENTRO DE UNA FRASE', 'TEXTO', 'UNA PALABRA' ) devuelve:

  CORRIGIENDO UNA PALABRA DENTRO DE UNA FRASE

AnsiReplaceStr( 'CORRIGIENDO TEXTO DENTRO DE UNA FRASE', 'Texto', 'UNA PALABRA' ) devuelve:
 
  CORRIGIENDO TEXTO DENTRO DE UNA FRASE

Como vemos en el segundo ejemplo al no encontrar Texto por contener minúsculas ha dejado la frase como estaba.

function AnsiReplaceText( const AText, AFromText, AToText: string ): string;

Igual a la función AnsiReplaceStr sin distinguir mayúsculas y minúsculas:

AnsireplaceText( 'CORRIGIENDO TEXTO DENTRO DE UNA FRASE', 'TEXTO', 'UNA PALABRA' ) devuelve:

  CORRIGIENDO UNA PALABRA DENTRO DE UNA FRASE

AnsireplaceText( 'CORRIGIENDO TEXTO DENTRO DE UNA FRASE', 'Texto', 'UNA PALABRA' ) devuelve:

  CORRIGIENDO UNA PALABRA DENTRO DE UNA FRASE

El próximo artículo continuará con más funciones de manipulación de texto.

Pruebas realizadas en Delphi 7.

Operaciones con cadenas de texto (I)

Delphi posee un amplio repertorio de funciones para el análisis y manipulación de cadenas de texto que nos harán la vida mucho más fácil una vez las conozcamos. Comencemos con ellas:

function AnsiCompareStr( const S1, S2: string ): Integer;

Esta función compara dos cadenas de texto carácter a carácter y nos dice si son iguales (diferencia mayúsculas y minúsculas). Si ambas cadenas son iguales devuelve un cero. Devolverá un 1 si la cadena S1 es superior a la cadena S2 y devuelve un -1 si la cadena S1 es inferior a la cadena S2. Veamos un ejemplo:

AnsiCompareStr( 'HOLA', 'HOLA' ) devuelve  0
AnsiCompareStr( 'HOLA', 'HOLa' ) devuelve  1
AnsiCompareStr( 'HOLa', 'HOLA' ) devuelve -1

¿Cuando se considera una cadena de texto superior a otra? Pues el orden es el siguiente:

Letras mayúsculas > Letras minúsculas
Letras minúsculas > Números

function AnsiCompareText( const S1, S2: string ): Integer;

Esta función es similar a AnsiCompareStr a diferencia de que no distingue entre mayúsculas y minúsculas. En el caso anterior:

AnsiCompareText( 'HOLA', 'HOLA' )  devuelve 0
AnsiCompareText( 'HOLA', 'HOLa' )  devuelve 0
AnsiCompareText( 'HOLa', 'HOLA' )  devuelve 0
AnsiCompareText( 'HOLA', 'HOLLA' ) devuelve -1
AnsiCompareText( 'HOLLA', 'HOLA' ) devuelve 1

El orden entre cadenas se define por:

Letras > Números

function AnsiContainsStr( const AText, ASubText: string ): Boolean;

Comprueba si la cadena ASubText esta dentro de la cadena AText. Por ejemplo:

AnsiContainsStr( 'DELPHI AL LIMITE', 'LIMITE' ) devuelve True
AnsiContainsStr( 'DELPHI AL LIMITE', 'LIMITe' ) devuelve False

function AnsiContainsText( const AText, ASubText: string ): Boolean;

Esta función es igual a AnsiConstainsStr salvo que no diferencia mayúsculas de minúsculas. Veamos un ejemplo:

AnsiContainsText( 'DELPHI AL LIMITE', 'LIMITE' ) devuelve True
AnsiContainsText( 'DELPHI AL LIMITE', 'LIMITe' ) devuelve True
AnsiContainsText( 'DELPHI AL LIMITE', 'LIMITES' ) devuelve False

function AnsiEndsStr( const ASubText, AText: string ): Boolean;

La función nos devuelve True si la cadena AText termina en la cadena ASubText. He aquí un ejemplo:

AnsiEndsStr( '.avi', 'C:\Archivos de programa\Emule\Incoming\pelicula.avi' ) devuelve True
AnsiEndsStr( '.AVI', 'C:\Archivos de programa\Emule\Incoming\pelicula.avi' ) devuelve False

Para este caso es mejor utilizar la función:

function AnsiEndsText( const ASubText, AText: string ): Boolean;

Esta función obtiene el mismo resultado que AnsiEndsStr pero sin diferenciar mayúsculas de minúsculas. En el caso anterior:

AnsiEndsText( '.avi', 'C:\Archivos de programa\Emule\Incoming\pelicula.avi' ) devuelve True
AnsiEndsText( '.AVI', 'C:\Archivos de programa\Emule\Incoming\pelicula.avi' ) devuelve True

Como vemos es ideal para comprobar extensiones de archivos.

En el próximo artículo seguiremos con muchas más funciones.

Pruebas realizadas en Delphi 7.

Dando formato a los números reales

La unidad SysUtils dispone del tipo TFloatFormat siguiente:

type TFloatFormat = (ffGeneral, ffExponent, ffFixed, ffNumber, ffCurrency);

Este tipo es utilizado por las funciones CurrToStrF, FloatToStrF y FloatToText para dar formato a los números reales que pasen a formato texto. Como hemos visto anteriormente, los posibles valores de TFloatFormat son:

ffGeneral

Define el formato general de un número real acercando el valor resultante tanto como sea posible. Quita los ceros que se arrastran y la coma cuando sea necesario. No muestra ningún separador de miles y utiliza el formato exponencial cuando la mantisa es demasiado grande para el valor especificado según el formato. El formato de la coma es determinado por la variable DecimalSeparator.

Veamos un ejemplo mostrando el resultado en un campo Memo:

var rCantidad: Extended; // Número real para hacer pruebas
begin
  rCantidad := 1234.56;

  Memo.Lines.Add( 'General 4,0 = ' + FloatToStrF( rCantidad, ffGeneral, 4, 0 ) );
  Memo.Lines.Add( 'General 6,0 = ' + FloatToStrF( rCantidad, ffGeneral, 6, 0 ) );
  Memo.Lines.Add( 'General 6,2 = ' + FloatToStrF( rCantidad, ffGeneral, 6, 2 ) );
  Memo.Lines.Add( 'General 3,2 = ' + FloatToStrF( rCantidad, ffGeneral, 3, 2 ) );

El resultado que nos muestra es el siguiente:

  General 4,0 = 1235
  General 6,0 = 1234,56
  General 6,2 = 1234,56
  General 3,2 = 1,23E03

Como vemos la función FloatToStrF toma los siguientes parámetros:

function FloatToStrF(Value: Extended; Format: TFloatFormat; Precision, Digits: Integer): string; overload;

Value es el número real que vamos a pasar a texto.
Format es el tipo de formato en coma flotante que vamos a utilizar (en este caso ffGeneral).
Precision es el número máximo de dígitos enteros que soporta el formato.
Digits es el número máximo de decimales que soporta el formato.

En el caso anterior cuando forzamos a mostrar menos dígitos de precisión de lo que el número real tiene lo que hace la función es recortar o bien decimales o si la cantidad entera es superior al formato lo pasa al formato exponencial.

Veamos el resto de formatos:

ffExponent

Muestra el número real en formato científico cuyo exponente viene representado con la letra E con base 10. Por ejemplo E+15 significa 1015. El carácter de la coma es representado por la variable DecimalSeparator.

Aquí vemos como queda el mismo número en distintos formatos exponenciales:

  Memo.Lines.Add( 'Exponencial 4,0 = ' + FloatToStrF( rCantidad, ffExponent, 4, 0 ) );
  Memo.Lines.Add( 'Exponencial 6,0 = ' + FloatToStrF( rCantidad, ffExponent, 6, 0 ) );
  Memo.Lines.Add( 'Exponencial 6,2 = ' + FloatToStrF( rCantidad, ffExponent, 6, 2 ) );
  Memo.Lines.Add( 'Exponencial 3,2 = ' + FloatToStrF( rCantidad, ffExponent, 3, 2 ) );

cuyo resultado es:

  Exponencial 4,0 = 1,235E+3
  Exponencial 6,0 = 1,23456E+3
  Exponencial 6,2 = 1,23456E+03
  Exponencial 3,2 = 1,23E+03

El formato ffFixed

Este formato no utiliza ningún separador de unidades de millar. Al igual que los formatos anteriores si la precisión del número real es superior al formato entonces muestra el resultado en notación científica. Quedaría de la siguiente manera:

  Memo.Lines.Add( 'Fijo 4,0 = ' + FloatToStrF( rCantidad, ffFixed, 4, 0 ) );
  Memo.Lines.Add( 'Fijo 6,0 = ' + FloatToStrF( rCantidad, ffFixed, 6, 0 ) );
  Memo.Lines.Add( 'Fijo 6,2 = ' + FloatToStrF( rCantidad, ffFixed, 6, 2 ) );
  Memo.Lines.Add( 'Fijo 3,2 = ' + FloatToStrF( rCantidad, ffFixed, 3, 2 ) );

dando los valores:

  Fijo 4,0 = 1235
  Fijo 6,0 = 1235
  Fijo 6,2 = 1234,56
  Fijo 3,2 = 1,23E03

El formato ffNumber

Es igual al formato ffFixed salvo que también incluye el separador de unidades de millar, el cual viene representado por la variable ThousandSeparator. En nuestro ejemplo:

  Memo.Lines.Add( 'Número 4,0 = ' + FloatToStrF( rCantidad, ffNumber, 4, 0 ) );
  Memo.Lines.Add( 'Número 6,0 = ' + FloatToStrF( rCantidad, ffNumber, 6, 0 ) );
  Memo.Lines.Add( 'Número 6,2 = ' + FloatToStrF( rCantidad, ffNumber, 6, 2 ) );
  Memo.Lines.Add( 'Número 3,2 = ' + FloatToStrF( rCantidad, ffNumber, 3, 2 ) );

mostraría:

  Número 4,0 = 1.235
  Número 6,0 = 1.235
  Número 6,2 = 1.234,56
  Número 3,2 = 1,23E03

El formato ffCurrency

Es similar al formato ffNumber pero con un símbolo de secuencia agregado, según se haya definido en la variable CurrencyString. Este formato también esta influenciado por las variables CurrencyFloat y NegCurrFloat. Sigamos el ejemplo:

  Memo.Lines.Add( 'Moneda 4,0 = ' + FloatToStrF( rCantidad, ffCurrency, 4, 0 ) );
  Memo.Lines.Add( 'Moneda 6,0 = ' + FloatToStrF( rCantidad, ffCurrency, 6, 0 ) );
  Memo.Lines.Add( 'Moneda 6,2 = ' + FloatToStrF( rCantidad, ffCurrency, 6, 2 ) );
  Memo.Lines.Add( 'Moneda 3,2 = ' + FloatToStrF( rCantidad, ffCurrency, 3, 2 ) );

Da como resultado:

  Moneda 4,0 = 1.235 €
  Moneda 6,0 = 1.235 €
  Moneda 6,2 = 1.234,56 €
  Moneda 3,2 = 1,23E03

según las variables mencionadas anteriormente que recogen el formato moneda por defecto configurado en Windows.

Pruebas realizadas en Delphi 7.

El tipo Variant

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.

Pruebas realizadas en Delphi 7.

Conversiones entre unidades de medida

Delphi incorpora una librería interesante encargada de realizar conversiones entre unidades de tiempo, volumen, distancia, etc. Para ello hay que añadir las unidades ConvUtils y StdConvs:

uses
  Windows, Messages, ..., ConvUtils, StdConvs;

La función encargada de realizar conversiones es la siguiente:

Convert( ValorAConvertir: Double; DesdeUnidad, HastaUnidad: TConvType): Double;

Veamos algunos ejemplos mostrando el resultado en un campo Memo.
Para convertir de millas a kilómetros:

var dMillas, dKilometros: Double;
begin
  dMillas := 15;
  dKilometros := Convert( dMillas, duMiles, duKilometers );
  Memo.Lines.Add( Format( '%8.4f Millas = %8.4f Kilometros', [dMillas, dKilometros] ) );

Esta otra convierte de pulgadas de área a centímetros de area:

var dPulgadas, dCentimetros: Double;
begin
  dPulgadas := 21;
  dCentimetros := Convert( dPulgadas, auSquareInches, auSquareCentimeters );
  Memo.Lines.Add( Format( '%8.4f Pulgadas de área = %8.4f Centímetros de área', [dPulgadas, dCentimetros] ) );

Y si queremos convertir libras en kilogramos:

var dLibras, dKilos: Double;
begin
  dLibras := 60;
  dKilos := Convert( dLibras, muPounds, muKilograms );
  Memo.Lines.Add( Format( '%8.4f Libras = %8.4f Kilos', [dLibras, dKilos] ) );

También podemos convertir unidades de temperatura:

var dFahrenheit, dCelsius: Double;
begin
  dFahrenheit := 84;
  dCelsius := Convert( dFahrenheit, tuFahrenheit, tuCelsius );
  Memo.Lines.Add( Format( '%8.4fº Fahrenheit = %8.4fº Celsius', [dFahrenheit, dCelsius] ) );

Así como conversión entre unidades de volumen:

var dMetrosCubicos, dLitros: Double;
begin
  dMetrosCubicos := 43;
  dLitros := Convert( dMetrosCubicos, vuCubicMeters, vuLiters );
  Memo.Lines.Add( Format( '%8.4f Metros cúbicos = %8.4fº Litros', [dMetrosCubicos, dLitros] ) );

Ahora vamos a ver todos los tipos de conversión según las unidades de medida.
Para convertir entre unidades de área tenemos:

  auSquareMillimeters
  auSquareCentimeters
  auSquareDecimeters
  auSquareMeters
  auSquareDecameters
  auSquareHectometers
  auSquareKilometers
  auSquareInches
  auSquareFeet
  auSquareYards
  auSquareMiles
  auAcres
  auCentares
  auAres
  auHectares
  auSquareRods

Convertir entre unidades de distancia:

  duMicromicrons
  duAngstroms
  duMillimicrons
  duMicrons
  duMillimeters
  duCentimeters
  duDecimeters
  duMeters
  duDecameters
  duHectometers
  duKilometers
  duMegameters
  duGigameters
  duInches
  duFeet
  duYards
  duMiles
  duNauticalMiles
  duAstronomicalUnits
  duLightYears
  duParsecs
  duCubits
  duFathoms
  duFurlongs
  duHands
  duPaces
  duRods
  duChains
  duLinks
  duPicas
  duPoints

Convertir entre unidades de masa:

  muNanograms
  muMicrograms
  muMilligrams
  muCentigrams
  muDecigrams
  muGrams
  muDecagrams
  muHectograms
  muKilograms
  muMetricTons
  muDrams
  muGrains
  muLongTons
  muTons
  muOunces
  muPounds
  muStones

Convertir entre unidades de temperatura:

  tuCelsius
  tuKelvin
  tuFahrenheit
  tuRankine
  tuReamur

Convertir entre unidades de tiempo:

  tuMilliSeconds
  tuSeconds
  tuMinutes
  tuHours
  tuDays
  tuWeeks
  tuFortnights
  tuMonths
  tuYears
  tuDecades
  tuCenturies
  tuMillennia
  tuDateTime
  tuJulianDate
  tuModifiedJulianDate

Convertir entre unidades de volumen:

  vuCubicMillimeters
  vuCubicCentimeters
  vuCubicDecimeters
  vuCubicMeters
  vuCubicDecameters
  vuCubicHectometers
  vuCubicKilometers
  vuCubicInches
  vuCubicFeet
  vuCubicYards
  vuCubicMiles
  vuMilliLiters
  vuCentiLiters
  vuDeciLiters
  vuLiters
  vuDecaLiters
  vuHectoLiters
  vuKiloLiters
  vuAcreFeet
  vuAcreInches
  vuCords
  vuCordFeet
  vuDecisteres
  vuSteres
  vuDecasteres
  vuFluidGallons
  vuFluidQuarts
  vuFluidPints
  vuFluidCups
  vuFluidGills
  vuFluidOunces
  vuFluidTablespoons
  vuFluidTeaspoons
  vuDryGallons
  vuDryQuarts
  vuDryPints
  vuDryPecks
  vuDryBuckets
  vuDryBushels
  vuUKGallons
  vuUKPottles
  vuUKQuarts
  vuUKPints
  vuUKGills
  vuUKOunces
  vuUKPecks
  vuUKBuckets
  vuUKBushels

Pruebas realizadas en Delphi 7.

Tipos de puntero

Pointer:

- Es un tipo general de puntero hacia cualquier objeto o variable en memoria.
- Al no ser de ningún tipo suele ser bastante peligroso si provoca desbordamientos de memoria.

PAnsiChar:

- Es un tipo de puntero hacia un valor AnsiChar.
- También puede ser utilizado para apuntar a caracteres dentro de una cadena AnsiString.
- Al igual que otros punteros permite la aritmética, es decir, los procedimientos Inc y Dec pueden utilizarse para mover el puntero en memoria.

PAnsiString:

- Apunta hacia una cadena AnsiString.
- Debido a que AnsiString ya es un puntero hacia si misma, el puntero PAnsiString no suele utilizarse mucho.

PChar:

- Es un tipo de puntero hacia un valor Char.
- Puede ser utilizado para apuntar a caracteres dentro de una cadena string.
- Permite aritmética de punteros mediante los procedimientos Inc y Dec.
- Suele utilizarse mucho para procesar cadenas de caracteres terminadas en cero, tal como las utilizadas en el lenguaje C/C++.
- Los caracteres Char son idénticos a los de las variables AnsiChar, siendo de 8 bits de tamaño.

PCurrency:

- Apunta hacia un valor Currency.
- Permite aritmética de punteros mediante los procedimientos Inc y Dec.

PDateTime:

- Apunta hacia un valor TDateTime.
- Permite aritmética de punteros mediante los procedimientos Inc y Dec.

PExtended:

- Apunta hacia un valor Extended.
- Permite aritmética de punteros mediante los procedimientos Inc y Dec.

PInt64:

- Apunta hacia un valor Int64.
- Permite aritmética de punteros mediante los procedimientos Inc y Dec.

PShortString:

- Apunta hacia una cadena ShortString.
- Debido a que las variables ShortString difieren de las variables string,
para apuntar a una variable ShortString es necesario utilizar la función Addr.

PString:

- Apunta hacia una cadena String.
- Al ser la cadena String un puntero en si misma no suele utilizarse mucho este puntero.

PVariant:

- Apunta hacia un valor Variant.
- Al ser Variant un tipo genérico y variable hay que extremar la precaución en el manejo de este puntero.

PWideChar:

- Apunta hacia un valor WideChar.
- Puede ser utilizado para apuntar a caracteres dentro de una cadena WideString.
- Permite aritmética de punteros mediante los procedimientos Inc y Dec.

PWideString:

- Apunta hacia una cadena WideString.
- Al ser ya cadena WideString un puntero en si misma no suele utilizarse mucho.

Pruebas realizadas en Delphi 7.

Tipos de variable para el manejo de caracteres

AnsiChar:

- Permite el almacenamiento de un carácter o un número entero.
- Valores comprendidos entre 0 y 255.
- Gasta un byte de memoria (8 bits).

AnsiString:

- Un tipo de dato que almacena una cadena de caracteres tipo AnsiChar.
- Cada carácter gasta un byte de memoria (8 bits), aunque la longitud de la cadena puede ser ilimitada.
- Al ser su contenido dinámico gastará tantos bytes como caracteres tenga la cadena en ese momento.
- El primer elemento comienza por [1].

ShortString:

- Variable para guardar un simple carácter o un número entero.
- Valores comprendidos entre 0 y 255.
- Al ser su contenido dinámico gastará tantos bytes como caracteres tenga la cadena en ese momento.
- Permite un máximo de 255 caracteres.
- El primer elemento comienza por [1].

String:

- Un tipo de dato que almacena una cadena de caracteres.
- Cuando se crea es tratado como AnsiString.
- La longitud es ilimitada siendo cada carácter de un byte (8 bits).
- El primer elemento comienza por [1].

WideChar:

- Almacena un carácter internacional.
- Puede guardar un carácter o un número entero entre 0 y 65535.
- Gasta 2 bytes de memoria (16 bits).

WideString:

- Un tipo de dato que almacena una cadena de caracteres tipo WideChar.
- Cada carácter gasta 2 bytes de memoria (16 bits), aunque la longitud de la cadena puede ser ilimitada.
- Al ser su contenido dinámico gastará tantos bytes como caracteres tenga la cadena en ese momento.
- El primer elemento comienza por [1].

Pruebas realizadas en Delphi 7.

Los tipos reales en Delphi

Currency:

- Tipo flotante de punto fijo con 4 decimales usado para valores financieros, minimizando así los errores de redondeo (recomendado para programas de gestión).
- Gasta 8 bytes de memoria (64 bits).

Double:

- Tipo flotante de uso general.
- Soporta hasta 15 dígitos de precisión.
- Gasta 8 bytes de memoria (64 bits).

Extended:

- Tipo flotante con alta capacidad y precisión.
- Soporta hasta 19 dígitos de precisión.
- Gasta 10 bytes de memoria (80 bits).

Real:

- Tipo flotante general obsoleto mantenido por compatibilidad hacia atrás (usar Double en su lugar).
- Soporta hasta 15 dígitos de precisión.
- Gasta 8 bytes de memoria (64 bits).

Real48:

- Tipo flotante general obsoleto mantenido por compatibilidad hacia atrás (usar Extended en su lugar).
- Soporta hasta 11 dígitos de precisión.
- Gasta 6 bytes de memoria (48 bits).

Single:

- El tipo flotante que tiene menos capacidad y precisión, aunque es el más rápido de procesar.
- Soporta hasta 7 dígitos de precisión.
- Gasta 4 bytes de memoria (32 bits).

Pruebas realizadas en Delphi 7.

Los tipos enteros en Delphi

Byte:

- Tipo entero que soporta valores entre 0 y 255.
- Gasta un byte de memoria (8 bits).

Cardinal:

- Tipo entero básico sin signo.
- Soporta valores entre 0 y 4294967295.
- Gasta 4 bytes de memoria (32 bits).

Integer:

- Tipo entero con signo.
- Soporta valores entre -2147483648 y 2147483647.
- Gasta 4 bytes de memoria (32 bits)

Int64:

- Tipo entero con signo.
- Alcanza valores desde -9223372036854775808 hasta 9223372036854775807.
- Gasta 8 bytes de memoria (64 bits).

LongInt:

- Tipo entero con signo.
- Valores comprendidos entre -2147483648 y 2147483647.
- Gasta 4 bytes de memoria (32 bits).
- Es un tipo fijo que no cambiará en futuras versiones de Delphi.

LongWord:

- Tipo entero sin signo.
- Valores comprendidos entre 0 y 4294967295.
- Gasta 4 bytes de memoria (32 bits).

DWord:

- Igual que LongWord;

ShortInt:

- Tipo entero con signo.
- Valores comprendidos entre -128 y 127.
- Gasta 1 byte de memoria (8 bits).

SmallInt:

- Tipo entero con signo.
- Valores comprendidos entre -32768 y 32767.
- Gasta 2 bytes de memoria (16 bits).

Word:

- Tipo entero sin signo.
- Valores comprendidos entre 0 y 65535.
- Gasta 2 bytes de memoria (16 bits).

Pruebas realizadas en Delphi 7.

Trabajando con arrays dinámicos

Una de las ventajas de los arrays dinámicos respecto a los estáticos es que pueden modificar su tamaño en tiempo de ejecución y no es necesaria la gestión de memoria para los mismos, ya que se liberan automáticamente al terminar el procedimiento, función o clase donde están alojados. También son ideales para enviar un número indeterminado de parámetros a funciones o procedimientos.

Para crear una array dinámico lo que hacemos es declarar el array pero sin especificar su tamaño:

  public
    Clientes: array of string;

Antes de meter un elemento al array hay que especificar su tamaño con la función SetLength. En este ejemplo creamos tres elementos:

  SetLength( Clientes, 3 );

Y ahora introducimos los datos en el mismo:

  Clientes[0] := 'JUAN';
  Clientes[1] := 'CARLOS';
  Clientes[2] := 'MARIA';

A diferencia de los arrays estáticos el primer elemento es el cero y no
el uno. Como he dicho antes no es necesario liberarlos de memoria, pero
si aún así deseamos hacerlo sólo es necesario hacer lo siguiente:

  Clientes := nil;

con lo cual el array queda inicializado para que pueda volver a ser utilizado.

Pruebas realizadas en Delphi 7.

Clonar las propiedades de un control

Cuantas veces hemos deseado en tiempo de ejecución copiar las características de un control a otro según las acciones del usuario. Por ejemplo si tenemos nuestro propio editor de informes se podrían copiar las carácterísticas de las etiquetas seleccionas por el usuario al resto del formulario (font, color, width, etc.)

Para ello tenemos que añadir la unidad TypInfo:

uses
  Windows, Dialogs, ..., TypInfo;

A esta función que voy a mostrar hay que pasarle el control origen y el destino (la copia) así como que propiedades deseamos copiar:

function ClonarPropiedades( Origen, Destino: TObject;
                            Propiedades: array of string ): Boolean;
var
  i: Integer;
begin
  Result := True;
  try
    for i := Low( Propiedades ) to High( Propiedades ) do
    begin
      // ¿Existe la propiedad en el control origen?
      if not IsPublishedProp( Origen, Propiedades[I] ) then
        Continue;

      // ¿Existe la propiedad en el control destino?
      if not IsPublishedProp( Destino, Propiedades[I] ) then
        Continue;

      // ¿Son del mismo tipo las dos propiedades? 
      if PropType( Origen, Propiedades[I]) <>
        PropType( Destino, Propiedades[I] ) then
        Continue;

      // Copiamos la propiedad según si es variable o método
      case PropType(Origen, Propiedades[i]) of
        tkClass:
          SetObjectProp( Destino, Propiedades[i],
            GetObjectProp( Origen, Propiedades[i] ) );

        tkMethod:
          SetMethodProp( Destino, Propiedades[I],
                         GetMethodProp( Origen, Propiedades[I] ) );
        else
          SetPropValue( Destino, Propiedades[i],
                        GetPropValue( Origen, Propiedades[i] ) );
      end;
    end;
  except
    Result := False;
  end;
end;

Para copiar las características principales de una etiqueta habría que llamar a la función de la siguiente manera:

 ClonarPropiedades( Label1, Label2, ['Font', 'Color', 'Alignment',
                    'Width', 'Height', 'Layout'] );

También se pueden copiar eventos tales como OnClick, OnMouseDown, etc. permitiendo así abarcar muchos controles con un solo evento.

Pruebas realizadas en Delphi 7.