En línea desde el 7 de noviembre de 2000

1. Funciones de manejo de cadenas

En este capítulo vamos a ver varias de las funciones que nos ofrece Delphi para la manipulación de cadenas. Todas las funciones y procedimientos que aquí se mencionan están en la unit System, unit de referencia para quien quiera ampliar conocimientos vía la ayuda de Delphi.

FUNCTION CompareStr(S1, S2: String): Integer;

Realiza una comparación entre las cadenas S1 y S2. Dicha comparación diferencia las mayúsculas de las minúsculas, por lo que la cadena 'Abc' no será la misma que la cadena 'abc'.

La función devuelve 0 si ambas cadenas resultan ser idénticas, un número positivo si la primera cadena (S1) es mayor que la segunda cadena (S2) o un número negativo si la primera cadena es menor que la segunda cadena.

FUNCTION CompareText(S1, S2: String): Integer;

Hace lo mismo que la función anterior, con una pequeña diferencia: no distingue entre mayúsculas y minúsculas, por lo que las cadenas 'Abc' y 'abc' serán iguales para esta función, con lo que nos devolvería el valor 0.

FUNCTION Copy(S: String; Inicio, CuantosCar: Integer): String;

Devuelve una subcadena de la cadena pasada como argumento, S. Toma como posición inicial dentro de S la dada por Inicio, y a partir de ahí toma CuantosCar caracteres. Si Inicio es mayor que la longitud de la cadena, devuelve cadena vacía. Si a partir de Inicio, CuantosCar excede el número de caracteres que haya en la cadena, sólo devuelve hasta el final de la cadena. Vamos a ver algunos ejemplos para terminar de aclararnos:

Tenemos definido, como constante, lo siguiente:

  Cadena = 'Esto_es_una_cadena_larga_para_hacer_pruebas';

Y los siguientes resultados para varias llamadas a Copy:

  Copy(Cadena, 1, 10);                  --> 'Esto_es_un'
  Copy(Cadena, Length(Cadena) + 2, 2);  --> ''
  Copy(Cadena, Length(Cadena) - 3, 5);  --> 'ebas'
  Copy(Cadena, 0, 5);                   --> 'Esto_'

PROCEDURE Delete(VAR S: String; Inicio, CuantosCar: Integer);

Borra de la cadena pasada como argumento los caracteres comprendidos entre la posición inicial dada por el argumento Inicio, y borra CuantosCar. Al igual que con la función Copy, si Inicio es mayor que la longitud de la cadena, no borrará nada, y si a partir de Inicio, CuantosCar excede el número de caracteres que haya en la cadena, sólo borrará hasta el final de la cadena. Vamos a ver también ejemplos. Para ello, supongamos que tenemos tres variables de tipo String, llamadas s1, s2 y s3, cuyo contenido sea el mismo, concretamente, la cadena de los ejemplos para Copy. Así, tendríamos lo siguiente:

 Delete(s1, 1, 10);             --> s1 = 'a_cadena_larga_para_hacer_pruebas'
 Delete(s2, Length(s2) + 2, 4); --> s2 = 'Esto_es_una_cadena_larga_para_hacer_pruebas'
 Delete(s3, Length(s3) - 3, 5); --> s3 = 'Esto_es_una_cadena_larga_para_hacer_pru'

PROCEDURE Insert(S: String; VAR S1: String; Indice: Integer);

Este procedimiento nos fusiona una cadena en otra comenzando en la posición dada por Indice. La cadena resultado será almacenada en S1, y se copiará la cadena S dentro de S1 a partir de la posición Indice. Vamos a ver algunos ejemplos, suponiendo que tenemos los valores siguientes para las variables: S := 'Cadena_Inicial', S1 := 'Otro_texto'

  Insert(S, S1, 3);              --> S1 = 'OtCadena_Inicialro_texto'
  Insert(S, S1, 6);              --> S1 = 'Otro_Cadena_Inicialtexto'
  Insert(S, S1, Length(S1) + 3); --> S1 = 'Otro_textoCadena_Inicial'

FUNCTION IntToHex(Valor, Digitos: Integer): String;

Esta función nos devuelve una cadena que resulta de convertir el número que pasamos en Valor a hexadecimal. La variable Digitos nos dice el número mínimo de dígitos hexadecimales a devolver. Por ejemplo:

  IntToHex(54367, 1);   --> D45F
  IntToHex(54367, 10);  --> 000000D45F

FUNCTION IntToStr(Valor: Integer): String;

Simplemente, nos devuelve la representación del número pasado en la variable Valor como una cadena.

FUNCTION Length(S: String): Integer;

Nos devuelve el número de caracteres que tiene la cadena S, es decir, su longitud.

FUNCTION LowerCase(S: String): String;

Devuelve una cadena que resulta de convertir a minúsculas la cadena pasada como argumento.

FUNCTION Pos(SubC, C: String): Integer;

Esta función busca la subcadena SubC dentro de la cadena C. Devuelve un valor entero que resulta ser el índice del primer carácter de SubC dentro de C. Si no encuentra la subcadena, devuelve el valor 0. Por ejemplo, supongamos que tenemos tres variables de tipo String, S1 := 'Cadena', S2 := 'de', S3 := 'algo'. Tendríamos los resultados:

  Pos(S2, S1);  -->  3
  Pos(S3, S1);  -->  0

PROCEDURE Str(X [: Ancho [: Decimales ]]; VAR S: String);

Convierte X a cadena (que se almacenará en S) de acuerdo a los parámetros de formato Ancho y Decimales. La variable X puede ser tanto real como entero, mientras que Ancho y Decimales son de tipo entero. Veamos algunos ejemplos:

  Str(2.54:5:1, S);  --> S = '  2.5'
  Str(2.54:5:3, S);  --> S = '2.540'

FUNCTION StrToInt(S: String): Integer;

Convierte la cadena pasada como argumento a su representación numérica como entero. Si la conversión no es posible, saltará una excepción por error de conversión.

FUNCTION StrToIntDef(S: String; ValorPorDefecto: Integer): Integer;

Convierte la cadena S a un entero. Si la conversión no es posible, en lugar de provocar una excepción, devolverá el valor que se le pase en la variable ValorPorDefecto.

FUNCTION Trim(S: String): String;

Devuelve una cadena que resulta de eliminar los espacios y caracteres de control existentes en S tanto al principio como al final. Por ejemplo:

  Trim('    Hola Mundo :-)   ');  -->  'Hola Mundo :-)'
  Trim('  Hola :-)');             -->  'Hola :-)'
  Trim('Hola :-)   ');            -->  'Hola :-)'

FUNCTION TrimLeft(S: String): String;

Devuelve una cadena que resulta de eliminar los espacios y caracteres de control existentes en S sólo al principio.

FUNCTION TrimRight(S: String): String;

Devuelve una cadena que resulta de eliminar los espacios y caracteres de control existentes en S sólo al final.

FUNCTION UpperCase(S: String): String;

Devuelve una cadena que resulta de convertir a mayúsculas la cadena pasada como argumento.