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.

https://delphiallimite.blogspot.com/2007/08/operaciones-con-cadenas-de-texto-iv.html?m=1

RE:Extraer caracteres de una string

Publicado por el novato (28 intervenciones) el 04/06/2005 03:23:35

Puedes usar
sintaxis
copy(cadena_de_la_que_extraes,posicion_desde_la_cual_empezaras_a_extraer,cantidad_de_cara
cteres_a_extraer_a_partir_de_la_posicion_anteriormente_especificada)

por ejemplo:

procedure
var
a,b:string;
begin
a:=editt1.text;
b:=copy(a,1,2);
end
Para extraer caracteres de una cadena vale lo anterior o simplemente acediendo a ello haciendo
referencia al posición del caracter

var scadena : String;

sCadena := 'Hola';
sCadena[0] equivaldria a la H

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.

http://www.formauri.es/arrobamasmas/Cursos/index.php?apdo=0402&curso=4_02_03#Length