Turbo Pascal es un "lenguaje de programación de alto nivel" bajo entorno ms-

dos, con esta poderosa herramienta, se pueden crear un sin número de

aplicaciones que van desde simples operaciones aritméticas como sumas,
restas, hasta sistemas operativos, lenguajes de programación, simulaciónes,
videojuegos, manejadores de base de datos, virus y una amplia gama de
programas cuyo único límite es solo la imaginación del programador.
Armar un programa en Turbo Pascal es como jugar con bloques de
construcción o legos; en estos se unen bajo un orden determinado una serie
de piezas para lograr componer una figura determinada, al final a muchos no
les interesa el resultado sino la forma que se constituyo; de igual modo, Pascal
se compone de una serie de "PIEZAS" (Comandos, procedimientos, funciones,
ciclos, sentencias, etc) las cuales permiten armar una determinada aplicación
para dar solución a una necesidad o problema, esto se hace colocando
cuidadosamente en su sitio correcto la "PIEZA" a "ENSAMBLAR" para que al
final toda esta serie de partes "EMPALMEN" corretamente (como quien arma el
motor de un automovil) y den marcha a la aplicación perseguida.
A pesar de que Turbo Pascal es un lenguaje orientado a objetos, este tutor
esta orientado a programación estructurada. En el recorrido que vayas
haciendo se explicarán los comandos básicos, con varios códigos fuente y
archivos ejecutables para cada uno de ellos, los cuales los puedes descargar, y
correr en tu computadora. Para ello debes tener instalado el Turbo Pascal sea
Versión 6.0 o 7.0.

Esta línea de código consiste en la palabra program seguida de un

nombre identificador que se lo da el usuario de acuerdo al tipo de programa
que sé este realizando, cabe destacar de que al igual que otros lenguajes no se
permiten el uso de palabras reservadas porque sé produciran errores
de compilación y por consiguiente los primeros dolores de cabeza en tus
primeros pininos como programador.

Begin {Inicio del programa principal}

Bloque de instrucciones
Comentarios y Asignaciones (Cabe destacar de que estos
pueden ir en cualquier parte del programa)
End. {final del programa principal}

Las unidades son aquellos bloques de código que proporcionan funciones y

procedimientos que TURBO PASCAL trae incluidas en el archivo TURBO.TPL
(Turbo Pascal Libraries), siempre se invocan precedidas por la palabra
reservada Uses;
Esta serie de herramientas son las que nos permiten construir poderosas
aplicaciones como juegos, simulaciones o uno que otro viruscito;
Ejemplo:
Uses crt;
Uses graph;
Uses dos;
Unidades incluidas
Crt (catode ray tube)
Esta unidad provee rutinas de control sobre el modo de la pantalla, códigos
extendidos de teclado, colores, ventanas y sonidos.
Graph
Esta es una de las mas divertidas unidades, pues con la diversidad de
funciones y procedimientos que provee, sumados a unos sencillos algoritmos
permite hacer desde una simple linea o un círculo hasta una simulación
matemática o un videojuego como pacman o tetrix.

Dos
Esta unidad nos brinda las rutinas necesarias para interactuar con el sistema
operativo D.O.S. permitiendo tomar desde la hora o fecha del sistema hasta
ejecutar programas o comandos.
Printer
Permite imprimir lineas y archivos de tipo texto, si se quieren imprimir gráficos
hay que recurrir a una serie de truquitos.
Aunque hay muchas mas unidades, os aseguro que para aprender a programar
en Turbo Pascal solo se necesitan las cuatro anteriores, eso sí, teniendo en
cuenta que el programador puede crear sus propias unidades.

Constantes
Estas sirven para establecer valores que no cambiaran durante la ejecución del
programa, siempre van precedidas de la palabra reservada CONST, luego se
coloca el identificador (o nombre que le vas a dar, por sino me entiendes), un
igual (=) y el valor al cual se quiere asignar la constante.
Ejemplo:
CONST
PI=3.1416;
MENSAJE=’VIVA COLOMBIA!!’;
NUMERO_ENTERO=12;
También se pueden definir constantes con tipo, aunque estas ya no serán tan
constantes del todo, pues el valor que se les asigna inicialmente puede
cambiar.
Ejemplo:
CONST
VaIor_parcial:integer=4;
Nombre:string[10]=’COMPUTADOR’;
Valor_real:real=0.3929;
Bandera:boolean=true;

Tipos
Estos (valga la redundancia) son tipos de datos más complejos, es decir una

agrupación de tipos de datos básicos , entre estos

podemos destacar: ARREGLOS, REGISTROS y CONJUNTOS.
Arreglos: Un Array o arreglo es una variable que repite un tipo de datos un
número limitado de veces, la sintaxis es la siguiente:
Nombre_arreglo=array[limite_inferior . . limite_superior]of tipo de datos
Donde :
Nombre_arreglo
Hace referencia al identificador del tipo de dato del que más adelante se
sacarán las variables, este puede ser cualquiera, pero es aconsejable que este
relacionado con la función que se va a desarrollar.
Array
Es la palabra reservada que le indica a Pascal que se va a definir un tipo
Arreglo

En estos paréntesis cuadrados se indica la extensión del arreglo y la forma,

que puede ser:
1. Vectores
El límite inferior empieza en 1 y el superior es un valor entero positívo, a
continuación te muestro tres de las formas para declararlos:
Program forma1;
Uses crt;
Const
Maximo=10;
Type
Vector=array[1..Maximo] of integer;
Program forma2;
Uses crt;
Const
Maximo=10;
Type
Contenido=1..Maximo;
Vector=array[Contenido] of integer;
Program forma3;
Uses crt;
Const
Maximo=10;
Var
Vector:array[1..Maximo] of integer;
2. Matrices
Observando las gráficas puedes ya determinar la diferencia entre un vector y
una matriz, esta última está compuesta por filas y columnas, para declararse el
primer factor en los parentesis cuadrados[]hace referencia a las filas, y el
segundo a las columnas, ahora veamos varias formas de declarar una matriz.
Program forma1;
Uses crt;
Const
Maxima_fila=10;
Maxima_columna=10;
Type
Matriz=array[1..Maxima_fila,1..Maxima_columna] of integer;
Program forma2;
Uses crt;
Const
Maxima_fila=10;
Maxima_columna=10;
Type
Contenido=1..Maxima_fila,1..Maxima_columna;
Matriz=array[Contenido] of integer;
Program forma3;
Uses crt;
Const
Maxima_fila=10;
Maxima_columna=10;
Var
Matrizr:array[1..Maxima_fila,1..Maxima_columna] of integer;

A continuación te doy unos ejemplos básicos de vectores y matrices:

Ejemplos en archivos (arreglo.exe)

Una aplicación práctica y divertida de las matrices son los videojuegos, algunos
de los que has manejado utilizan matrices y vectores para su funcionamiento,
de estos podemos destacar:

Registros: Sirven para agrupar diferentes tipos de datos en uno nuevo, la

sintaxis es la siguiente:

Nombre_del_registro=RECORD
Campo1 : Tipo Campo1;
Campo2: Tipo Campo2;
Campo3: Tipo Campo3;
.
.
.
Campon : Tipo Campon;
End;
Ejemplo:
Type
Datos_estudiante=RECORD
Nombre : string[40];
Dirección : string[50];
Telefono : string[15];
Edad : byte;
Mujer : boolean;
END;
Var
Tabla_estudiantes: Datos_estudiante;
Se puede acceder a elementos de un registro de dos formas:
Por referencia Explicita
En este tipo de asignación se usa el nombre de la variable registro seguido por
un punto y a continuación el nombre del campo, haciendo uso del ejemplo
podría quedar así:
Tabla_estudiante.nombre:=’Daniel’;
Tabla_estudiante.direccion:=’Popayan, Cauca’;
Por referencia Implicita
En este caso se usa la sentencia WITH, la cual facilita enormemente el acceso,
pues aquí no se debe repetir el nombre del registro cada vez que se hace una
asignación.
Ejemplo:
WITH Tabla_estudiante DO
BEGIN
Nombre:=’Daniel’;
Direccion:=’Popayan, Cauca, Colombia’;
END;
Se puede tambien para algunos tipos de problemas declarar arreglos de
registros así:
TYPE
Datos_estudiante=RECORD
Nombre : string[40];
Dirección : string[50];
Telefono : string[15];
Edad : byte;
Mujer : boolean;
END;
Arreglo_de_registros =ARRAY[1..50] of Datos_estudiante;
Var
Listado_estudiantes:Arreglo_de_registros;
Para acceder la información sé hara de la siguiente forma:
Listado_estudiantes[1].nombre:=’Daniel’;
Listado_estudiantes[1].direccion:=’Popayan, Cauca’;
O tambien dentro de un ciclo.

Variables
Una variable es un nombre o identificador que "representa" a una porción de
memoria donde se almacenan temporalmente los datos que cambiaran durante
la ejecución del programa; para definir una variable (\DVHDHQHOSURJUDPD
SULQFLSDOHQXQSURFHGLPLHQWRXQDIXQFLyQRXQDXQLGDG) se debe escribir la
palabra reservada VAR en la sección de definición de variables, luego el
nombre o identificador ((VWHQRSXHGHVHUXQDpalabra reservada \VH
DFRQVHMDVHDUHODFLRQDGRFRQODWDUpDTXHYDDGHVHPSHxDU), y por último el
tipo de datos al que va a pertenecer.
Sintaxis
VAR

Nombre_variable : Tipo de dato

PROCEDIMIENTOS y
FUNCIONES
En algunas ocasiones se debe llamar un bloque de código mas de una vez,
una forma de hacerlo es escribir las instrucciones tantas veces como se
necesite, tornando de esta manera programas con exceso de código y
dificultad para descubrir posibles errores, la otra es meter las instrucciones en

subprogramas que se invocan cada vez que se necesiten.

Los procedimientos y funciones se declaran o escriben antes del begin
principal, un procedimiento o función puede contener otros procedimientos y
funciones.
En resumen: Las subrutinas son escensialmente partes separadas de código

que ejecutan tareas pequeñas de un programa GRANDE.

PROCEDIMIENTOS
Un procedimiento es un grupo de sentencias que realizan una tarea concreta.
En lugar de reescribir el código completo de esa tarea cada vez que se
necesite, únicamente se hace una referencia al procedimiento. Estos pueden
recibir o enviar información el programa principal, técnicamente se conoce
como PASO DE PARAMETROS, que puede ser POR TRANSFERENCIA o
POR VALOR.
Sintaxis
Procedure NOMBRE_DEL_PROCEDIMIENTO
CONSTANTES
TIPOS
VARIABLES
PROCEDIMIENTOS Y FUNCIONES
BEGIN
{Bloque de instrucciones}
END;

Este sencillo programita ilustra la forma de utilizar procedimientos sencillos

program Procedimientos_sencillos;
procedure Nombre;
begin
Writeln('
Este Robot aun no tiene nombre' );
end;
procedure Direccion;
begin
Writeln('
C:\mis documentos\imágenes\caricaturas\' );
end;
procedure Telefono;
begin
Writeln(’0000 sin corriente’);
end;
begin{Inicio del programa principal}
{Se invocan los diferentes procedimientos
Declarados anteriormente}
Nombre;
Dirección;
Telefono;
Readln;
end. {Final del programa principal}

Ahí te va otro ejemplo:

program Otro_procedimiento_sencillo;
var Contador : integer;
procedure Escribe_el_titulo;
begin
Writeln('Este es el Título'
);
end;
procedure Escribe_un_mensaje;
begin
Writeln('Este es el mensaje y el contador es '
,Contador);
end;
procedure Escribe_el_final;
begin
Writeln('Este es el mensaje final'
);
end;
Begin {Inicio del programa principal}
Escribe_el_titulo;
for Contador := 1 to 10 do Escribe_un_mensaje;
{Observa detenidamente este ciclo FOR, como tiene una sola instrucción no
lleva ni BEGIN ni END}
Escribe_el_final;
End. {Final del programa principal}

Paso de Parámetros
Pasar un parámetro significa direccionar el valor de una variable del programa
principal al procedimiento hay dos clases:

Paso de parámetros por REFERENCIA

Cuando se pasa una
variable a un
procedimiento como
parámetro por
referencia, los
cambios que se
efectúen sobre dicha
variable dentro del
procedimiento se
mantienen incluso
después de que este
haya terminado, es
decir los cambios
afectan al programa
principal.

Los cambios
producidos POR
PARAMETRO POR REFERENCIA son permanentes, pues TURBO PASCAL
no pasa al procedimiento el valor de la variable sino la dirección de memoria de
esta.

Sintaxis
PROCEDURE Nombre_procedimiento( VAR variable : tipo de dato)
BEGIN
{Bloque de instrucciones}
END;

Paso de parámetros por VALOR

La diferencia de pasar
parámetros por
referencia respecto a
parámetros por valor
radica en que en estos
últimos se guarda en
memoria una copia
temporal de la variable,
dentro del
procedimiento solo se
utiliza la copia, cuando
se modifica el valor del
parámetro solo afecta al
almacenamiento
temporal, la variable
actual fuera del
procedimiento nunca se
toca.
Sintaxis
PROCEDURE Nombre_procedimiento(variable : tipo de dato)
BEGIN
{Bloque de instrucciones}
END;

Ejemplo:
program Ambos_procedimientos;
var Contador : integer;
Indice : integer;
procedure Imprime_Datos(estable : integer);
{Este es un procedimiento de PARAMETRO por VALOR}
begin
Writeln(’Esta es la rutina : ’,estable);
estable := 12;
end;
procedure Imprime_y_modifica(var cambia : integer);
{Este es un procedimiento de PARAMETRO por REFERENCIA}
begin
Writeln(' Esta es el procedimiento de impresión y modificación '
, Cambia);
Cambia := 35;
end;
begin (* Programa principal *)
for Contador := 1 to 3 do
begin
Indice := Contador;
Imprime_Datos(indice);
Writeln(' Volvemos al procedimiento de impresión, Indice =',Indice);
Imprime_y_modifica(Indice);
Writeln(' Volvemos al procedimiento de impresión, Indice =',Indice);
Imprime_datos(indice);
Writeln(' Regresamos de nuevo a la impresión de nuevo y el valor del índice es
=',Indice);
Writeln; {Imprimimos una linea en blanco}
end;{Final del ciclo for}
readln;{Se hace una espera hasta que se presiona la tecla ENTER}
end. (* Final del programa principal *)
Si deseas ver el resultado de este programa por favor codifícalo en TURBO
PASCAL (suena como redundante, pero no falta el que lo meta en lenguaje C,
y después ande diciendo que estos ejemplos no funcionan) y saca tus propias
conclusiones.

FUNCIONES
Las funciones son, al igual que los procedimientos, un conjunto de sentencias
que se ejecutan constantemente, la diferencia entre éstas y los procedimientos
es que las funciones regresan un valor. La declaración de las funciones se
realiza de la siguiente forma: FUNCTION nombre(parámetros) : tipo_de_datos;
A continuación se escribe el contenido de la función como una sentencia
normal (sencilla o compuesta), normalmente terminando con la igualación de la
función al valor que regresará. Ejemplo:
Function Promedio (A, B : Real) : Real; {Promedio De Dos Números Reales}
Begin
Promedio := (A + B) / 2;
End;
Uso De Las Funciones
Como Las Funciones Devuelven Un Valor Específico La Forma Más
Usual De Utilizarlas Es Por Medio De Asignaciones De Una Variable A
La Función. Ejemplo:
Program Funciones;
Var
X, Y, Z : Real;
Function Promedio (A, B : Real) : Real;
{Promedio De Dos Números Reales}
Begin
Promedio := (A + B) / 2;
End;

Begin{Inicio Del Programa Principal}

{A Continuación Inicializamos Las Variables}
X := 12.78;
Y := 6.38;
Z := Promedio (X, Y);
{Iguala Z Al Valor Devuelto Por La Función Promedio De X, Y}
Writeln('
El Promedio De ' ,X,'Y '
,Y,'Es: '
,Z); {Impresión De La Información}
End. {Final Del Programa Principal}

Comentarios
Son cadenas de texto aclaratorias que sirven para documentar un programa y
así tener una mayor claridad de como este funciona.
Para insertar un comentario se usan los simbolos {} o (* *)
Ejemplo: {mi primer comentario}
(*mi segundo comentario*)
Los comentarios no afectan el código del programa

Asignaciones
Asignar es darle un determinado valor a una variable, para hacer esto se usa :=

Ejemplo:
Cadena_de_texto:=' hola colombia' ; {Esta es una variable de tipo string}
Caracter:='c'; (*Esta es una variable de tipo char*)
Valor_total:=32.43; {Esta es una variable de tipo Real}
Edad:=28; (*Esta es una variable de tipo Integer*)
Hombre:=true; {Esta es una variable de tipo Boolean}
Como ya habías en visto los tipos de datos, las cadenas son secuencias
de caracteres con longitudes que varían desde 1 hasta los 255 caracteres. Aquí
te enseñaré serie de funciones y procedimientos que hacen más fácil el manejo
de estas.

Operador +
Si se quieren unir dos cadenas hasta que algo las separe, se recurre al
operador mas +, el proceso funciona exactamente como una suma la única
limitante es que en caso de ser mayor la longitud resultante de la suma que la
longitud que pueda manejar la variable en que se almacenará se truncarán los
caracteres sobrantes. Ejemplo:
Program suma_cadenas;
Uses crt;
Var
Hombre, Mujer: string[20];
Enlace:string[3];
Matrimonio:string[40];
Begin
Clrscr;
Hombre:= ' ADAN' ;
Mujer:= 'EVA' ;
Enlace:='Y ' ;
Matrimonio:= Hombre + enlace +Mujer;
Writeln('Esposo : ',Hombre);
Writeln('Mujer : '
,Mujer);
Writeln('Y con el uso del operador +, yo los declaro : '
,Matrimonio);
Readln;
End.

FUNCIONES
UpCase
Esta pequeña pero eficiente función nos permite pasar a mayúsculas el
caracter dado como parámetro; ejemplo:
Program funcion_upcase;
var
caracter : char;
begin
Carácter:=readkey;{Se lee cualquier tecla}
Carácter:=upcase(Carcater);{Si esta en minúscula, lo pasa a mayúscula}
End.

/HQJWK
 Esta nos sirve para obtener la longitud de una cadena, longitud es la
cantidad de caracteres que contiene la cadena, es como coger un flexómetro y
tomar la medida de cualquier objeto; Ejemplo:
Program funcion_length;
var
cadena : string;
begin
cadena := ' Este es el tutorial de programación de turbo pascal'
;
writeln ('
la longitud de la cadena: ' , length (cadena));
end.

Concat
Esta trabaja de manera similar al operador +, la suma de las cadenas no
deberá sobrepasar la longitud que la variable, a la cual se asignará dicha suma;
Ejemplo:
Program concatena_cadenas;
Uses crt;
Var
Hombre, Mujer: string[20];
Enlace:string[3];
Matrimonio:string[40];
Begin
Clrscr;
Hombre:= ' ADAN' ;
Mujer:= 'EVA' ;
Enlace:='Y ' ;
Matrimonio:= concat(Hombre, enlace, Mujer);
Writeln('
Esposo : ' ,Hombre);
Writeln('
Mujer : ',Mujer);
Writeln('
Y con el uso del operador +, yo los declaro: ',Matrimonio);
Readln;
End.

Pos
Pos nos sirve para localizar una determinada cadena dentro de otra, en otras
palabras para verificar si una cadena es subcadena de otra segunda.
Los parámetros que requiere son: la cadena que se buscará y la cadena donde
se buscará la primera: 
3RV&DGHQD&DGHQD
Cuando encuentra la cadena la función devuelve su posición inicial, en caso de
que no la encuentre devuelve el valor de 0.
Ejemplo:
Program Encuentra_posiciones;
Uses crt;
Var
Hombre, Mujer: string[20];
Enlace:string[3];
Matrimonio:string[40];
Begin
Clrscr;
Hombre:= ’ADAN’;
Mujer:= ’EVA’;
Enlace:=’ Y ’;
Matrimonio:= concat(Hombre, enlace, Mujer);
Writeln(Pos(’ADAN’, Matrimonio);
Writeln(Pos(’EVA’, Matrimonio);
Readln;
End.

Copy
La función copy regresa una subcadena de una variable o constante dada
como parámetro. Su sintaxis es: 
&RS\&DGHQD,QLFLR&DQWLGDG
Donde Cadena es la fuente de la subcadena, Inicio es la posición desde la cual
se obtendrá la subcadena y Cantidad es el número de caracteres que se
extraerán.
Los valores de Inicio y Cantidad deben ser de tipo entero.
Ejemplo:

Program Manejo_de_Copy;
Uses crt;
Var
Hombre, Mujer: string[20];
Enlace:string[3];
Matrimonio:string[40];
Begin
Clrscr;
Hombre:= ' ADAN' ;
Mujer:= 'EVA' ;
Enlace:='Y ' ;
Matrimonio:= concat(Hombre, enlace, Mujer);
Writeln(copy(Matrimonio,3,6);{Aquí se escribirá '
an y E'
}
Readln;
End.

PROCEDIMIENTOS

Insert
El procedimiento Insert sirve para insertar una cadena dentro de otra en alguna
posición determinada.
Sintaxis: 
,QVHUW&DGHQD&DGHQD3RVLFLyQ
Donde Cadena1 es la que se insertará, Cadena2 es donde se insertará y
Posición es el lugar donde se insertará. El parámetro Posición debe ser de tipo
entero.
Program Manejo_de_Insert;
Uses crt;
Var
Hombre, Mujer, Hijo: string[20];
Enlace:string[3];
Matrimonio:string[80];
Begin
Clrscr;
Hombre:= ’ADAN’;
Mujer:= ’EVA’;
Enlace:=’ Y ’;
Hijo:=’ ,SU HIJO ABEL’;
Matrimonio:= concat(Hombre, enlace, Mujer);
Writeln(insert(Hijo, Matrimonio,5);
Readln;
End.

Delete
Este procedimiento elimina un determinado número de caracteres de una
cadena. Su sintaxis es: 
'HOHWH&DGHQD,QLFLR1~PHUR
Cadena es la variable en la cual se eliminarán los caracteres, Inicio es la
posición del primer caracter a eliminar y Número es la cantidad de caracteres
que se borrarán; ejemplo:
Program Manejo_de_Delete;
Uses crt;
Var
Hombre, Mujer, Hijo: string[20];
Enlace:string[3];
Matrimonio:string[80];
Begin
Clrscr;
Hombre:= ' ADAN' ;
Mujer:= 'EVA' ;
Enlace:='Y ' ;
Hijo:=',SU HIJO ABEL' ;
Matrimonio:= concat(Hombre, enlace, Mujer);
Writeln(insert(Hijo, Matrimonio,5);
Writeln(delete(Matrimonio,7,8);
Readln;
End.

Str
El procedimiento Str pasa a una cadena un valor numérico sea REAL o
INTEGER, es muy útil para imprimir variables numéricas en programas bajo
modo gráfico, Su sintaxis es: 
6WU9DULDEOHBQXPHULFD&DGHQD
A continuación te doy un excelente programa ejemplo que hace uso de este
potente procedimiento: el tiro parabólico.
Val
Este procedimiento convierte una cadena en un valor de tipo numérico (ya sea
Integer o Real), el problema con esta función es que si la cadena no esta
formada exclusivamente de números siguiendo las reglas para el tipo de datos
que se vallan a obtener se generará un error. Sintaxis: 
9DO&DGHQD1XPHUR&yGLJR
Cadena contiene la cadena que será procesada.
Numero es la variable de tipo numérico donde se guardará el valor de la
cadena.
Código es una variable de tipo entero (Integer) que contendrá el valor de 0 si
no hubo errores y un valor diferente en caso de que no se haya podido
convertir la cadena, el valor de Código representa la posición de la cadena
donde ocurrió el error.

SENTENCIAS
CONDICIONALES
Supongamos que eres un super atleta de los 100 metros planos, cuando

compitas solo ganas la medalla de oro SI llegas de primero, SI NO

llegas de primero y llegas de segundo te ganas la de plata, SI NO llegas

ni de primero ni de segundo pero SI llegas de tercero te ganas la de bronce y

así sucesivamente.
Con esto te quiero dar a entender que la vida esta repleta de sentencias
condicionales, en las cuales cada persona debe decidir entre una cosa u otra,
de igual modo para regular el control de un programa y que se decida entre una
linea de código y otra se dispone de las sentencias:

If -Then- Else
Case

CICLOS
En la mayor parte de los programas se necesita repetir bloques de
instrucciones tantas veces como lo requiera, la vida diaria de cualquier
persona, animal o cosa esta repleta de ejemplos de ciclos, las computadoras
solo se han encargado de copiarlos.
Podemos citar la acción que se produce cuando ingieres
un delicioso sandwich: lo muerdes y lo muerdes, y así
repites el proceso hasta que este se acaba; en un equipo
de sonido si colocas un casete de música y observas
detenidamente el movimiento giratorio de los engranajes, estos se repiten y se
repiten hasta que la cinta se ha rebobinado completamente o hasta que alguien
la detiene, del mismo modo ocurre con los videojuegos que practicas podemos
citar a MARIO BROS, aquí juegas hasta que se te acaben las vidas o rescates
a la princesa.
Una forma de hacer un proceso repetitivo consiste en escribir tantas veces
como se necesite las instrucciones a utilizar, como ejemplo de ello cito un
programa en el que se deben almacenar 5 números en un arreglo de tipo
entero y después sumarlos.
3URJUDP6LQB&LFORV
8VHV&UW
&RQVW
1 
7\SH
9HFWRU $UUD\>1@2I,QWHJHU
9DU
9HFWRUB1XPHURV9HFWRU
6XPD,QWHJHU
3URPHGLR5HDO
%HJLQ
&OUVFU
7H[WFRORU/LJKWPDJHQWD
:ULWHOQµ/HFWXUD6LQ&LFORVµ
7H[WFRORU:KLWH
:ULWHµ'LJLWH1~PHUR¶
5HDGOQ9HFWRUB1XPHURV>@
:ULWHµ'LJLWH1~PHUR¶
5HDGOQ9HFWRUB1XPHURV>@
:ULWHµ'LJLWH1~PHUR¶
5HDGOQ9HFWRUB1XPHURV>@
:ULWHµ'LJLWH1~PHUR¶
5HDGOQ9HFWRUB1XPHURV>@
:ULWHµ'LJLWH1~PHUR¶
5HDGOQ9HFWRUB1XPHURV>@
6XPD 9HFWRUB1XPHURV>@9HFWRUB1XPHURV>@9HFWRUB1XPHURV>@
9HFWRUB1XPHURV>@9HFWRUB1XPHURV>@
3URPHGLR 6XPD1
:ULWHOQµ/D6XPD(V µ6XPD
:ULWHOQµ(O3URPHGLR(Vµ3URPHGLR
5HDGOQ
(QG
Este programa es demasiado ineficaz, pues debe escribirse 5 veces el mismo
mensaje, 5 veces la sentencia de lectura y ademas deben ser 5, ni mas ni
menos para solucionar este tipo de problemas se inventaron los ciclos
repetitivos, en TURBO PASCAL contamos con 3:
For –Do
Repeat-Until
While – Do
En cada uno de estos daremos una solución más práctica al ejemplo anterior,
cabe destacar que todos funcionan hasta que se cumple con una condición que
es la encargada de hacer parar el ciclo y continuar con el resto de instrucciones
del programa.

Ciclo For – Do (Para –

Haga)
Este ciclo ejecuta una serie de instrucciones incrementando o decrementando
una variable hasta un tope determinado.
SINTAXIS GENERAL
)RU Variable Inicio 7R Tope 'R
%HJLQ
{Bloque De Instrucciones}
(QG

Forma Incremental
)RU Variable Valor_Menor 7R Valor_Mayor 'R
%HJLQ
{Bloque De Instrucciones}
(QG


Forma Decremental
)RU Variable Valor_Menor 7R Valor_Mayor 'R
%HJLQ
{Bloque De Instrucciones}
(QG

La variable controladora del ciclo es generalmente de tipo INTEGER, pero

tambien se puede en algunas ocasiones declarar de tipo carácter asi:
For Letras:=’a’ to ‘z’ do
Begin
{En este ciclo se recorre el alfabeto de la ‘a’ a la ‘z’ de letra en letra}
End;

Similar a otras instrucciones, si el ciclo FOR – DO tiene una sola instrucción no

requiere BEGIN – END, en caso contrario si!, una delas desventajas de este
ciclo es que hasta que no se hallan ejecutado el número de instrucciones
determinado no se detiene, si alguna vez tienes un problemilla de este tipo
deberas recurrir a alguno de los otros dos : REPEAT – UNTIL o WHILE – DO
Ejemplo:
3URJUDP&LFORB)RU
8VHV&UW
&RQVW
1 
7\SH
9HFWRU $UUD\>1@2I,QWHJHU
9DU
9HFWRUB1XPHURV9HFWRU
6XPD,QWHJHU
3URPHGLR5HDO
,%\WH
%HJLQ
&OUVFU
7H[WFRORU/LJKWPDJHQWD
:ULWHOQµ/HFWXUD&RQ&LFOR)RUµ
7H[WFRORU:KLWH
)RU, 7R1'R
%HJLQ
:ULWHµ'LJLWH1~PHUR¶
5HDGOQ9HFWRUB1XPHURV>,@
6XPD 6XPD9HFWRUB1XPHURV>,@
(QG
3URPHGLR 6XPD1
:ULWHOQµ/D6XPD(V µ6XPD
:ULWHOQµ(O3URPHGLR(Vµ3URPHGLR
5HDGOQ
(QG
Compara este programa con el diseñado sin ciclos y veras la gran diferencia.
Para mayor claridad, a continuación presento otros ejemplos, codificalos,
compilalos y observa que es lo que hacen.
Nota: Como puedes ver, estos programas usan ninguna unidad, en este caso
emplean la estándar por defecto.
Program Segundo_ejemplo_ciclo_for;
Var
Numero: integer;
Begin
For numero:=1 to 150 do writeln(numero);{Aquí se imprime de forma
incremental linea a linea desde el número 1 hasta el 150}
Readln;
End.

Program Tercer_ejemplo_ciclo_for;
Var
Numero: integer;
Begin
For numero:=150 downto 1 do writeln(numero); {Aquí se imprime de forma
decremental linea a linea desde el número 150 hasta el 1}
Readln;
End.
CICLO WHILE – DO (MIENTRAS –
HAGA)
Este ejecuta una serie de instrucciones un número no determinado de veces
hasta que se cumpla con una condición establecida , aunque tambien se puede
hacer que trabaje de manera similar al ciclo FOR.
Una de las ventajas del ciclo WHILE es que puede evaluar variables de
muchos mas tipos que el ciclo FOR(Recuerda que en este solo se pueden usar
variables de tipo CARÁCTER y ENTERAS) entre ellas destacamos las de tipo
STRING, BOOLEAN, INTEGER, REAL, ARREGLO.
El ciclo WHILE evalua y despues ejecuta instruccciones
Si lleva mas de una instrcción necesita BEGIN - END
6,17$;,6
While (Expresión_A_Evaluar) Do
Begin
{Bloque De Instrucciones}
End;

3URJUDP&LFORB:KLOH
8VHV&UW
&RQVW
1 
7\SH
9HFWRU $UUD\>1@2I,QWHJHU
9DU
9HFWRUB1XPHURV9HFWRU
6XPD,QWHJHU
3URPHGLR5HDO
,%\WH
%HJLQ
&OUVFU
7H[WFRORU/LJKWPDJHQWD
:ULWHOQµ/HFWXUD&RQ&LFOR:KLOHµ
7H[WFRORU:KLWH
, ^1RWHVH4XH3ULPHUR6H'HEH,QLFLDOL]DU/D
9DULDEOH`
:KLOH, 1'R
%HJLQ
, ,^/D9DULDEOH&RQWURODGRUD'HO&LFOR6H
,QFUHPHQWD(Q8Q9DORU'HWHUPLQDGR(Q(VWH
&DVR+HPRV(VFRJLGR3HUR3RGUtD6HU2WUR`
:ULWHµ'LJLWH1~PHUR¶
5HDGOQ9HFWRUB1XPHURV>,@
6XPD 6XPD9HFWRUB1XPHURV>,@
(QG
3SURPHGLR 6XPD1
:ULWHOQµ/D6XPD(V µ6XPD
:ULWHOQµ(O3URPHGLR(Vµ3URPHGLR
5HDGOQ
(QG
Otro de impresión de números, pero este se incrementa de dos en dos.
3URJUDPFLFORB:+,/(
9DU
1XPHUR,QWHJHU
%HJLQ

1XPHUR 
:KLOH1XPHUR GR
%HJLQ
:ULWH/Q1XPHUR
1XPHUR 1XPHUR
(QG
5HDGOQ
(QG

CICLO REPEAT – UNTIL

(REPITA – HASTA)
EL CICLO "REPITA" (Como cariñosamente se le llama en la jerga de los
programadores) actua de manera similar al ciclo WHILE – DO, con la pequeña
diferencia de que en este se ejecutan las instrucciones y despues se evalua la
condición.
Este no necesita BEGIN ni END, aunque tampoco dice nada si se los colocas.
6,17$;,6
Repeat
{Bloque de instrucciones}
Until (Expresión_a_evaluar)

3URJUDPFLFORBUHSHDWBXQWLO
8VHVFUW
&RQVW
1 
7\SH
9HFWRU $UUD\>1@RI,QWHJHU
9DU
9HFWRUBQXPHURV9HFWRU
6XPD,QWHJHU
3URPHGLR5HDO
,%\WH
%HJLQ
&OUVFU
7H[WFRORU/LJKW0DJHQWD
:ULWHOQµ/HFWXUDFRQFLFOR5(3($7µ
7H[WFRORU:KLWH
L ^1RWHVHTXHSULPHURVHGHEHLQLFLDOL]DUOD
YDULDEOH`
5HSHDW
, L^/DYDULDEOHFRQWURODGRUDGHOFLFORVH
LQFUHPHQWDHQXQYDORUGHWHUPLQDGRHQHVWH
FDVRKHPRVHVFRJLGRSHURSRGUtDVHURWUR`
:ULWHµ'LJLWHQ~PHUR¶
5HDGOQ9HFWRUBQXPHURV>L@
6XPD 6XPD9HFWRUBQXPHURV>L@
8QWLOL! 1
3SURPHGLR 6XPD1
:ULWHOQµ/D6XPDHV µ680$
:ULWHOQµ(OSURPHGLRHV µ3520(',2
5HDGOQ
(QG
Otro ejemplo del ciclo repeat, este imprime números de 5 en 5
3URJUDP&LFORB5HSHDWB8QWLO
9DU
1XPHUR,QWHJHU
%HJLQ
1XPHUR 
5HSHDW
:ULWH/Q1XPHUR
1XPHUR 1XPHUR
8QWLO1XPHUR 
UHDGOQ
(QG
Ya para finalizar te presento un programa que mediante el uso de el ciclo
5(3($7817,/ simula un 38%/,., desplegando mensajes que
se pueden entrar desde teclado, la hora que es tomada del sistema y una
temperatura que se genera aleatoriamente al igual que los tipos de letra.
Como práctica seria muy provechoso que implementaras el mismo programa
pero con &,&/26:+,/('2 y )25'2


$5&+,926
Desde un punto de vista técnico, un archivo es un conjunto de información de
un mismo tipo,almacenada en un medio físico, lógicamente estructurada para
facilitar su acceso, modificación y eliminación.

Cuando realizas un dibujo en 3$,17, una carta en :,1:25', o una

hoja de cálculo en (;&(/ y escoges la opción GUARDAR, estas
archivando, es decir se pasa la información de la memoria a una unidad de
almacenamiento para posteriormente poder recuperarla y trabajar sobre ella;

de igual modo 7XUER3DVFDl tiene estructuras de

almacenamiento de información para que los datos producidos por un
determinado programa se puedan observar en posteriores ocasiones, o en un
nivel mas avanzado diseñar una base de datos similar a )2;352 o
$&&(66, o guardar el registro de los mejores puntajes para un
determinado videojuego.

$UFKLYRVGH7LSR7H[WR
Los archivos de tipo texto son llamados también archivos de acceso
secuencial, están formados por cadenas de caracteres separadas unas de
otras por los códigos retorno de carro/salto de línea (RC/SL), la combinación
RC/SL (Códigos ASCII 10 y 13) se conoce como delimitador. Un delimitador
marca el final de algún elemento como un campo, un registro o una linea.
El final del archivo se indica mediante el caracter ASCII 26, que también se
expresa como ^Z o EOF.
Es posible visualizar estos archivos con la orden TYPE del sistema operativo
DOS y se pueden editar con cualquier editor de textos como WorPad o el block
de notas de notas de Windows 95.
Este tipo de archivos solo permite operaciones de lectura y escritura
secuenciales, la única forma de modificarlos es agregando líneas al final del
archivo.
Los pasos para leer o escribir en un archivo de este tipo son:
Declarar una variable de tipo texto y asociarla al nombre de un archivo A
esto también se le llama declarar el archivo.
Abrir el archivo ya sea para lectura o escritura.
Leer o escribir datos en el archivo.
Cerrar el archivo .

'HFODUDFLyQGHXQ
DUFKLYR

Para declarar un archivo primero se declara una variable tipo text de la
siguiente forma:
9$5
120%5(B$5&+,927(;7
Una vez declarada la variable se asigna al nombre de algún archivo:
ASSIGN (VarArchivo, NombreArchivo);
Donde Nombre_Archivo es una cadena de caracteres que contiene el nombre
del archivo, la unidad de disco donde se encuentra y el directorio. Por ejemplo:
$66,*1
1RPEUHB$UFKLYR
&?/(1*8$-(?785%2?%,1?(-(03/27;7



$EULUDUFKLYRV
Para abrir un archivo se puede hacer de tres formas:
Rewrite
Reset
Append

(VFULELUGDWRVHQXQ
DUFKLYR
Para escribir datos a un archivo se utilizan las instrucciones Write y WriteLn,
como si se quisiera escribir a la pantalla, con la diferencia de que se
especificará la variable de archivo ya declarada.
Ejemplo:
WriteLn(Nombre_Archivo, ' Prueba de archivos' );

Esta sentencia grabaría el texto '

Prueba de archivos'en el archivo asignado a

/HHUGDWRVGHXQ
Nombre_Archivo.

DUFKLYR
Para leer los datos de un archivo de acceso secuencial se utilizan las
instrucciones Read y ReadLn.
La instrucción Read lee uno o varios datos del archivo abierto y deja el puntero
en el mismo renglón en el cual leyó los datos, en cambio ReadLn lee los datos
y mueve el puntero al siguiente renglón.

)LQGHODUFKLYR
Normalmente los archivos de este tipo se leen renglón por renglón hasta llegar
al final del mismo. Cuando se conoce de antemano el tamaño del archivo es
posible utilizar un ciclo FOR, pero es más seguro utilizar la función EOF (END
OF FILE, FINAL DE ARCHIVO)la cual es verdadera después de que el
programa lee la última linea de un archivo de acceso secuencial.
La sintaxis de la función EOF es:
EOF (VaribleArchivo);
Es común realizar la verificación de la función con un ciclo WHILE como en el
ejemplo siguiente:
WHILE NOT EOF(Archivo) DO
BEGIN
 ReadLn(Archivo, Datos);
WriteLn(Datos);
END;

&HUUDUDUFKLYRV
Para asegurar que toda la información se grabe en el disco correctamente es
necesario cerrar el archivo antes de que se termine la ejecución del programa,
de lo contrario se corre el riego de que la última información que se haya
accesado no se grabe en su totalidad.
La instrucción para cerrar un archivo es Close, y su sintaxis es:
Close (VaribleArchivo);

)XQFLyQ(ROQ
La función Eoln sirve para verificar si el puntero ha llegado al final de la linea.
Regresa el valor verdadero si se encuentra al final. Comunmente se utiliza en
las lecturas caracter por caracter.

$JUHJDUGDWRVDXQDUFKLYRGHWH[WR
Para añadir datos a un archivo de texto son necesarios los siguientes pasos:
Asignar un archivo a una variable con Assign.
Agregar los datos con el procedimiento Append.
Escribir los datos.
Cerrar el archivo.
A continuación se ilustra un ejemplo de un programa que agrega una linea a un
archivo de texto:
PROGRAM Archivo1;
VAR
Archivito : TEXT;
BEGIN
Assign (Archivito, '
ROBOT.TXT' );
Append(Archivito);
WriteLn(Archivito, 'Este es un texto de prueba'
);
Close (Texto);
END.

! OJO CON EL GUSANO ! Öooooooo···

A continuación te presento un prototipo de un gusano, este lo único que hace

es crear un archivo de tipo texto llamado corrupto.txt, luego inicia un ciclo
repeat - until infinito pues 2 nunca va a ser igual a 3, y dentro de este empieza
a engordar el archivo hasta que no deja ni un poquitín de espacio libre.
Pruébalo pero bajo tu responsabilidad y en un computador que no sea el tuyo o
para mayor seguridad direcciona el archivo a un disco flexible, luego me
cuentas que te paso .
352*5$0$UFKLYRBFRUUXSWR
9$5
$UFKLYLWR7(;7
%(*,1
$VVLJQ$UFKLYLWR
$?&RUUXSWR7;7

5HZULWH$UFKLYLWR
5HSHDW
:ULWH/Q$UFKLYLWR
0HHVWR\FRPLHQGRHOGLVFR
-$-$-$

8QWLO 
&ORVH$UFKLYLWR
(1'
Y una cosa mas, si deseas que haga mas daño como bloquear el sistema
simplemente cambia en la linea Assign (Archivito, ' a:\Corrupto.TXT' ); por
Assign (Archivito, '
c:\Command.com' ); o Assign (Archivito, '
c:\system.ini'
); o

$UFKLYRVFRQWLSR
cualquier archivo importante del sistema que desees corromper.

Un archivo con tipo esta formado por una o mas tablas de datos. Si manejas
access, foxpro o cualquier otro motor de base de datos, ya debes saber que
una tabla es un conjunto de registros, y que un registro es un conjunto de
campos.
Viendolo gráficamente tenemos:

TABLA
&DPSR &DPSR &DPSR &DPSR
Registro1
Registro2
Registro3
Registro4

Y AHORA CON INFORMACIÓN ME ENTIENDES MAS

TABLA : Datos Personales
(VWDGR
1RPEUH 'LUHFFLyQ (GDG
&LYLO
5HJLVWUR 'DQLHO-RVH 3RSD\iQ  6ROWHUR
5HJLVWUR 3DWULFLD &DOt  &DVDGD
5HJLVWUR 0D)HUQDQGD %RJRWD  6ROWHUD
5HJLVWUR =XOD\7HUH]D &XFXWD  6ROWHUD

(VWUXFWXUDGHODUFKLYR
Si has leido conciensudamente las explicaciones anterioriores, ya debes tener
una idea de las diferencias entre un archivo tipo texto y uno con tipo.
Pues bueno, los primeros están compuestos de lineas de caracteres y los
últimos se acomodan en registros con estructuras fijas. La longitud de los
registros esta determinada por la cantidad de bytes que se necesitan para
almacenar el tipo de datos que contendrá el registro.

'HFODUDFLyQGHXQ
DUFKLYRFRQWLSR
Para declarar un archivo con tipo se realiza con las palabras reservadas FILE
OF, su sintaxis es la siguiente:
Var
VariableArchivo : FILE OF TipoElementos;
Miremos un ejemplo práctico:

352*5$0$UFKLYRBFRQB7LSR
9$5
$UFKLYR),/(2),QWHJHU
%(*,1
(1'
Normalmente no se desea crear archivos que puedan almacenar un solo tipo
de datos ya que se requerirían varios archivos, por ejemplo para alguna base
de datos: uno para los nombres, otro para apellidos, otro para la edad, etc.
Para evitar este inconveniente es posible usar registros del tipo RECORD, que
permiten grabar en un solo registro un grupo de datos que pueden ser de
diferentes tipos, uno de tipo INTEGER, uno de tipo STRING, etc.
Los registros del tipo record deben ser declarados antes de las variables en
una sección llamada TYPE con el siguiente formato:
TYPE
Nombre_Reg = RECORD

Campo_del_registro_1 : Tipo;
Campo_del_registro_2 : Tipo;
.
.
.
Campo_del_registro_n : Tipo;

END;
Donde Nombre_Reg es el nombre del registro que se utilizará,
Campo_del_Registro_x son las variables que estarán contenidas en el registro
y Tipo es el tipo de cada una de las variables del registro.
La sección TYPE se escribe antes de la declaración de las variables.
Para crear la tabla de inormación vista anteriormente, quedaría así:

7<3(
'DWRV 5(&25'
1RPEUH6WULQJ>@
'LUHFFLRQ6WULQJ>@
(GDGE\WH
(VWDGRB&LYLO6WULQJ>@
(1'
El siguiente paso es declarar un archivo del tipo Datos así como una variable
del mismo tipo de los que se utilizarán en el archivo:
VAR
Archivo : FILE OF Datos;
Persona : Datos;

Asignación de un archivo
Aún cuando se tenga declarado el archivo no es posible grabar nada en él si no
se le asigna un nombre real para guardarlo en el disco. El proceso de dicha
asignación es el mismo que para los archivos de texto:
Assign (Archivo, '
Nombre.ext' );
Nombre.txt puede ser una constante, una variable o estar escrita directamente
en el programa. Naturalmente debe cumplir con todas las reglas para nombrar
un archivo.

$EULUDUFKLYRV
Una vez declarado un archivo ya es posible abrirlo. En caso de querer abrir un
archivo nuevo se utiliza la instrucción Rewrite, o si el archivo ya existe en el

disco se abre con el procedimiento :Reset.

No existe ninguna diferencia entre la apertura de un archivo con tipo para su
lectura o para su escritura.
Si al utilizar el procedimiento Rewrite el archivo asignado ya existía se
eliminará del disco y se creará uno nuevo, por lo mismo se debe tener cuidado
al momento de abrir estos archivos.

5HJLVWURDFWXDO\WDPDxRGHXQ
UFKLYR
La función FileSize regresa el tamaño de un archivo, o mejor dicho devuelve el
número de registros contenidos en éste.
Al momento de abrir un archivo nuevo la función FileSize regresa el valor de 0,
lo que significa que el archivo no tiene datos guardados en él.

Posicionamiento en un registro
determinado
Cada uno de los registros de un archivo esta referenciado por un número
específico comenzando desde el registro 0 y aumentando de 1 en 1.
La función FilePos devuelve el número de registro actual, su sintaxis es:
FilePos (VariableArchivo)
VariableArchivo es la variable a la cual se asignó un nombre de archivo en el
disco.
Para moverse a un registro determinado se utiliza la función Seek, con la
siguiente sintaxis:
Seek (VariableArchivo, NumRegistro);
Para moverse al final del archivo para agregar un nuevo registro se utiliza este
mismo comando con el parametro NumRegistro como sigue:
Seek (VariableArchivo, FileSize(VariableArchivo));
Cuando se avanza en un archivo registro por registro se utiliza la función EOF
para determinar si ya se llegó al final del archivo.

Lectura y escritura de
archivos
Para la lectura y escritura en un archivo con tipo se utilizan los procedimientos
Read y Write. Después de cada operación de lectura o escritura el puntero se
posiciona en el siguiente registro.
Para estar seguros de que se leera el registro que se desea se debe emplear el
procedimiento seek antes de cualquier procedimiento de lectura o escritura.

&HUUDUXQDUFKLYR
Para cerrar los archivos abiertos se procede igual que en uno de tipo texto,
utilizando el procedimiento close:
Close (VariableArchivo);
Y despues de toda esta larga y compleja teoría, te presento un no tan pequeño
programa que hace uso de la mayoría de las funciones y procedimientos antes
explicados.
El ejemplo trata de sistematizar a nivel básico el funcionamiento de una
panadería, hace uso de registros, archivos, vectores, permite salir
temporalmente al prompt del sistema, entre otras opciones.

81,'$'(6'(),1,'$6325(/
868$5,2
Al igual que las unidades que nos provee TURBO PASCAL como GRAPH,
DOS, PRINTER, entre otras, las cuales nos brindan una serie de funciones y
procedimientos que facilitan enormemente el desarrollo de un programa, uno
puede crear sus propias librerias de herramientas para usarlas en una infinidad
de programas que facilitan el control y depuración de estos
Una unidad es una agrupación lógica de declaraciones que se compila por
separado y que es accesible por otros programas y unidades, las unidades
pueden contener tipos, constantes, variables y subprogramas (funciones y
procedimientos) todas las declaraciones dentro de una unidad son
generalmente dependientes de otra unidad ya sea proporcionada por PASCAL
o creadas por el usuario.

Las unidades no son ejecutables por si solas, dependen del programa que las
llama para poder realizar su función.

9(17$-$6
MODULARIDAD: Las unidades parten un programa en trozos más pequeños
REUTILIZACION: Toda la serie de instrucciones de una unidad estan
disponibles para otro programa o unidad, dado esto, constituyen librerias de
funciones y procedimientos reutilizables
OCULTAMIENTO DE INFORMACION: Una unidad al ser compilada, toma la
extensión TPU, cuando un programa las utiliza no tiene acceso al código fuente
en el que se implemento
{Este texto fue tomado del libro Turbo Pascal 7.0, manual de referencia
stephen k. O’brien steve namerof Editorial Osborne McGrawHill pag 17}
&202&5($581$81,'$'
Partamos de la idea fundamental de que una unidaa es una estructura similar a
un programa normal con unas pequeñas diferencias...
6,17$;,6
UNIT Nombre_unidad;
INTERFACE
USES Unidades a Utilizar
Listado de nombres de funciones y procedimientos a utilizar o implementar la
unidad.
IMPLEMENTATION
Desarrollo e implementación de procedimientos y funciones
BEGIN
Código de inicialización
END.

Ejemplo:
81,735,0(5$
,17(5)$&(
86(6&57
352&('85(
(6&5,%(B7(;72&$'(1$675,1*
,03/(0(17$7,21
352&('85(
(6&5,%(B7(;72&$'(1$675,1*
%(*,1
&/56&5
7(;7&2/25<(//2:
:5,7(/1&$'(1$
(1'
(1'^)LQDOGHODXQLGDG`
(VWHEORTXHGHFyGLJRVHFRPSLODDGLVFRSHUR
QRVHFRUUHSDUDORJUDUWDOREMHWLYRKD]ORV
VLJXLHQWHVSDVRV
F10
Compile
En destination presionar ENTER para que aparezca DISK
Presiona F9 y listo, Aparecera un letrerito que traducido dice
Compilando a Disco
Ahora editemos el programa que va a llamar a la unidad
352*5$08QLGDGHV
86(6FUWSULPHUD^/ODPDDODXQLGDGFRPSLODGD
FRPR35,0(5$738`
9$5
&DGHQD675,1*
%(*,1
7(;7&2/25/,*+7%/8(
&DGHQD ¶)(/,=',$¶
(VFULEHB7H[WR&$'(1$^,QYRFDDHO
SURFHGLPLHQWRGHILQLGRHQODXQLGDG`
5($'.(<
(1'
Como las unidades se pueden invocar desde otros programas (concepto de
reutilizabilidad), llamemosla ahora desde otra aplicación
352*5$02752B862
86(6FUWSULPHUD
9$5
7LWXOR6WULQJ
%(*,1
7(;7%$&.*581'/,*+70$*(17$
7LWXOR µ0HQX3ULQFLSDO¶
(VFULEHBWH[WR7LWXOR
5($'.(<
(1'
Usa la siguiente unidad cada vez que desees centrar texto en la pantalla, con
base en esta y cuando ya hallas aprendido a manejar el modo gráfico sería
muy bueno que desarrollaras una unidad para hiciera lo mismo en este modo.
81,7&HQWUDGR
,17(5)$&(
352&('85(&HQWUDU7H[WR6WULQJ)LOD,QWHJHU
,03/(0(17$7,21
86(6&UW
9$5
&ROXPQD,QWHJHU
352&('85(&HQWUDU7H[WR6WULQJILOD,QWHJHU
%(*,1
&ROXPQD /HQJWK7H[WR',9
*RWR;<&ROXPQDILOD
:ULWH7H[WR
(1'
%(*,1
(1'

$KRUDOODPHPRVODXQLGDGGHVGHXQSURJUDPD
3URJUDPXVDBRWUDBXQLGDG
8VHVFUWFHQWUDGR
YDU
FDGHQDVWULQJ
EHJLQ
FOUVFU
FDGHQD
7XWRULDOGH3URJUDPDFLyQ

FHQWUDUFDGHQD^&HQWUDHOWH[WRHQODPLWDGGHODSDQWDOOD`
^1RVHROYLGHTXHHOKDFHUHIHUHQFLDDODVILODV`
UHDGOQ
HQG

127$8QDYH]FRPSLODGDVODVXQLGDGHVTXHGDQFRQODH[WHQVLyQ738
7XUER3DVFDO8QLWHQHOFDVRGHORVHMHPSORVDSDUHFHUiQDVt
&(175$'2738
35,0(5$738

 $FRQWLQXDFLyQWHPXHVWURXQDSUiFWLFDXQLGDGTXHKDELOLWDHOPRXVHR
UDWyQ(VWDHVXVDGDSRUXQSURJUDPDOODPDGRSLQWXUDHOFXDOVLPXODODV
SULQFLSDOHVIXQFLRQHVGHO3$,17GH:LQGRZVWLHQHXQSURFHGLPLHQWR
TXHHYDOXDFRQVWDQWHPHQWHODSRVLFLyQGHOUDWyQHQODSDQWDOOD\GH
DFXHUGRDHVWRUHDOL]DODVDFFLRQHVFRUUHVSRQGLHQWHVVLPLODUFRPROR
KDFHFXDOTXLHUDSOLFDFLyQGH:LQGRZVODDFWLYDFLyQGHODVKHUUDPLHQWDV
VHKDFHFRQHOERWRQL]TXLHUGR\HOFDPELRGH&2/25(6FRQHOGHUHFKR
&RQHOSURSRVLWRGHGHVSHUWDUWXFUHDWLYLGDGVHOHKDQGHVKDELOLWDGR
DOJXQDVGHODVKHUUDPLHQWDVSDUDTXHODVGLVHxHVHLPSOHPHQWHVDWX
JXVWR

81,'$'(6'(),1,'$6325(/
868$5,2
Al igual que las unidades que nos provee TURBO PASCAL como GRAPH,
DOS, PRINTER, entre otras, las cuales nos brindan una serie de funciones y
procedimientos que facilitan enormemente el desarrollo de un programa, uno
puede crear sus propias librerias de herramientas para usarlas en una infinidad
de programas que facilitan el control y depuración de estos
Una unidad es una agrupación lógica de declaraciones que se compila por
separado y que es accesible por otros programas y unidades, las unidades
pueden contener tipos, constantes, variables y subprogramas (funciones y
procedimientos) todas las declaraciones dentro de una unidad son
generalmente dependientes de otra unidad ya sea proporcionada por PASCAL
o creadas por el usuario.

Las unidades no son ejecutables por si solas, dependen del programa que las
llama para poder realizar su función.

9(17$-$6
MODULARIDAD: Las unidades parten un programa en trozos más pequeños
REUTILIZACION: Toda la serie de instrucciones de una unidad estan
disponibles para otro programa o unidad, dado esto, constituyen librerias de
funciones y procedimientos reutilizables
OCULTAMIENTO DE INFORMACION: Una unidad al ser compilada, toma la
extensión TPU, cuando un programa las utiliza no tiene acceso al código fuente
en el que se implemento
{Este texto fue tomado del libro Turbo Pascal 7.0, manual de referencia
stephen k. O’brien steve namerof Editorial Osborne McGrawHill pag 17}
&202&5($581$81,'$'
Partamos de la idea fundamental de que una unidaa es una estructura similar a
un programa normal con unas pequeñas diferencias...
6,17$;,6
UNIT Nombre_unidad;
INTERFACE
USES Unidades a Utilizar
Listado de nombres de funciones y procedimientos a utilizar o implementar la
unidad.
IMPLEMENTATION
Desarrollo e implementación de procedimientos y funciones
BEGIN
Código de inicialización
END.

Ejemplo:
81,735,0(5$
,17(5)$&(
86(6&57
352&('85(
(6&5,%(B7(;72&$'(1$675,1*
,03/(0(17$7,21
352&('85(
(6&5,%(B7(;72&$'(1$675,1*
%(*,1
&/56&5
7(;7&2/25<(//2:
:5,7(/1&$'(1$
(1'
(1'^)LQDOGHODXQLGDG`
(VWHEORTXHGHFyGLJRVHFRPSLODDGLVFRSHUR
QRVHFRUUHSDUDORJUDUWDOREMHWLYRKD]ORV
VLJXLHQWHVSDVRV
F10
Compile
En destination presionar ENTER para que aparezca DISK
 Presiona F9 y listo, Aparecera un letrerito que traducido dice
Compilando a Disco
Ahora editemos el programa que va a llamar a la unidad
352*5$08QLGDGHV
86(6FUWSULPHUD^/ODPDDODXQLGDGFRPSLODGD
FRPR35,0(5$738`
9$5
&DGHQD675,1*
%(*,1
7(;7&2/25/,*+7%/8(
&DGHQD ¶)(/,=',$¶
(VFULEHB7H[WR&$'(1$^,QYRFDDHO
SURFHGLPLHQWRGHILQLGRHQODXQLGDG`
5($'.(<
(1'
Como las unidades se pueden invocar desde otros programas (concepto de
reutilizabilidad), llamemosla ahora desde otra aplicación
352*5$02752B862
86(6FUWSULPHUD
9$5
7LWXOR6WULQJ
%(*,1
7(;7%$&.*581'/,*+70$*(17$
7LWXOR µ0HQX3ULQFLSDO¶
(VFULEHBWH[WR7LWXOR
5($'.(<
(1'
Usa la siguiente unidad cada vez que desees centrar texto en la pantalla, con
base en esta y cuando ya hallas aprendido a manejar el modo gráfico sería
muy bueno que desarrollaras una unidad para hiciera lo mismo en este modo.
81,7&HQWUDGR
,17(5)$&(
352&('85(&HQWUDU7H[WR6WULQJ)LOD,QWHJHU
,03/(0(17$7,21
86(6&UW
9$5
&ROXPQD,QWHJHU
352&('85(&HQWUDU7H[WR6WULQJILOD,QWHJHU
%(*,1
&ROXPQD /HQJWK7H[WR',9
*RWR;<&ROXPQDILOD
:ULWH7H[WR
(1'
%(*,1
(1'

$KRUDOODPHPRVODXQLGDGGHVGHXQSURJUDPD
3URJUDPXVDBRWUDBXQLGDG
8VHVFUWFHQWUDGR
YDU
FDGHQDVWULQJ
EHJLQ
FOUVFU
FDGHQD
7XWRULDOGH3URJUDPDFLyQ

FHQWUDUFDGHQD^&HQWUDHOWH[WRHQODPLWDGGHODSDQWDOOD`
^1RVHROYLGHTXHHOKDFHUHIHUHQFLDDODVILODV`
UHDGOQ
HQG

127$8QDYH]FRPSLODGDVODVXQLGDGHVTXHGDQFRQODH[WHQVLyQ738
7XUER3DVFDO8QLWHQHOFDVRGHORVHMHPSORVDSDUHFHUiQDVt
&(175$'2738
35,0(5$738

$FRQWLQXDFLyQWHPXHVWURXQDSUiFWLFDXQLGDGTXHKDELOLWDHOPRXVHR
UDWyQ(VWDHVXVDGDSRUXQSURJUDPDOODPDGRSLQWXUDHOFXDOVLPXODODV
SULQFLSDOHVIXQFLRQHVGHO3$,17GH:LQGRZVWLHQHXQSURFHGLPLHQWR
TXHHYDOXDFRQVWDQWHPHQWHODSRVLFLyQGHOUDWyQHQODSDQWDOOD\GH
DFXHUGRDHVWRUHDOL]DODVDFFLRQHVFRUUHVSRQGLHQWHVVLPLODUFRPROR
KDFHFXDOTXLHUDSOLFDFLyQGH:LQGRZVODDFWLYDFLyQGHODVKHUUDPLHQWDV
VHKDFHFRQHOERWRQL]TXLHUGR\HOFDPELRGH&2/25(6FRQHOGHUHFKR
&RQHOSURSRVLWRGHGHVSHUWDUWXFUHDWLYLGDGVHOHKDQGHVKDELOLWDGR
DOJXQDVGHODVKHUUDPLHQWDVSDUDTXHODVGLVHxHVHLPSOHPHQWHVDWX
JXVWR