Anda di halaman 1dari 9

PASCAL

• Sentencias compuestas
• Sentencias repetitivas
o Ciclos FOR
o Ciclos WHILE
o Ciclos REPEAT-UNTIL
• Bifurcaciones condicionales
o IF...THEN...ELSE
o IF anidados
o CASE

Sentencias compuestas
Las sentencias compuestas son grupos de sentencias, separadas cada una por un punto y coma ";" que
son tratadas como una sola sentencia.
Para identificar una sentencia compuesta de un grupo sucesivo de sentencias se encierran entre las
palabras reservadas BEGIN y END. Uno de los ejemplos más claros de una sentencia compuesta es el
cuerpo de un programa principal en Turbo Pascal, el lenguaje toma todo lo que existe entre estas dos
sentencias como un solo elemento a ejecutarse aún cuando contenga varias instrucciones o sentencias:

PROGRAM Prueba;

BEGIN
WriteLn('Primera linea de una sentencia compuesta');
WriteLn('Segunda linea de una sentencia compuesta');
WriteLn('Tercera linea de una sentencia compuesta');
END.

El punto y coma que se encuentra antes de la palabra reservada END puede ser suprimido sin afectar a
la compilación. En ocasiones es necesario repetir un determinado número de veces la ejecución de una
sentencia, ya sea sencilla o compuesta, para realizar esta tarea Turbo Pascal cuenta con instrucciones
específicas para el tipo de repetición que se requiera.

Ciclos FOR
El ciclo FOR repite una sentencia un determinado número de veces que se indica al momento de llamar
al ciclo.
Lo que hace FOR es que incrementa una variable en uno desde un valor inicial hasta un valor final
ejecutando en cada incremento la sentencia que se quiere repetir. Su sintaxis es:
FOR identificador := inicio TO fin DO instrucción;
Donde el identificador es la variable que se incrementará, inicio es el primer valor que tendrá dicha
variable y fin es el valor hasta el cual se incrementará la misma; instrucción es la sentencia (sencilla o
compuesta) que se ejecutará en cada incremento de la variable.
El siguiente ejemplo escribe los números del 1 al 50 en pantalla. La variable utilizada es "Numero".

PROGRAM Ciclo_FOR;
VAR
Numero : Integer;

BEGIN
FOR Numero := 1 to 50 DO
WriteLn(Numero);
END.

Una de las limitaciones de los ciclos FOR es que una vez iniciado el ciclo se ejecutará el número de
veces predefinido sin posibilidad de agregar o eliminar ciclos.
Es posible hacer que un ciclo cuente hacia atrás, es decir que la variable en lugar de incrementarse se
decremente. Para ésto cambiamos la palabra TO por DOWNTO, y colocamos el valor mayor a la
izquierda y el menor a la derecha. Ejemplo:

PROGRAM Ciclo_FOR_2;
VAR
Numero : Integer;

BEGIN
FOR Numero := 50 DOWNTO 1 DO
WriteLn(Numero);
END.

Ciclos WHILE
Los ciclos WHILE ofrecen la ventaja de que la ejecución se realiza mientras se cumpla una condición,
por lo tanto es posible controlar el número de repeticiones una vez iniciado el ciclo. Su sintaxis es:
WHILE condición DO instrucción
Donde condición es la condición que se evaluará, mientras ésta sea verdadera se ejecutará la
instrucción, que es una sentencia simple o compuesta.
Un programa que escriba los números del 1 al 50, utilizando el ciclo WHILE se vería como sigue:

PROGRAM Ciclo_WHILE;
VAR
Numero : Integer;

BEGIN
Numero := 1;
WHILE Numero <= 50 DO
BEGIN
WriteLn (Numero);
Numero := Numero +1;
END;
END.

Al final del programa la variable Numero guardará el valor 51, que fué el valor que no cumplió con la
condición establecida en el ciclo WHILE.

Ciclos REPEAT-UNTIL
Este tipo de ciclos es muy parecido a los ciclos WHILE, la diferencia entre ambos es que en WHILE la
condición se evalúa al principio del ciclo, en cambio en REPEAT-UNTIL se evalúa al final, lo que
significa que en un ciclo REPEAT-UNTIL la sentencia se ejecutará por lo menos una vez, cosa que
puede no ocurrir en el ciclo WHILE. Ejemplo:

PROGRAM Ciclo_WHILE;
VAR
Numero : Integer;
BEGIN
Numero := 1;
WHILE Numero <= 50 DO
BEGIN
WriteLn (Numero);
Numero := Numero +1;
END;
END.

Para crear un buen programa es necesario dotarlo con capacidad de desición con base en las variables
o eventos definidos por el programador, para que el programa sea aplicable en un entorno más
generalizado y no solo para un problema específico.
Para lograr este control se cuenta con las estructuras de control que, en Turbo Pascal, son las
siguientes:

Sentencia IF...THEN...ELSE
Esta expresión es utilizada para ejecutar una sentencia en el caso que una condición establecida sea
verdadera, de lo contrario se podra ejecutar una sentencia distinta. Su sintaxis es:
IF condición THEN instrucción ELSE otro
Donde condición es la expresión que se evaluará, en caso de ser verdadera se ejecutará la sentencia
dada como instrucción, en caso de que la condición sea falsa se ejecutara la sentencia dada como otro.
Ejemplo:

PROGRAM IF_THEN_ELSE;
VAR
Contador : Integer;
BEGIN
FOR contador := 1 to 50 DO
BEGIN
IF contador > 10 THEN WriteLn(Contador) ELSE WriteLn('*');
END;
END.

En este pequeño programa la variable Contador se incrementará desde 1 hasta 50, la sentencia
condicional IF verificará si es verdad que Contador es mayor a 10, de ser así se escribirá en pantalla el
valor de la variable, de lo contrario se escribira en la pantalla un caracter "*". Como el contador inicia
desde 1, tenemos que se imprimiran 10 asteriscos antres del primer número, que será el 11, valor que
si cumple la condición "Contador > 10" (la hace verdadera).
La sección ELSE con su correspondiente sentencia son opcionales y pueden omitirse en caso de no
necesitarse.

Sentencias IF anidadas
Es posible utilizar en una expresión del tipo IF..THEN..ELSE una sentencia compuesta como la
sentencia a ejecutarse en caso de que la condición sea verdadera, así como en la sentencia posterior a
un ELSE, de esta forma podemos utilizar otra sentencia IF..THEN..ELSE dentro de la anterior, para de
esta forma evaluar varias condiciones una dentro de otra. Ejemplo:

IF Numero > 5 THEN


BEGIN
IF Numero <10 THEN Opcion :="Numero;<BR"> IF Numero <30 THEN Opcion2 :="Numero;<BR"> END
Selecciones CASE
Esta forma de control se utiliza cuando se va a evaluar una expresión que puede contener varios datos
diferentes y en cada dato deberá realizar una acción especial. Por ejemplo, si se crea un menú con
diferentes opciones se realizará un determinado proceso para cada acción, aunque la selección por
parte del usuario se haga desde el mismo lugar.
El siguiente programa ilustra el uso de la forma CASE, el programa preguntará un número al usuario y
lo clasificará de acuerdo a su valor.

PROGRAM Case;
VAR
Numero : Integer;
BEGIN
WriteLn('Introduzca un número entero del 1 al 5: ');
ReadLn(Numero);
CASE Numero OF
1 : WriteLn('El número fué 1');
2 : WriteLn('El número fué 2');
3 : WriteLn('El número fué 3');
4 : WriteLn('El número fué 4');
5 : WriteLn('El número fué 5');
ELSE WriteLn('El número no estaba en el rango indicado');
END.
Contenidos > 3.2 Repetitiva repetir...hasta

En Pascal, para escribir una instrucción repetitiva repetir...hasta se utiliza la sintaxis:

repeat
<bloque_de_instrucciones>
until <expresión_lógica>;

Como se puede apreciar, la instrucción repetitiva repeat...until, también hace uso de una condición.

En un bucle repeat...until, primero se ejecuta el bloque de instrucciones y, después, se evalúa la


condición. En el caso de que ésta sea falsa, se vuelve a ejecutar el bloque de instrucciones. Y así
sucesivamente, hasta que, la condición sea verdadera.

Por consiguiente, cuando el flujo de un programa llega a un bucle repeat...until, existen dos
posibilidades:

1. Se ejecuta el bloque de instrucciones y, después, si la condición se evalúa a verdadera, el


bloque de instrucciones no se vuelve a ejecutar, de manera que, el bucle repeat...until finaliza,
habiendo realizado una sola iteración.
2. Se ejecuta el bloque de instrucciones y, a continuación, si la condición se evalúa a falsa, el
bloque de instrucciones se vuelve a ejecutar. Y así sucesivamente, hasta que la condición
sea verdadera.

El <bloque_de_instrucciones> de un bucle repeat...until puede ejecutarse una o más veces


(iteraciones). También hay que prevenir que el bucle no sea infinito.

En resumen, una instrucción repetitiva repeat...until permite ejecutar repetidamente (una o más
veces) un bloque de instrucciones, hasta que, una determinada condición sea verdadera.

Ejemplo 1: De modo que, utilizando un bucle repeat...until, el problema del ejemplo 1 del apartado
anterior, 3.1 Repetitiva mientras, se puede resolver con el código:

program EJE13101;

uses Crt;

var Contador : Integer;

begin
ClrScr;
GotoXY( 4, 2 );

Contador := 1; { Inicializacion del contador }


repeat
Write( Contador, ' ' ); { Salida }
Contador := Contador + 1; { Incremento }
until Contador > 10; { Condicion }
end.

Programa (.PAS): Números del 1 al 10 (repeat...until)

Como ya se ha dicho, el bucle repeat...until puede iterar una o más veces, por tanto, cuando un bloque
de instrucciones debe iterar al menos una vez, generalmente, es mejor utilizar un bucle repeat...until
que un bucle while, como por ejemplo, en el siguiente problema.

Ejemplo 2: Se quiere escribir un programa que:


1º) Pida por teclado un número (dato entero).
2º) Pregunte al usuario si desea introducir otro o no.
3º) Repita los pasos 1º y 2º, mientras que, el usuario no responda 'n' de (no).
4º) Muestre por pantalla la suma de los números introducidos por el usuario.

En pantalla:
Introduzca un numero entero: 7
¿Desea introducir otro (s/n)?: s
Introduzca un numero entero: 16
¿Desea introducir otro (s/n)?: s
Introduzca un numero entero: -3
¿Desea introducir otro (s/n)?: n
La suma de los numeros introducidos es: 20

El código propuesto es:


program EJE13121;
uses Crt;
var
Seguir : Char;
Acumulador, Numero : Integer;
{ En Acumulador se va a guardar la suma de los numeros introducidos por el usuario. }
begin
ClrScr;
Acumulador := 0;
repeat
WriteLn;
Write( ' Introduzca un numero entero: ' );
ReadLn( Numero );
Acumulador := Acumulador + Numero;
WriteLn;
Write( ' Desea introducir otro numero (s/n)?: ' );
ReadLn( Seguir );
until Seguir = 'n';
{ Mientras que el usuario desee introducir mas numeros, el bucle iterara. }
WriteLn;
Write( ' La suma de los numeros introducidos es: ', Acumulador );
end.

Programa (.PAS): Suma de números introducidos por el usuario


Formato de Enteros y dos decimales:

Ejem.
Mostrar la salida formateada para números decimales.

Program formato;
Var
N:Real;
Begin
N:= 113;
Writeln ('Formato por defecto',n);
Writeln ('Anchura 8:1', n:8:1);
Writeln ('Anchura 8:3', n:8:3)
End.

Ejecución:
Formato por defecto _____ 3.33333333335E-01
Anchura 8:1 ____________ 0.3
Anchura 8:3 ____________ 0.333

IF THEN ELSE.

Formato:
IF (expresión lógica o booleana) THEN Sentencial (simple o compuesta)
ELSE Sentencia2 (simple o compuesta);

Ejem.
IF n>O then Writeln (`Número positivo');
IF n>O then
Writeln (`Número positivo')
ELSE
Writeln (`Negativo o cero');
No puede existir un punto y coma inmediatamente antes de una palabra ELSE ya que sería
interpretado como final de IF.

CASE OF

Formato:
CASE (expresión o variable) OF
(lista de constantes1):(sentencia1);
(lista de conslantes2):(sentencia2);
(lista de constantes3):(senteneia3);
...
(lista de constantesN):(sentenciaN);
ELSE (SENTENCIA)
...
END;
Ejem.

Program menu;
Var
Numerodia: integer;
Begin
Write('introduzca el ordinal de un día laborable de la semana:')
Readín (numerodia);
Write (`Hoy es ');
Case numerodia Of
1:Writeln ('Lunes');
2:Writeln ('Martes');
3:Writeln ('Miercoles');
4:Writeln ('Jueves');
5:Writeln ('Viernes');
6:Writeln ('Sábado')
Else
Writeln ('¡¡¡Domingo!!! No es día laborable');
End.

SENTENCIA REPEAT UNTIL


Ejecuta las sentencias comprendidas entre las palabras reservadas REPEAT y UNTIL hasta que la
expresión o variable sea verdadera.

Formato:
REPEAT
begin
(Sentencia);
(Sentencia);
...
end;
UNTIL condición;

Características del bucle REPEAT:


Se ejecutan siempre una vez, por lo menos, y la terminación del bucle se produce cuando el valor de la
expresión lógica o condición de salida es verdadera. Se ejecuta hasta que la expresión es verdadera,
es decir, se ejecuta mientras la expresión sea falsa.

Ejemplo.
El mismo que con la sentencia WHILE.

Program escribeenteros;
Var
N,contador:integer;
Begin
Write ('Introduzca número máximo de enteros: '); Readin (N);
Contador:= O;
Repeat
Contador:=contador+1; Write (contador:5)
Until contador = N;
Writeln ('Fin de programa. Contador = ',contador)
End.
SENTENCIA FOR

Repite la ejecución de una o varias sentencias un número fijo de veces. previamente establecido.
Necesita una variable de control del bucle que es necesariamente de tipo ordinal, ya que el bucle se
ejecuta mientras la variable de control toma una serie consecutiva de valores de tipo ordinal,
comprendidos entre dos valores extremos (inferior y superior).

Formato ascendente:
FOR variablecontrol:=valorinicial TO valorfinal DO
(sentencia);

Formato descendente:
FOR variablecontrol:=valorincial DOWNTO valorfinal DO
(sentencia); donde (sentencia) puede ser una sentencia simple o compuesta.

Ejemplo:
El mismo que con la sentencia WHILE.

Program escribeenteros;
Mar
N,contador: integer;
Begin
Write ('Introduzca numero maximo de enteros: ');
Readln (N);
For contador:=1 to n do
Write (contador:5);
Writeln
End.