Funciones.
Delphi, es un lenguaje estructurado, lo cual indica que los programas escritos en este lenguaje, pueden descomponerse en pequeños módulos que pueden ser llamados cuando los necesitemos. Estos módulos en Pascal se llaman funciones y se identifican mediante un nombre. Se declaran del siguiente modo:
function nombre (argumento1: tipo; argumento2: tipo;…) : tipo;
Begin
//codigo
End;
Donde nombre es el nombre que se asignará a la función, argumento1 y argumento2 son valores que pasan a la función y tipo es el tipo de valor que retornará como resultado. Por ejemplo, si queremos implementar en Pascal la función matemática: f(x, y) = (x * x + y) / x siendo x e y números enteros, se realizaría de este modo:
Function f (x: integer; y: integer) : integer;
Begin
F = (x * x + y) / x;
End;
Dicha función, se definirá una sola ocasión durante el programa, y únicamente será necesario hacer llamada a esta función mediante su nombre y sus valores dados entre paréntesis.
a := f(1, 2); {llamada a f con x=1 e y=2}
b := f(a, 3); {llamada a f con x=a e y=3}
c := f(a, b) + f(1, 4);
Los valores colocados entre paréntesis de la función, reciben el nombre de argumentos. Estos se comportan dentro de la función, como si se tratase de variables.
Procedimientos
Toda función que no retorna ningún valor, o que no realiza operaciones matemáticas o no genera resultados numéricos, recibe el nombre de procedimiento. La programación estructurada, se basa en dividirse en pequeñas partes autosuficientes que realizan una tarea muy concreta, y que pueden ser invocados cuando se desee. Se puede realizar alguna función o tarea especifica que arroje información de modo no numérico, o sin realizar operaciones, es entonces cuando se utilizan los procedimientos.
Un procedimiento se declara del mismo modo que una función, a diferencia que la palabra reservada Function cambia por Procedure y al final de la lista de argumentos no se pone ningún tipo de valor de respuesta, pues no arroja ningún resultado. Ejemplo:
Program Ejemplo2;
Procedure Di (mensaje: String);
Begin
Showmessage(mensaje);
End;
Begin
Di (‘Mi nombre es: ’);
Di (‘David Osornio Fernández’);
End;
También es posible construir funciones o procedimientos que no tengas argumentos, pues pueden realizar una tarea concreta, no importando alguna otra cosa. Ejemplo:
Program Ejemplo3;
Procedure Saluda;
Begin
Showmessage(‘Hola a todos’);
End;
Begin
Saluda;
End;
¿Donde se declaran los procedimientos y las funciones?: Ver clase 03.
Funciones para fechas
Si deseamos cargar la fecha en una variable este se debe declarar asi:
var fecha: tdate;
Convertir fecha a texto:
edit1.text:=DateToStr(DateTimePicker1.date);
Convertir texto a fecha:
fecha := StrToDate( ’23/08/2007′ );
Comparaciones de fechas
If (DateTimePicker1.DateTime>MonthCalendar1.Date) then
begin
showmessage(‘DateTimePicker1.DateTime es mayor que MonthCalendar1.Date’);
end;
Deseo ver todas las funciones para las fechas: Parte 1 Parte 2 Parte 3
Funciones de cadenas
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
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.
