Funciones, procedimientos y tipos primitivos básicos

Posted on 2026年7月13日 by

Modifica el archivo dpr de la lección anterior con el siguiente contenido

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;
function MyFunction(const S: string): string;
begin
  Result := S + 'strings are automatically managed';
end;
var
  X: Single;
begin
  WriteLn(MyFunction('Note: '));
  MyProcedure(5);
  // El operador "/" genera siempre resultado flotante, usa "div" para división entera
  X := 15 / 5;
  WriteLn('X is now: ', X); // notación científica
  WriteLn('X is now: ', X:1:2); // 2 cifras decimales
end.Lenguaje del código: PHP (php)
D:\fpcdemo>fpc mydemo.dpr
Free Pascal Compiler version 3.2.2 [2021/05/15] for i386
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Win32 for i386
Compiling mydemo.dpr
Linking mydemo.exe
20 líneas compiladas, 0,0 seg, 39248 bytes código, 2484 bytes datos

D:\fpcdemo>mydemo
Note: strings are automatically managed
A + 10 is: 15
X is now:  3.000000000E+00
X is now: 3.00

D:\fpcdemo>Lenguaje del código: CSS (css)

A continuación la explicación de los comentarios. Los caracteres no ingleses pueden aparecer distorsionados; configura la consola para salida en chino.

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram; 
// Nombre personalizado del programa. Los programas consola Pascal deben empezar por program nombre; luego declarar variables, procedimientos y código principal

// Sin valor de retorno: procedure procedimiento. Los procedimientos y funciones solo se ejecutan al ser llamados
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 =：', A + 10);
end;

// Con valor de retorno: function función
function MyFunction(const S: string): string;
begin
  Result := S + 'la memoria de las cadenas es gestionada automáticamente por el sistema';
end;

// Object Pascal no tiene función main, el bloque más externo begin...end. es el punto de entrada del programa, este es el bloque principal
var
  X: Single; // Tipo primitivo de coma flotante simple
begin 
  // Toda la lógica a ejecutar se escribe aquí
  WriteLn(MyFunction('Aviso：'));
  MyProcedure(5);

  // El operador "/" siempre devuelve un flotante, usa div para división entera
  X := 15 / 5;
  WriteLn('X is now：', X); // Muestra en notación científica automáticamente
  WriteLn('X is now：', X:1:2); // Limita a dos cifras decimales
end. // end. con punto marca el final completo del programaLenguaje del código: PHP (php)

Cada función o procedimiento usa un par begin y end para delimitar su cuerpo, equivalente a las llaves { } de C, C++, Java y otros lenguajes.

WriteLn imprime contenido en consola, las comillas simples ‘ ‘ delimitan literales de cadena. WriteLn('A + 10 =：', A + 10); imprime sucesivamente la cadena A + 10 =： y el resultado del cálculo A + 10.

Un programa solo puede tener un único bloque externo begin y end. que contiene el código principal y llama a otras funciones y procedimientos.

X := 15 / 5;
WriteLn(‘X is now: ‘, X); // notación científica
WriteLn(‘X is now: ‘, X:1:2); // dos decimales

/ es división flotante, el cociente siempre es un número decimal.

Las dos primeras líneas son directivas de precompilación

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}Lenguaje del código: PHP (php)

Se trata de una directiva de compilación condicional exclusiva de FPC

  • {$ifdef FPC}: Ejecuta la configuración intermedia solo si el compilador es Free Pascal
  • {$mode objfpc}: Cambia al modo sintáctico ObjFpc
  • {$H+}: Habilita las cadenas largas (tipo string moderno con gestión automática de memoria, obligatorio)
  • {$J-}: Desactiva las constantes modificables (las constantes no se pueden cambiar en ejecución, mayor seguridad)
  • {$endif}: Fin del bloque condicional

Propósito: Activar sintaxis moderna solo al compilar con FPC; el compilador Delphi ignora todo este bloque.

{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}Lenguaje del código: PHP (php)

Compilación condicional multiplataforma

  • MSWINDOWS: Solo surte efecto en sistema operativo Windows
  • {$apptype CONSOLE}: Define el programa como una aplicación consola (abre una ventana de terminal negra en lugar de ventana gráfica). Esta línea se ignora al compilar en Linux/macOS.

Conceptos clave

  • string tipo nativo básico; FPC/Delphi gestiona su memoria automáticamente, no requiere liberación manual
  • procedure procedimiento: Sin valor de retorno; function función: Con valor de retorno almacenado en la variable nativa Result
  • Diferenciación de divisiones: / división flotante; div división entera truncada
  • Salida formateada variable:anchoTotal:decimales para controlar la visualización de flotantes
  • Las funciones recursivas sin parámetros deben llevar paréntesis vacíos () para evitar ambigüedad sintáctica
  • Exit(valor) permite especificar valor de retorno y salir de la función anticipadamente
  • Se puede invocar una función ignorando su valor de retorno, útil para lógica con efectos secundarios como modificar variables globales

Reglas de valor de retorno de funciones

  1. La variable especial integrada Result almacena el valor devuelto por la función, se lee y escribe igual que una variable local
function MyFunction(const S: string): string;
begin
  Result := S + 'One';
  Result := Result + 'Two';
end;
Lenguaje del código: PHP (php)
  1. La sintaxis antigua permite asignar directamente al nombre de la función (MyFunction := xxx), no recomendada por baja legibilidad; usa siempre Result.

C/C++/Java/C# usan = para asignación y == para comparación de igualdad. Pascal funciona al revés: := para asignar variables, un solo = para comparar, igual que la notación matemática.

Pascal no tiene el operador ==

Sustituye la antigua MyFunction del ejemplo por esta versión. Esta función añade primero «One» y luego «Two» al final de la cadena recibida al invocarla.

La cadena final devuelta es: cadena original + One + Two

Llamadas recursivas

Las funciones sin parámetros en llamadas recursivas deben llevar paréntesis vacíos () para diferenciar «ejecutar la función» y «leer el valor de retorno actual»:

function SumIntegersUntilZero: Integer;
var I: Integer;
begin
  ReadLn(I);
  Result := I;
  if I <> 0 then
    Result := Result + SumIntegersUntilZero(); // llamada recursiva con ()
end;
Lenguaje del código: JavaScript (javascript)

Para la función sin parámetros SumIntegersUntilZero:

  1. SumIntegersUntilZero() → Ejecuta la función en recursión y obtiene el valor de retorno
  2. SumIntegersUntilZero → Accede a la variable interna Result (valor de retorno propio de la función)

Código sin paréntesis:

Result := Result + SumIntegersUntilZero;

El compilador lo interpreta como:

Result := Result + Result;

Equivale a Result := Result * 2, toda la lógica recursiva se rompe, generando bucle infinito y valores duplicados constantemente.

En este ejemplo, la función se llama a sí misma repetidamente hasta que la entrada sea 0 para salir; mientras el valor no sea cero, la recursión continúa.

Exit: Salida anticipada

  1. Exit sin parámetros: Sale inmediatamente de la función, devuelve el valor ya asignado a Result
  2. Exit(valor): Especifica directamente el valor de retorno y finaliza la función, equivalente al return x de C
function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); // Devuelve NewName directamente y termina
  Result := ExistingNames + ', ' + NewName;
end;
Lenguaje del código: PHP (php)
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;

function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); 
  Result := ExistingNames + ', ' + NewName;
end;

var
  X: Single;
begin
  WriteLn(AddName('Tom','Jack'));
  WriteLn(AddName('Tom',''));
  WriteLn(AddName('','Jack'));
end.Lenguaje del código: PHP (php)

Invocar funciones como procedimientos (ignorar valor de retorno)

Aunque una función tenga valor de retorno, se puede ejecutar solo su lógica ignorando el resultado; adecuado para lógica con efectos secundarios como modificar variables globales:

var
  Count, MyCount: Integer;
function CountMe: Integer;
begin
  Inc(Count); // Efecto secundario: incrementar variable global
  Result := Count;
end;
begin
  Count := 10;
  CountMe;   // Ignora retorno, solo ejecuta lógica, Count pasa a 11
  MyCount := CountMe; // Almacena valor devuelto, Count pasa a 12
end.
Lenguaje del código: PHP (php)

Ejemplo completo funcional

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;

var
  Count, MyCount: Integer;

function CountMe: Integer;
begin
  Inc(Count); 
  Result := Count;
end;

begin
  Count := 10;
  WriteLn(CountMe);   
  MyCount := CountMe;
  WriteLn(MyCount);
end.Lenguaje del código: PHP (php)

Inc es función estándar nativa de Pascal (FPC/Delphi), incrementa una variable en 1.

var es la palabra clave de declaración de variables en Pascal, su función es definir variables.

var
  Count, MyCount: Integer;Lenguaje del código: JavaScript (javascript)

var: Abre el bloque de declaración de variables

Count, MyCount: Dos nombres de variables

Integer: Tipo entero

Las variables declaradas dentro del bloque var de este ejemplo son globales, accesibles por todas las procedimientos y funciones de todo el programa.

Funciones, procedimientos y tipos primitivos básicos

POSTED IN Free Pascal Tutorial

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *