Pascal Prog

Pascal
Pascal: Tabla de Contenido

LAZARUS (Object Pascal) ................................................................................................................ 2
1. Lazarus y Pascal ...................................................................................................................................2
2. El lenguaje Pascal ................................................................................................................................ 2
3. Programas compilados e interpretados ................................................................................................. 3
4. Características de los programas en Pascal ........................................................................................... 3
Programación en Consola de LAZARUS ........................................................................................... 5
5. Crear un nuevo proyecto de consola: .................................................................................................... 5
6. Estructura general de un proyecto nuevo .............................................................................................. 5
7. Variables y Constantes ......................................................................................................................... 6
8. Tipos de datos ...................................................................................................................................... 7
9. Asignación de valores a variables ......................................................................................................... 8
10. Instrucciones simples y compuestas ..................................................................................................... 8
11. Operadores aritméticos y relacionales ................................................................................................... 9
12. Precedencia de los operadores ............................................................................................................ 10
13. Funciones predefinidas ....................................................................................................................... 10
14. Mostrando mensajes en pantalla ......................................................................................................... 11
15. Ingreso de datos por parte del usuario ............................................................................................... 12
16. Estructuras de decisión....................................................................................................................... 12
Estructura de Decisión Simple ..................................................................................................... 12
EJEMPLO 1 – IF SIMPLE .............................................................................................................. 13
EJEMPLO 2 – IF/ELSE CON IF ANIDADO ....................................................................................... 13
Estructura de Decisión Múltiple .................................................................................................... 13
EJEMPLO 3 – CASE..................................................................................................................... 14
EJEMPLO 4 – CASE..................................................................................................................... 14
EJEMPLO 5 – CASE..................................................................................................................... 15
17. Estructuras de iteración (repetición) ................................................................................................... 15
Intrucción FOR (repetir n veces). ................................................................................................. 15
EJEMPLO 6 – FOR ...................................................................................................................... 16
EJEMPLO 7 – FOR / DOWNTO ...................................................................................................... 16
Instrucción WHILE (Repetir Mientras).......................................................................................... 16
EJEMPLO 8 - WHILE ................................................................................................................... 16
Instrucción REPEAT/UNTIL (Repetir Hasta) .................................................................................. 17
EJEMPLO 9 – REPEAT/UNTIL ....................................................................................................... 17
18. Declaración de Procedimientos y Funciones ........................................................................................ 17
Invocación (llamada) a un Subprograma ...................................................................................... 18
Procedimientos .......................................................................................................................... 18
Funciones ................................................................................................................................. 19
Acerca de Parámetros Formales y Parámetros Actuales .................................................................. 20
Función versus Procedimiento ..................................................................................................... 21
19. Pasaje de parámetros ......................................................................................................................... 21
Paso por VALOR ......................................................................................................................... 22
Paso por REFERENCIA ................................................................................................................ 22
20. Ambito (o tiempo de vida) de variables y demás identificadores .......................................................... 23
21. Listado de funciones y procedimientos predefinidos ............................................................................ 24
22. Apéndice A – Mini Diccionario Inglés Español ...................................................................................... 25
Pascal
Lazarus (Object Pascal)

Veremos aquí los fundamentos del lenguaje en que se basa Lazarus1: la extensión del
lenguaje Pascal, llamada Object Pascal por su capacidad de manejar objetos.
Hay muchos agregados en Lazarus al lenguaje original; no obstante, se mantiene la filosofía que
dio origen al lenguaje, es decir, la estructuración en bloques. Con las extensiones de la
Programación Orientada a Objetos se extiende considerablemente el espectro de las aplicaciones
que podemos escribir, manteniendo la facilidad y velocidad que hicieron del Turbo Pascal uno de
los lenguajes más difundidos.
1. Lazarus y Pascal
Lazarus es un Entorno de programación, no un lenguaje. Son las ventanas y herramientas que
tenemos disponibles. Está basado en el lenguaje Object Pascal, que se utiliza para escribir el
Introducción a la Programación – Prof. Laura Kees – Año 2015

código que se ejecutará en respuesta a los distintos eventos del sistema2.
Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional
Lazarus reduce al mínimo la cantidad de código que es necesario escribir para construir un
programa, gracias a la utilización de componentes. Estos son objetos que tienen ya un
comportamiento preprogramado, que nosotros utilizamos como ladrillos para armar las
aplicaciones.
Las tareas recurrentes, reutilizables, vienen pre-programadas de antemano, como por ejemplo
hacer que un botón se “hunda” cuando se hace click sobre él. Pero para indicar qué debe hacer
nuestro programa al hundirse el botón... necesitamos escribir las instrucciones adecuadas.
Lazarus utiliza el lenguaje Pascal, pero podemos encontrar otros entornos muy parecidos que
utilizan C++ (C++ Builder) o Java (JBuilder), por ejemplo. Este código se ejecuta en respuesta a
los eventos que ocurren en el sistema, como por ejemplo la anterior pulsación del botón.
Esta obra está bajo una
2. El lenguaje Pascal
En un lenguaje no estructurado (como BASIC) un programa es una secuencia de líneas. En un
lenguaje estructurado (como Pascal), el programa se compone de una serie de bloques o
estructuras. A su vez, cada una de estas estructuras se compone de líneas de código.
En un lenguaje no estructurado, el flujo de la ejecución pasa de una línea a la siguiente; a menos
que la instrucción actual indique un salto o bifurcación a otra línea diferente, alterando la
secuencia de órdenes.
En un lenguaje estructurado, se ejecutan secuencialmente los bloques. A su vez dentro de los
bloques se ejecuta línea por línea, pero sin posibilidad de “saltar” de un bloque a otro en cualquier
momento. Debemos terminar la ejecución de un bloque para pasar al siguiente.
Tenemos la posibilidad de anidar bloques, pero siguiendo a rajatabla la regla que dice que cada
bloque debe estar contenido completamente dentro de otro, o totalmente fuera.
Podemos llamar a un bloque desde otro, pero este segundo bloque deberá terminar su ejecución
antes de volver al original que lo llamó; esencialmente, podemos considerar que el segundo
bloque estaba dentro del primero.
El siguiente gráfico muestra la diferencia fundamental entre los dos tipos de lenguajes:
1
Se trata de una alternativa libre y gratuita, desarrollada como proyecto de software libre a partir de Free
Pascal.
2
Recordemos que los eventos son las cosas que suceden en el entorno: el movimiento del ratón, la
presión de una tecla, etc.
2/26
Pascal

3. Programas compilados e interpretados
El microprocesador, que es el que ha de ejecutar cada programa, sólo entiende el lenguaje

binario, de manera que lo que sea que intentemos comunicarle debemos traducirlo a ese
“idioma”.
Existen principalmente dos formas de hacerlo3:
 Traducción “simultánea”, a medida que se leen las líneas: se interpreta cada una y se
actúa inmediatamente. Sólo tenemos que escribir el programa y ejecutarlo. No obstante, la
ejecución es relativamente lenta debido al proceso de interpretación de lo escrito. El ejemplo
más conocido es BASIC. Este modo de ejecución se denomina “interpretado”, y el programa
que lo hace intérprete.
 Traducción en un paso previo a la ejecución: este proceso se denomina compilación y el
programa que lo hace compilador. Es necesario compilar el programa entero luego de cada
modificación, lo que en ocasiones puede demorar el proceso. La gran ventaja de este tipo de
lenguajes es la velocidad de ejecución; dado que el procesador no debe consumir tiempo
traduciendo las líneas escritas porque ese paso ya ha sido cumplido, el código se ejecuta
directamente.
Pascal (el lenguaje que utiliza Lazarus) es un lenguaje compilado. No obstante, el compilador es
sumamente rápido; la generación del ejecutable no demanda mucho tiempo y permite probar
rápidamente los cambios introducidos. Además, como veremos luego, el programa se divide en
unidades funcionales, cada una de las cuales se compila por separado. Al modificar una parte del
programa, sólo hay que recompilar las unidades que se vean afectadas; esto acelera aún más el
proceso de traducción.
4. Características de los programas en Pascal

Como todo lenguaje, hay ciertas reglas que seguir para escribir un programa en Pascal:
 El programa principal comienza con la declaración program seguida del nombre.
 Todas las líneas terminan con punto y coma (;) salvo algunas excepciones como las sentencias
begin, do, repeat, etc.
 El bloque principal del programa comienza con la cláusula begin (siempre sin punto y coma).
 El bloque principal del programa termina con la declaración end seguida por un punto. Es el
único lugar donde se utiliza el punto al final de línea, e indica al compilador que el programa
concluye ahí.
3
Existe también lo que podríamos considerar una tercera forma de compilación, a medio camino
entre las otras dos: la compilación de un código intermedio independiente del procesador entre el código
máquina y el lenguaje de alto nivel, ejecutado por un núcleo intérprete especial. Esta es la técnica utilizada
por Java.
3/26
Pascal
Ejemplo:
Un programa de nombre Ejemplo debería tener al menos las siguientes líneas:
Program Ejemplo;
Begin
End.
Este programa no hace nada; sin embargo, el compilador creará un archivo ejecutable sin señales
de error.
Este tipo de programas se denominan aplicaciones de consola, y en Windows se abrirá una
ventana de DOS donde correrá nuestro programa. No es el tipo de programas que uno espera
crear con Lazarus.
La sintaxis general de un programa en Pascal es la siguiente:

PROGRAM NombrePrograma;
USES librería [, librería ...];
CONST
Declaración de constantes;
TYPE
Declaración de tipos de datos definidos por el usuario;
VAR
Declaración de variables;
{Declaración de procedimientos y funciones}
BEGIN {Cuerpo del programa principal}

Sentencia1;
....
SentenciaN;
END.
4/26
Pascal
Programación en consola de LAZARUS

5. Crear un nuevo proyecto de consola:
1. En el menú Principal, seleccionar Archivo.
2. Seleccionar la opción Cerrar todos los archivos del editor

para cerrar el proyecto que se crea por defecto.

3. Seleccionar la opción Nuevo para crear un nuevo proyecto.

Aparecerá la ventana que se muestra en la figura 2, donde se
deberá seleccionar Aplicación de Consola y luego deseleccionar las
Opciones de generación de código como se sugiere en la imagen, y
así tendremos un proyecto de consola nuevo listo para trabajar.
Figura 1
Figura 2
6. Estructura general de un proyecto nuevo

Al crear y guardar una nueva aplicación de consola en Lazarus, se generan varios archivos, de los
cuales los más importantes son:
5/26
Pascal
El archivo de Proyecto de Consola cuya extensión es .LPI y el archivo .PAS que contiene el código
de nuestro programa.

Figura 3
En la figura 3, podemos apreciar el archivo de proyecto de consola, donde escribiremos nuestro

código.
Al código de nuestro programa lo insertaremos entre las palabras begin y end.
Entre la palabra uses y begin, podremos declarar una sección var para variables.
7. Variables y Constantes
Los datos de un programa se almacenan en posiciones de memoria. Dependiendo si esos valores
pueden cambiar en el transcurso de un programa o no, Pascal clasifica estas posiciones como
Variables o Constantes respectivamente.
Los nombres utilizados para identificar constantes y variables deben seguir ciertas reglas:
 Pueden tener hasta 32 caracteres de longitud.
 Deben empezar con una letra o guión bajo (_), y puede continuar con una secuencia de
números, letras y/o guión bajo (_).
 No se distinguen entre mayúsculas y minúsculas.
Las variables o constantes deben ser declaradas antes de ser utilizadas, en secciones destinadas a
tal efecto: la cláusula var indica que comienza una zona de declaración de variables, mientras la
cláusula const se usa para especificar la zona de declaración de constantes.
Las variables se declararán de la siguiente forma:
Var
nombreVar1: TipoDato;
nombreVar2: TipoDato;
6/26
Pascal
Al declarar las variables debemos especificar claramente el tipo de datos que contendrán, porque
el compilador necesita esta información para traducir el programa a código de máquina (por
ejemplo, para saber cuanto espacio reservar para cada variable).
Ejemplo:
En el programa Ejemplo utilizaremos una variable de tipo entero que llamaremos a. Entonces,
agregamos al programa anterior la sección de declaración de variables indicada por la cláusula
var:
Program Ejemplo;
Var
a:Integer;
Begin {Cuerpo del programa principal}
End.

No hay un identificador del final de la zona de declaración de variables; sencillamente se termina
al encontrar el identificador de otra zona. En el ejemplo anterior la cláusula begin indica que
comienza el bloque principal del programa, terminando por lo tanto la zona de declaración de
variables.
Podemos definir más de una variable del mismo tipo en una sola línea, por ejemplo si en el listado
anterior queremos otra variable b también de tipo entero podríamos escribirlo de cualquiera de las
formas siguientes:
Program Ejemplo; Program Ejemplo;

Var Var
a,b:Integer; a:Integer;
b:Integer;
Begin Begin
End. End.
Variables Globales: se agregará una sección var antes de la cláusula begin y después de la
cláusula uses del programa, para declarar allí las variables globales.
Variables Locales: se agregará una nueva sección var en el procedimiento en cuestión, después
de la palabra procedure y antes de la palabra begin del mismo, análogo para las funciones.
Nota: más adelante, en este mismo apunte, profundizaremos este tema.
8. Tipos de datos
Estos son algunos de los diferentes tipos de datos que se les puede asignar a las variables en
TipoDato (para mayor detalle sobre ver Apunte 2 – Object Pascal: Tipos de Datos).
Tamaño
Tipo Valores que puede contener
en Bytes
Byte Números enteros entre 0 y 255 1
ShortInt Números enteros entre -128 y 127 1

SmallInt Números enteros entre -32768 y 32767 2
LongInt Números enteros entre –2147483648 y 2147483647 4

Word Números enteros entre 0 y 65535 2
Integer Números enteros entre -2147483648 y 2147483647 2ó4

Real Números en coma flotante con hasta 12 dígitos. 4ó8
7/26
Pascal
Números en coma flotante con hasta 8 dígitos. 4
Single
1.5E-45 .. 3.4E38
Números en coma flotante con hasta 16 dígitos. 8
Double
5.0E-324 .. 1.7E308
Boolean True o False 1
Char Un caracter cualquiera. 1

String Cadena de caracteres entre 0 y 255 de longitud.
El lenguaje Pascal exige una concordancia exacta en los tipos de datos que intervengan en una
misma expresión. Esto significa que no podemos, por ejemplo, sumar una palabra con un número
(¡algo que por otro lado nos suena bastante lógico!).
Se dice que es un lenguaje fuertemente tipificado (o tipado) ya que obliga a declarar cada una
de las variables mencionadas dentro de un programa. En los tipos numéricos se puede asignar un
valor de un tipo a una variable de un tipo superior, que lo contenga. Por ejemplo podemos asignar

un entero a una variable de tipo real (los números enteros también son reales) pero no a la
inversa.
9. Asignación de valores a variables

Considerando a las variables como “cajones” en la memoria de la computadora, donde guardar
valores que nos interesen, tenemos que ver cómo le diremos a Lazarus que guarde determinado
valor en determinado cajón de memoria.
La sentencia que utilizaremos será la siguiente:
NombreVar := Valor ;
Notar que el nombrevar es el nombre con el cual hemos declarado dicha variable, y que el valor
será algún dato del tipo que esa variable pueda guardar.
Supongamos que definí las siguientes variables y una sección var en mi programa:
var
numero : integer;
pepe : integer;
esCero : Boolean;
miFrase : String;
Entonces, debajo del begin del programa, se podrán hacer las siguientes asignaciones de valores
válidas, por ejemplo:
numero := 56; {Aquí la variable numero toma el valor 56}
pepe := numero;
esCero := True;
miFrase := ‘Esto es un texto’;
Pero no serán válidas las siguientes asignaciones:
pepe := ‘Hola’;
numero := 3,14;
esCero := 6;
miFrase := 34;
10. Instrucciones simples y compuestas

Como ya se dijo, los programas en Pascal están compuestos por una serie de bloques.
Las instrucciones más simples se dan en una sola línea; por ejemplo, una asignación…
8/26
Pascal
variable1 := 67;
Hay ocasiones en que tendremos la necesidad de agrupar las sentencias en un bloque,
necesitaremos entonces crear una instrucción compuesta: un bloque begin..end.
Una sola
Tres
instrucción
instrucciones El punto y coma de la
compuesta.
simples. sentencia anterior a la
cláusula END no es
necesario.
Ejemplo:
La sentencia if..then va seguida de una sola instrucción. Si debemos ejecutar varios pasos,
debemos crear una instrucción compuesta encerrando el bloque entre begin y end. Lo mismo

ocurre con las sentencias iterativas for..do, while..do que veremos después.
11. Operadores aritméticos y relacionales

Los operadores aritméticos nos permiten realizar dentro del código de nuestro programa las
operaciones usuales entre números.
Los operadores relacionales nos permiten comparar valores, de forma tal que podamos construir
condiciones, a calcular si valen verdadero o falso en un momento dado del programa.
A continuación se listan todos los operadores.
Las expresiones de Pascal pueden utilizar cualquiera de los símbolos convencionales para las
operaciones básicas: +, -, *, /, además de funciones (porciones de código) que devuelvan un
valor de tipo compatible.
Ejemplo
Dadas las siguientes variables…
var
a: integer;
b: real;
c: single;
… podemos escribir las siguientes expresiones:
b:= a*3;
c:= Sin(a*Pi/180); {seno en grados; el resultado siempre es real}
b:= Sqrt(b*23-a*a); {Raíz cuadrada; el resultado siempre es real}
9/26
Pascal
En los dos últimos casos, no se podría asignar el resultado de la operación a la variable a porque
por definición, las funciones utilizadas devuelven valores reales.
12. Precedencia de los operadores

Precedencia significa que, en una expresión donde hay
varios operadores, unos se calculan primero que otros,
es decir, los de mayor precedencia tienen más prioridad
al calcularse la expresión. Dicho de otro modo, las
reglas de precedencia determinan en qué orden son
realizadas las operaciones de una expresión compleja.
Los operadores de igual precedencia serán evaluados de izquierda a derecha.
 Supongamos la expresión X + Y * Z.
Multiplicará Y con Z primero, y luego al resultado le sumará X.

 Supongamos la expresión X – Y + Z.
Como los operadores + y – tienen la misma precedencia, se evaluará primero el término de más a
la izquierda, es decir, primero X – Y, luego al resultado de la resta se le sumará Z.
 Podemos usar paréntesis para determinar otro orden en el cálculo de la expresión, por ejemplo,
en la expresión (X + Y) * Z, podremos sumar primero y luego multiplicar el resultado de dicha
suma por Z.
 Supongamos la expresión X = Y or X = Z.
La interpretación deseada de dicha expresión es claramente (X = Y) or (X = Z); pero sin
paréntesis, Pascal usará las reglas de precedencia, por lo que entenderá (X = (Y or X)) = Z.
13. Funciones predefinidas

Vemos en el ejemplo anterior la utilización de funciones predefinidas: éstas son pequeños

programas, con un nombre asignado (por ejemplo, “sin”) y que devuelven un valor. Es decir, se
pueden usar en la parte derecha de una asignación siempre y cuando el tipo de la variable de la
parte izquierda sea compatible.
Eventualmente, las funciones pueden necesitar algún dato para procesar; estos datos se entregan
a la función en el momento de invocarla, encerrados entre paréntesis y separados por comas. Se
denominan parámetros de la función.
Ejemplo: la función Sin espera un dato de tipo real, que representará el ángulo al cual queremos
calcularle el seno, en radianes. Entonces, debemos invocarla con un número real (puede ser una
variable o una constante, o incluso otra función) entre paréntesis. Ejemplos: Sin(30*Pi/180),
Sin(Cos(2.876)), Sin(0.654).
Dado que las funciones siempre devuelven un valor, se pueden utilizar directamente como
parámetros de otras funciones. Las siguientes secuencias son equivalentes:
Var
a, b: real;
begin
a:= Sin(25*Pi/180); {a es igual al seno de 25 grados}
b:= Sqrt(a); {b es igual al cuadrado del seno de 25 grados}
Var
b: real;
begin
b:= Sqrt(Sin(25*Pi/180));{b es igual al cuadrado de seno de 25 grados}
Veamos la definición de la función Sin, tal como aparece en la ayuda de Lazarus:
10/26
Pascal
function Sin(X: Extended): Extended;
Vemos que entre paréntesis se declara una variable: esta variable existe únicamente dentro de la
función, e indica el valor que tenemos que entregar a la función para su proceso. En este caso,
cualquier valor que pasemos a la función entre los paréntesis se asignará dentro de la función a
una variable X. A nosotros, usuarios de la función, no nos interesan los nombres que ésta les
asigna a sus parámetros; únicamente tenemos que tener cuidado de enviar el tipo correcto de
dato para cada parámetro.
El tipo de dato que se indica después de los dos puntos finales nos dice qué tipo de datos
devuelve la función.
Las funciones pueden esperar más de un parámetro; en este caso, en la definición se listan todos
y cuando la llamamos debemos enviar cada dato en el orden que se define.
Lazarus trae definidas un montón de funciones como las anteriores. Están organizadas en
distintos módulos -unidades- por lo que para utilizarlas debemos incluir la unidad correspondiente
en nuestro código (sección USES de un programa en Object Lazarus).

14. Mostrando mensajes en pantalla

Para escribir texto en la pantalla de nuestro programa cuando esté en ejecución, la sentencia que
usaremos será:
write(texto);
Si se quiere que una vez que imprima el texto en pantalla, haga un Enter, y el cursor quede
posicionado en la línea siguiente (de abajo), se deberá usar:
writeln(texto);
Ejemplo 1: la siguiente secuencia de instrucciones

write(“A”);
write(“n”);
write(“a”);
Imprimirá por pantalla:

Ana

writeln(“A”);
writeln(“n”);
writeln(“a”);

A
n
a

Numero:= 100 * 7 + 300
write(“El resultado es: ”);
write(numero);
writeLn();
write(“Presione Enter para continuar.”);
11/26
Pascal
El resultado es: 1000

Presione Enter para continuar.
Una forma equivalente de obtener la misma salida por pantalla es:

numero:= 100 * 7 + 300
writeln(“El resultado es: ”, numero);
write(“Presione Enter para continuar.”);
15. Ingreso de datos por parte del usuario

Para permitir que el usuario de nuestro programa ingrese valores a nuestro programa, tenemos la
siguiente sentencia:

Read(nombrevar);
Esta sentencia lo que hace es esperar que el usuario ingrese un valor (o más) y cuando éste
apriete Enter, guarda el valor ingresado en la variable que le hemos dado (nombrevar).
Atención!! Para el ejemplo del read anterior, si el usuario ingresara más de un valor antes de
presionar Enter, se asignaría el primer valor a la variable nombrevar y los valores restantes
quedarían pendientes en un buffer de memoria asignándoselos a las próximas sentencias read que
aparezcan. En ocasiones esto suelo provocar comportamientos inesperados en nuestros
programas.
Para evitar que quede algún dato pendiente en el buffer de memoria se utiliza la sentencia:
ReadLn(nombrevar);
la cual asigna a nombrevar un dato ingresado por el usuario y luego “limpia”, “borra” el buffer de
memoria (dedicado para almacenar la entrada de datos).
Supongamos que deseamos que el usuario ingrese dos números, los cuales guardaremos en
variables: (asumimos definidas en su correspondiente sección var las variables que aparecen)
write(‘Ingrese el primer numero:’);
readln(num1);
write(‘Ingrese el segundo numero:’);
readln(num2);
16. Estructuras de decisión
Estructura de Decisión Simple

La sentencia IF permite la ejecución condicional de una porción de código. La sintaxis general es
la siguiente:
La condición puede ser cualquier expresión que devuelva un
valor lógico booleano (verdadero o falso).
If (condición) then
Cuando la expresión es verdadera (la condición se cumple) se
sentencia1 ejecuta la sentencia siguiente. Esta puede ser simple o
compuesta (un bloque begin..end), pero debe ser una sola.
else
Cuando la condición no se cumple y se especifica una acción
alternativa (sentencia2) con la sentencia else, ésta se ejecuta
sentencia2;
en lugar de la primera (sentencia1).
12/26
Pascal
Notar:
 El else es opcional.
EJEMPLO 1 – IF SIMPLE
Program Ejemplo1;
var
n : integer;
begin
writeln(‘Ingrese un número:’);
readln(n);
If ((n>1) and (n< 10)) then
write(‘Ha ingresado un número mayor que 1 y menor que 10’);
end.

EJEMPLO 2 – IF/ELSE CON IF ANIDADO

Si el usuario ingresa el texto “hola”, el programa saludará, sino, si el usuario ingresa el texto
“chau”, el programa se despedirá.
Program Ejemplo2;
var
frase : string;
begin
writeln(‘Ingrese una frase:’);
readln(frase);
If (frase = ‘hola’) then
write(‘buenas, como está usted?’)

else
if (frase=’chau’) then
write(‘hasta la próxima, fue un placer charlar con Usted’)
else
write(‘no te entiendo!’);
end.
NOTA: observe el uso del punto y coma final sólo después de la última sentencia. Al momento de
encontrar este signo de puntuación (si no se está dentro de una sentencia compuesta) el
compilador asume que termina la instrucción if. Por lo tanto antes del else no va el punto y coma
(de lo contrario el compilador terminaría la orden if en ese momento y se encontraría con una
sentencia else que no tiene significado por sí sola).
Estructura de Decisión Múltiple

Cuando debemos seleccionar uno solo de una serie de valores del mismo tipo -siempre que estos
valores sean ordinales- podemos utilizar otra sentencia de selección: CASE.
13/26
Pascal
La sintaxis es la siguiente:
El selector es una variable de un tipo que se

case ( selector ) of pueda enumerar (ordinal) como por ejemplo
valor1 : sentencia1; integer, char, boolean o enumerado.
El punto y
coma de valor2 : sentencia2;
Según el valor que tome esta variable se
la : ejecutará la sentencia que corresponda, la cual
sentencia valorN: sentenciaN ; puede ser simple o compuesta. Si el valor del
anterior a else selector no está contemplado en la lista de
la cláusula sentenciaPorDefecto ; valores, se ejecuta la sentencia que sigue a la
ELSE no es cláusula else (opcional) en caso de existir. La
end;
necesario. estructura termina con la instrucción end.
coma.
El punto y coma de la
sentencia anterior a la

cláusula END no es necesario.
EJEMPLO 3 – CASE
Se puede indicar un rango de valores escribiendo el primer valor seguido por dos puntos y luego
el último valor del rango:
Program Ejemplo3;
var
n: integer;
begin
ReadLn(n);
case n of
1..9: Write('El número ingresado esta entre 1 y 9');
10..20: Begin
Write('El número ingresado esta entre 10 y 20');
Write('El número ingresado tiene dos dígitos');
End;
0: Write('El número ingresado es cero');
else
Write('El número ingresado es mayor que 20');
end;
end.
EJEMPLO 4 – CASE
También se puede indicar la misma acción para varios valores, simplemente listándolos en la
misma línea:
Program Ejemplo4;
var
n: integer;
begin
ReadLn (n);
case n of
1,3,5,7,9: Write('El número ingresado es impar');
2,4,6,8: Write('El número ingresado es par');
0: Write('El número ingresado es cero');
else
Write('Error! El número debía ser de una sola cifra');
end;
end.
14/26
Pascal
EJEMPLO 5 – CASE
Program Ejemplo6;
var
a: char;
begin
ReadLn(a);
case a of
'a','e','i','o','u': Write('La letra es una vocal');
else
Write('No es una vocal');
end;
end.
17. Estructuras de iteración (repetición)

Intrucción FOR (repetir n veces).

La instrucción for tiene la siguiente sintaxis general:
for variableContador := valor_inferior to valor_superior do

sentencia;
for variableContador := valor_superior downto valor_ inferior do

sentencia;
Esta instrucción ejecuta los siguientes pasos:

1. se asigna el valor (inferior o superior según la variación elegida) inicial a la variable de control;
2. se compara el valor de la variable con el indicado a continuación de “to” o “downto”.
3. si la variable es menor o igual (en la primera forma) o mayor o igual (en la segunda forma)
que el valor dado, se ejecuta la sentencia y se incrementa (en la primera forma) o se
decrementa (en la segunda forma) la variable.
4. se vuelve al paso (2) hasta que se pase el límite.
Notas:
 Esta instrucción ejecuta una sola sentencia, que puede ser simple o compuesta.
 La variableContador debe ser de tipo ordinal y no puede alterarse dentro del bloque a repetir
(no puede aparecer del lado izquierdo de una asignación).
 Al contrario de otros lenguajes, no es posible especificar un paso diferente de uno.
 La comprobación del límite se produce antes de ejecutar la sentencia interna, por lo que puede
ser que el bucle no se ejecute nunca.
 En el caso de TO, si el valor inicial es mayor que el valor final, la sentencia FOR no se ejecuta
ninguna vez. En el caso de DOWNTO, si el valor inicial es menor que el valor final, la sentencia
FOR no se ejecuta ninguna vez. El valor de la variable de control es indefinido al finalizar
normalmente la sentencia FOR.
15/26
Pascal
 La variable de control debe declararse igual que cualquier otra variable y que su tipo debe ser
ordinal.
EJEMPLO 6 – FOR
Este programa mostrará todos los números desde el 1 hasta el 35 en pantalla, uno por línea, en
forma creciente (1, 2, 3, 4…)
Program Ejemplo7;
var
i : integer;
begin
for i := 1 to 35 do
writeln(i);
end.

EJEMPLO 7 – FOR / DOWNTO
Este programa mostrará todos los números desde el 2 hasta el 40 en pantalla, uno por línea, en
forma decreciente (40, 39, 38, 37… 2)
Program Ejemplo8;
var
k : integer;
begin
for k := 40 downto 2 do
writeln(k);
end.
Instrucción WHILE (Repetir Mientras)

La sentencia while ejecuta una sentencia (simple o compuesta) mientras se cumpla una
condición.
La condición que va a controlar el bucle se evalúa al principio, antes de entrar en él, por lo que
puede ser que el bucle no se ejecute nunca.
La sintaxis es:
while ( condición ) do
sentencia;
La condición es una expresión que devuelve un valor lógico booleano.

Este bucle es muy parecido al anterior (for), pero aquí no se tiene una variable de control
explícita; por lo que es imprescindible hacer que alguna vez la condición sea falsa, para que el
bucle pueda terminar.
EJEMPLO 8 - WHILE
Este programa suma los 10 primeros números naturales.
Notemos que en este ejemplo fue necesario utilizar begin..end porque dentro del bucle se debían
ejecutar dos sentencias.
Program SumaNaturales;
var
suma,n : integer;
begin
16/26
Pascal
n:=1;
suma := 0;
while (n<=10) do
begin
suma := suma + n;
n:=n+1
end;
writeln(‘La suma desde 1 hasta 10 es igual a: ’, suma);
end.
Instrucción REPEAT/UNTIL (Repetir Hasta)

La sintaxis es:
repeat

sentencia1; El punto y coma de la
sentencia2; sentencia anterior a la

sentencia3; cláusula UNTIL no es
: necesario.
sentenciaN ;
until ( condición );
La condición que va a controlar la ejecución del bucle se evalúa al final, entrando al bucle al
menos una vez.
Se comienza el bucle ejecutando las sentencias (no se comprueba la condición hasta el final) y al
llegar a la cláusula until (hasta) comprueba si se cumple la condición. Si se cumple (la condición
devuelve verdadero) se sale del bucle; caso contrario se repite desde la sentencia1.
Aquí tampoco existe una variable de control explícita.
EJEMPLO 9 – REPEAT/UNTIL
Este programa suma todos los números ingresados por el usuario. Cuando el usuario ingresa 0
significa que ya no ingresará más y el programa ha de mostrar la suma total.
Program SumarNumeros;
var
suma, n : integer;
begin
suma := 0;
repeat
ReadLn(n)
suma := suma + n;
until n = 0;
writeln(‘La suma es igual a: ’, suma);
end.
18. Declaración de Procedimientos y Funciones

Uno de los métodos fundamentales para resolver un problema es dividirlo en problemas
más pequeños, llamados subproblemas. Este método de diseño se denomina diseño
descendente debido a que se comienza con un problema general y se diseñan soluciones
específicas a sus subproblemas. Es deseable que cada subproblema (módulo) sea independiente
de los restantes. El problema principal se resuelve con el programa principal y los subproblemas
con los SUBPROGRAMAS (también conocidas como rutinas o subrutinas), los cuales pueden
escribirse como PROCEDIMIENTOS o FUNCIONES.
17/26
Pascal
Un subprograma (procedimiento o función) es, entonces, un conjunto de instrucciones al que se
asigna un nombre. Este grupo de instrucciones realiza una tarea específica y se ejecuta cada vez
que se invoca su nombre (invocación/llamada a subprograma). Por ejemplo, los
procedimientos predefinidos READLN y WRITELN están diseñados para realizar operaciones de
entrada y salida.
El proceso de descomposición de un problema en módulos se conoce como modularización y a
la programación relativa a ellos programación modular.
Un subprograma se declara una sola vez pero puede ser utilizado, mediante llamadas, todas las
veces que se quiera desde el resto de código de nuestro programa. La finalidad principal es evitar
la repetición de un código que va a ser usado varias veces, aislándolo y asignándole un nombre
que facilite tanto su ejecución repetida como su posible modificación.
Una rutina es independiente del resto del programa por lo que también facilita el diseño, el
seguimiento y la corrección de un programa. Pueden además almacenarse independientemente en
colecciones llamadas librerías o unidades, lo cual permite que sean utilizadas en cualquier
programa. De hecho, existen funciones y procedimientos que vienen ya construidos para el

lenguaje de programación Object Pascal (Cos, Sin, Exp, ReadLn, WriteLn, ClrScr...), que
están almacenados en distintas unidades (System, Crt, Graph...) y que el programador puede
emplear en sus programas4.
Tanto procedimientos como funciones deben estar declarados antes de poder ser
referenciados.
Ventajas de la programación modular:
 Los subalgoritmos permiten a los programadores desarrollar soluciones de problemas
complejos, a través del método descendente.
 Los programas son más fáciles de comprender, debido a la independencia entre las unidades de
programas.
 Los subprogramas se escriben una sola vez, pero puede usarse en muchos puntos de un
programa.
 Con el uso de los subprogramas se facilita la localización de un error.
 El tamaño total del programa será menor que si se escribiera el código completo de la operación
cada vez que se necesita.
Invocación (llamada) a un Subprograma

Al invocar a una subrutina P, el módulo llamador (sea M) le entrega el control a dicha subrutina:
es decir, la siguiente instrucción que se ejecuta es la primera instrucción de P. Una vez ejecutado
el cuerpo de P, P devuelve el control a la sentencia siguiente a la del punto de llamada en M.
M SentenciaMn-1
P SentenciaP1
…
SentenciaP1
…
SentenciaM n-1
P …
SentenciaPFin
SentenciaM n+1
SentenciaPFin SentenciaMn+1
…
Procedimientos
Un procedimiento, como ya dijimos, es un módulo que forma parte de un programa y realiza una
tarea específica.
4
Para leer acerca de cómo crear módulos véase: Apunte 4 –Creación de Unidades.pdf
18/26
Pascal
Un procedimiento puede devolver 0, 1 ó más datos de salida.
La declaración/definición de un procedimiento tiene la siguiente forma:
Procedure NombreProc (lista de parámetros formales); Los parámetros formales

sirven para pasar información
<declaraciones locales>
al procedimiento y/o devolver
Begin información del mismo a la
unidad de programa que lo
<sentencias del cuerpo de la función>
invoca.
End;
Un procedimiento puede tener sus propias variables las cuales se declaran en la sección var del
propio procedimiento. Estas se llaman variables locales. El espacio de memoria para estas

variables se crea cada vez que el procedimiento es llamado y se libera al salir (terminar la
ejecución) del mismo. Así, las variables locales para un procedimiento sólo se pueden usar en el
cuerpo del procedimiento y no en el cuerpo principal del programa.
Un procedimiento se invoca en el programa principal o en otros subprogramas escribiendo su
nombre:
nombreProc(parámetros actuales);
Ejemplo: procedimiento para intercambiar los valores de dos variables.

Program Uno;
Uses crt;
Indicación de parámetros de
Var Declaración de
salida (cláusula var).
N1, N2: integer; procedimiento
Procedure intercambio (var nro1, nro2: integer);

Var
Aux: integer; (variable local uso exclusivo en procedimiento}
Begin
Aux:= nro1;
Nro1:= nro2;
Nro2:= aux
End;
begin
clrscr; {borrado de pantalla}
Write ('introduzca 2 números enteros: ');
Readln(N1,N2);
Writeln ('valores de las variables antes de la llamada');
Writeln ('Nro 1 = ', Nl,'Nro 2 = ',N2);
intercambio(Nl,N2); {llamada al procedimiento, parámetros actuales: N1 y N2}
Writeln ('Valor de las variables después de la llamada');
Writeln ('Nro 1 = ',Nl,'Nro 2 = ',N2);
End.
Funciones
Una función, así como un procedimiento, es un módulo que forma parte de un programa y realiza
una tarea específica. En particular, una función se asemeja bastante a la idea matemática de
función con argumentos: calcula como resultado un valor simple y único a partir de otros valores
dados como argumentos.
19/26
Pascal
El identificador de la función asume un valor, por lo tanto, dicho nombre debe tener asociado
un tipo de dato.
La declaración/definición de una función tiene la siguiente forma: Tipo de dato
del resultado
que devuelve
Function NombreFunc (lista de parámetros formales): Tipo; la función.
<declaración de variables, procedimientos y funciones locales>
Begin
<sentencias del cuerpo de la función>
NombreFunc := valor resultado de la función
End;
exponente
Ejemplo: función para calcular base (Por ejemplo: 23=8)

FUNCTION potencia( base, exponente: REAL):REAL;

VAR k,p: REAL;
BEGIN
p := 1;
FOR k:= 1 TO exponente DO
p := p * base
END;
potencia := p
END;
La llamada a una función se realiza usando su nombre en una expresión. Es decir,
una función puede ser utilizada dentro de una sentencia de asignación, o dentro de una condición
que esté en cualquiera de las estructuras while, if, etc.

El siguiente es un ejemplo de llamada a la función potencia declarada antes:
x := potencia(2 , 3)
Acerca de Parámetros Formales y Parámetros Actuales

Los parámetros (también llamados argumentos) son identificadores que proveen un mecanismo
para pasar información hacia/desde los subprogramas invocados.
PARÁMETROS FORMALES - usados en el encabezado de la

definición de la función (ó procedimiento).
function potencia( base, exponente : real ): real
PARÁMETROS ACTUALES – variables (ó valores) usados en la

invocación/llamada a la función (ó procedimiento).
x = potencia(2 , 3)
Es obligatorio que haya el mismo número de parámetros formales que actuales, y además
estos deben ser del mismo tipo (o un tipo compatible) y aparecer en el mismo orden, ya que
la correspondencia se realiza según la posición en la que aparecen.
20/26
Pascal
Función versus Procedimiento
Semejanzas
 La definición de ambos aparece en la sección de subprogramas de la parte de declaraciones de

un programa y en ambos casos consiste en una cabecera, una parte de declaraciones locales y
una parte de instrucciones.
 Ambos son unidades de programa independientes. Los parámetros, constantes y variables
declarados en una función o procedimiento son locales a la función o al procedimiento;
solamente son accesibles dentro del subprograma.
 Cuando se llama a una función o procedimiento, el número de los parámetros reales debe ser el
mismo que el número de los parámetros formales y los tipos de los parámetros reales deben
coincidir con los tipos de los correspondientes parámetros formales.
Diferencias
 Una función normalmente devuelven un solo valor a la unidad de programa (programa principal

u otro subprograma) que la referencia. Los procedimientos suelen devolver más de un valor, o
pueden no devolver ninguno si solamente realizan alguna tarea, como una operación de salida.
 Mientras que a un procedimiento se le llama mediante una instrucción de llamada a
procedimiento, a una función se la llama usando su nombre en una expresión. Es decir:
* Una función puede ser utilizada dentro de una sentencia de asignación, o dentro de una
condición que esté en cualquiera de las estructuras while, if, etc.
* Una llamada a procedimiento, en cambio, va en una sentencia exclusiva para llamarlo (y no
se puede poner ni en una asignación, ni en condiciones booleanas), como por ejemplo, el
procedimiento write para escribir mensajes en pantalla.
 Puesto que se debe asociar un valor al número de una función, también se le debe asociar un
tipo. Por tanto, la cabecera de una función debe incluir un identificador de tipo que especifique
el tipo del resultado. Sin embargo, no se asocia ningún valor con el nombre de un
procedimiento y, por tanto, tampoco ningún tipo.

 En los procedimientos, los valores se devuelven a través de parámetros por variable; en las
funciones el valor de salida se devuelve mediante la asignación al nombre de la función de dicho
valor en la parte de instrucciones de la definición de la función.
Cualquier tarea que se pueda realizar mediante una función también se puede realizar mediante
un procedimiento y viceversa. La elección de una u otra alternativa se suele hacer en función de
su comodidad de uso (las funciones devuelven obligatoriamente un valor a través de su nombre
y los procedimientos no).
19. Pasaje de parámetros

Al invocar a un subprograma se le pueden pasar parámetros, los cuales pueden consistir de
valores de variables declaradas en el módulo invocador. El paso de tales parámetros puede
hacerse de dos maneras:
 Por valor (datos de entrada)
 Por referencia o variable (datos de salida, datos de entrada-salida)
Notas:
1. Ambos métodos de paso de parámetros se aplican tanto a la llamada de funciones como a las
de procedimientos.
2. Una función tiene la posibilidad de devolver valores al programa principal (u otro subprograma)
de dos formas: a) como valor de la función, b) por medio de parámetros por referencia (aunque
esta última opción generalmente no se usa).
3. Un procedimiento solo puede devolver valores por medio de parámetros por referencia.
21/26
Pascal
Paso por VALOR
El paso de parámetros por valor consiste en enviar una COPIA del valor de la variable al
subprograma llamado/invocado.
Los cambios a la copia no afectan el valor de la variable original una vez que se terminó de
ejecutar el subprograma. De esta manera se asegura que el valor de la variable original sólo
puede ser modificado por el módulo que la declaró.
Un parámetro por valor actúa como una variable local del subprograma (con la particularidad de
que su valor será inicializado por el módulo llamador).
En Object Pascal, por defecto, los parámetros se consideran pasados por valor.
Paso por REFERENCIA

En el caso de que se requiera que el valor de una variable sea modificado por el módulo invocado,
debe hacerse el paso de parámetro por referencia, por medio del cual el módulo invocado

tiene acceso a la dirección en que se guarda el valor a modificar.
Los cambios que se hagan sobre a un parámetro por referencia persistirán después de la
ejecución de la función.
Aquí la/el función/procedimiento recibe exactamente la variable enviada, no una copia; si algo se
le hace al parámetro, se le está haciendo directamente a la variable.
En Object Pascal a los parámetros pasados por referencia se les antepone la cláusula VAR.
Ejemplo:
Program UnoDosTres;
Var
T,Z: Integer;
Procedure Uno(N, X: Integer);

Begin
N:= N/100;
X:= X + N;
End;
Procedure Dos(N: Integer; Var X: integer);
Begin
N:= N/100;
X:= X + N;
End;
Procedure Tres(Var N, X: integer);
Begin
N:= N/100;
X:= X + N;
End;
Begin {Programa principal}

T:=100;
Z:=200;
Uno(T, Z);
Write('T es:',T,'y Z es:',Z); {Imprime: T es 100 y Z es 200}
Dos(T, Z);
Tres(T, Z);
End.
22/26
Pascal
20. Ambito (o tiempo de vida) de variables y demás identificadores
Según el lugar donde son declaradas puede haber dos tipos de variables:
Variable Global: Es toda aquella declarada en el programa principal; permanece activa

durante todo el programa (se crea al iniciarse éste y se destruye de la memoria al finalizar).
Puede ser utilizada en cualquier procedimiento o función.
Variable Local: Es aquella declarada dentro de un subprograma y es creada cuando el
programa llega a la invocación de la función o procedimiento en la que está definida. Al finalizar
la ejecución de la función (o el procedimiento) en el que está declarada, desaparece de la
memoria.
Si dos variables, una global y una local, tienen el mismo nombre, la local prevalecerá sobre la
global dentro del subprograma en que ha sido declarada.
El uso de variables locales tiene muchas ventajas. En particular, hace a los subprogramas
independientes, con la comunicación entre el programa principal y los subprogramas manipulados

estructuralmente a través de la lista de parámetros. Para utilizar un procedimiento sólo
necesitamos conocer lo que hace y no tenemos que estar preocupados por su diseño, es decir,
cómo están programados.
Ahora bien, esta noción de “local” y “global” es extensiva a cualquier identificador (variables,
constantes, procedimientos, funciones y tipos).
El ámbito de un identificador es la parte del programa donde se conoce el identificador

(donde se puede utilizar).
Trabajemos estos conceptos con ejemplos: La figura a continuación muestra un esquema de

un programa con diferentes procedimientos, variables locales y globales, junto con el ámbito de
cada definición.
Los identificadores del programa “Principal” se clasifican
de la siguiente manera:
Identificadores globales del x, y, f1, f2

programa Principal
Identificadores locales de F1 a, i
Identificadores locales de F2 t, m
En el ejemplo, dentro de las funciones F1 y F2 pueden

emplearse las variables globales del programa x e y,
pero en el cuerpo del programa no pueden emplearse
las variables locales i y m o los parámetros a y t de
las funciones. Éstos sólo pueden emplearse dentro de
sus respectivas funciones, F1 y F2, exclusivamente.
Estas rutinas delimitan unos niveles o bloques fuera de
los cuales no puede utilizarse lo declarado dentro de
ellas.
El ámbito de uso de cualquier identificador que se declare en una rutina, está restringido al nivel o
bloque donde se ha declarado y, a partir de su declaración en la secuencia de código, nunca
antes.
Caso de llamadas a rutinas (procedimientos y/o funciones)
Las llamadas a las rutinas pueden realizarse, no sólo desde el cuerpo del programa principal, sino
también desde el cuerpo de los propios procedimientos y funciones, siempre y cuando la rutina a
la que se realice la llamada esté previamente declarada. Por ejemplo, dadas la estructura y
declaraciones de un programa anterior. Desde el cuerpo del programa principal pueden hacerse
llamadas a las funciones F1 y F2. Desde el cuerpo de la función F2 pueden realizarse llamadas a
23/26
Pascal
F1 pero no al revés, ya que la función F2 se declara después que F1. Es decir, sólo puede
emplearse lo que esté previamente declarado en el código del programa.
Anidamiento de rutinas (procedimientos y/o funciones)
Por otro lado, en un programa pueden existir subrutinas definidas dentro de otras. Esto es lo que
se conoce como anidamiento y da lugar a la existencia de una jerarquía de niveles y de una serie
de reglas que permiten determinar qué elementos se pueden utilizar en un determinado punto del
programa. Por ejemplo, en el programa mostrado a continuación se han declarado varias rutinas
anidadas.
En el programa principal pueden emplearse las
variables globales a y b y los procedimientos,
también globales, pro1 y pro4.
En el cuerpo del procedimiento pro1 pueden
utilizarse el parámetro formal c, las variables
locales d y e y los procedimientos locales

pro2 y pro3 y el propio procedimiento pro1
(esto se llama recursividad). También pueden

emplearse las variables globales a y b.
En el cuerpo del procedimiento pro2 pueden
emplearse el parámetro formal f, la variable
local g, el propio procedimiento pro2, así
como todo lo ya previamente declarado en los
niveles superiores que lo contienen, en este
caso, en el procedimiento pro1 (parámetro
formal c y variables locales d y e) y en el
cuerpo del programa principal (variables
globales a y b y el procedimiento pro1).
Dentro del procedimiento pro3 pueden

utilizarse el parámetro formal h, la variable
local i, las variables locales d y e, el
parámetro formal c y el procedimiento local
pro2 declarados en el procedimiento pro1, el
propio procedimiento pro3, así como las
variables globales a y b y el procedimiento
pro1.
En el procedimiento pro4 pueden emplearse
el parámetro formal j, la variable local a y los
procedimientos pro5 y pro6 y el propio procedimiento pro4. Además pueden emplearse la
variable global b y el procedimiento pro1.
Se deja como ejercicio, determinar qué elementos pueden emplearse en el cuerpo de los
procedimientos pro5 y pro6.
21. Listado de funciones y procedimientos predefinidos

Serán funciones salvo que se indique lo contrario.
 Arctan(n) Calcula el arco tangente de un número n dado.
 Cos(x) Calcula el coseno de x.
 Exp(x) Calcula la exponencial de x.
 Sin(x) Devuelve el seno de x en radianes.
 Sqr(n) Devuelve el cuadrado de un número n.
 Sqrt(n) Devuelve la raíz cuadrada de un número n.
24/26
Pascal
 Power(b, e) Devuelve be, se debe incorporar en la parte uses del programa la palabra Math,
que hace referencia a una unit donde está implementada la función power.
 Dec(n) Decrementa una variable del tipo integer. (procedimiento)
 Inc(n) Incrementa una variable del tipo integer. (procedimiento)
 Succ(n) Devuelve el sucesor de un valor entero.
 Int(x) Devuelve la parte entera de un número real x.
 Trunc(x) Trunca un número real x a un entero.
 Round(x) Devuelve el entero más próximo al valor de x; si la parte decimal de x es menor que
0.5 devuelve lo mismo que trunc (x), el entero inferior. Si la parte decimal de x es mayor que
0.5 devuelve el entero siguiente9.
 Val(s) Convierte de String a formato numérico; devuelve el valor numérico de una cadena de
caracteres s, ó 0 si la cadena s no contiene un número válido.

 Str(n) Convierte el número n en formato String.
 FloatToStr(x) Convierte un número real x a Formato String.

 StrToFloat(s) Convierte un string s en un valor de punto flotante.
 StrToInt(s) Convierte un string s en un integer.
 FloatToStr(f) Convierte un valor en punto flotante f en un string.
 IntToStr(n) Convierte un entero n en un string.
 TimeToStr(t) Convierte un valor del tipo TtimeDate en String, extrayendo la hora.
 DateToStr(d) Convierte un valor del tipo TtimeDate en String, extrayendo la fecha.
 Copy(s, i, n) Devuelve un substring de un string s que comienza en s[i] y tiene longitud n.
 Insert(s1, s, i) Inserta un substring s1 en s a partir de la posición s[i]. (procedimiento)

 Length(s) Devuelve la longitud de un string s.
 LowerCase(s) Convierte un string a minúscula.
 UpperCase(s) Devuelve un string en mayúscula.
 Pos(subs, s) Devuelve la posición del primer carácter de un substring subs dentro de un string
s.
 Delete(s, i, n) Elimina del texto s, a partir del caracter i-ésimo de s, n caracteres.
(procedimiento)
 Concat(s1, s2) Devuelve el texto formado por unir el string s1 seguido del string s2.
 date Devuelve la fecha actual.
 now Devuelve la fecha y hora actual.
 time Devuelve la hora actual.
 Length(a) Devuelve la longitud de un array a.
 Random(n) Genera un número aleatorio entre 0 y n, o entre 0 y 1 sino se le pasa n. Inicializar
con el procedimiento randomize.
 beep Genera el beep estándar usando el parlante de la PC. (procedimiento)
22. Apéndice A – Mini Diccionario Inglés Español
25/26
Pascal
26/26

Pascal Prog

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Pascal Prog

Uploaded by

Copyright:

Available Formats

Pascal

Pascal: Tabla de Contenido

Lazarus (Object Pascal)

Introducción a la Programación – Prof. Laura Kees – Año 2015

Introducción a la Programación – Prof. Laura Kees – Año 2015

El microprocesador, que es el que ha de ejecutar cada programa, sólo entiende el lenguaje

4. Características de los programas en Pascal

Introducción a la Programación – Prof. Laura Kees – Año 2015

USES librería [, librería ...];

{Declaración de procedimientos y funciones}

BEGIN {Cuerpo del programa principal}

Programación en consola de LAZARUS

1. En el menú Principal, seleccionar Archivo.

2. Seleccionar la opción Cerrar todos los archivos del editor

Introducción a la Programación – Prof. Laura Kees – Año 2015

3. Seleccionar la opción Nuevo para crear un nuevo proyecto.

6. Estructura general de un proyecto nuevo

Introducción a la Programación – Prof. Laura Kees – Año 2015

En la figura 3, podemos apreciar el archivo de proyecto de consola, donde escribiremos nuestro

Introducción a la Programación – Prof. Laura Kees – Año 2015

Program Ejemplo; Program Ejemplo;

ShortInt Números enteros entre -128 y 127 1

LongInt Números enteros entre –2147483648 y 2147483647 4

Integer Números enteros entre -2147483648 y 2147483647 2ó4

Char Un caracter cualquiera. 1

Introducción a la Programación – Prof. Laura Kees – Año 2015

9. Asignación de valores a variables

10. Instrucciones simples y compuestas

Introducción a la Programación – Prof. Laura Kees – Año 2015

11. Operadores aritméticos y relacionales

12. Precedencia de los operadores

Introducción a la Programación – Prof. Laura Kees – Año 2015

13. Funciones predefinidas

Vemos en el ejemplo anterior la utilización de funciones predefinidas: éstas son pequeños

Veamos la definición de la función Sin, tal como aparece en la ayuda de Lazarus:

Introducción a la Programación – Prof. Laura Kees – Año 2015

14. Mostrando mensajes en pantalla

Ejemplo 1: la siguiente secuencia de instrucciones

Imprimirá por pantalla:

Ejemplo 2: la siguiente secuencia de instrucciones

Imprimirá por pantalla:

Ejemplo 3: la siguiente secuencia de instrucciones

write(“Presione Enter para continuar.”);

El resultado es: 1000

Una forma equivalente de obtener la misma salida por pantalla es:

writeln(“El resultado es: ”, numero);

write(“Presione Enter para continuar.”);

15. Ingreso de datos por parte del usuario

Introducción a la Programación – Prof. Laura Kees – Año 2015

16. Estructuras de decisión

Estructura de Decisión Simple

Introducción a la Programación – Prof. Laura Kees – Año 2015

EJEMPLO 2 – IF/ELSE CON IF ANIDADO

write(‘buenas, como está usted?’)

Estructura de Decisión Múltiple

El selector es una variable de un tipo que se

Introducción a la Programación – Prof. Laura Kees – Año 2015

17. Estructuras de iteración (repetición)

Introducción a la Programación – Prof. Laura Kees – Año 2015

Intrucción FOR (repetir n veces).

for variableContador := valor_inferior to valor_superior do

for variableContador := valor_superior downto valor_ inferior do

Esta instrucción ejecuta los siguientes pasos:

Introducción a la Programación – Prof. Laura Kees – Año 2015