Aprender Programación en Pascal Tutorial Lección 1

Introducción a Pascal
Acerca de Pascal
El lenguaje de programación Pascal fue creado por Niklaus Wirth en 1970. Recibió su nombre en honor a
Blaise Pascal, un famoso matemático francés. Se creó como un lenguaje para enseñar programación.
y ser confiable y eficiente. Pascal se ha convertido desde entonces en más que un lenguaje académico
y ahora se utiliza comercialmente.

Lo que necesitarás
Antes de comenzar a aprender Pascal, necesitarás un compilador de Pascal. Este tutorial utilizaes elGratis
Compilador Pascal. Ustedes cpuedo encontrar una lista de otros compiladores de PascaltPascal de TheFreeCountry
lista de compiladores.

Tu primer programa
Lo primero que hay que hacer es abrir tu IDE si tu compilador viene con uno o abrir un texto
editor.

Siempre comenzamos un programa escribiendo su nombre. Escribe el nombre del programa a continuación.
Lo llamaremos nuestro primer programa 'Hola' porque va a imprimir las palabras 'Hola mundo'
en la pantalla.

program Hola;

A continuación, vamos a escribir 'begin' y 'end'. Vamos a escribir el cuerpo principal del programa entre
estas 2 palabras clave. Recuerda poner el punto después del final.

programa Hola;

comenzar
fin.

El comando Write imprime palabras en la pantalla.

programa Hola;

comenzar
Escriba('Hola mundo');
fin.
Verás que 'Hola mundo' está entre comillas simples. Esto se debe a que es lo que se llama un
cadena. Todas las cadenas deben ser así. El punto y coma al final de la línea es un separador de declaraciones.
Siempre debes recordar ponerlo al final de la línea.

El comando Readln ahora se utilizará para esperar a que el usuario presione enter antes de finalizar.
programa.

program Hola;

comenzar
Escribe('Hola mundo');
Leerln;
fin.

Ahora debes guardar tu programa como [Link].

Compilando
Nuestro primer programa ya está listo para ser compilado. Cuando compilas un programa, el compilador lee
tu código fuente y lo convierte en un archivo ejecutable. Si estás utilizando un IDE, entonces pulsar
CTRL+F9 se usa generalmente para compilar y ejecutar el programa. Si está compilando desde el
línea de comandos con Free Pascal luego ingrese lo siguiente:

fpc [Link]

Si obtienes errores al compilarlo, entonces debes repasar esta lección nuevamente para averiguarlo.
donde los hiciste. Los usuarios de IDE encontrarán que sus programas se compilan y ejecutan al mismo tiempo.
Los usuarios de línea de comandos deben escribir el nombre del programa en el símbolo del sistema para ejecutarlo.

Deberías ver las palabras "Hola mundo" cuando ejecutes tu programa y presionar enter saldrá.
¡El programa. Felicitaciones! Acabas de hacer tu primer programa en Pascal.

Más comandos
Writeln es igual a Write excepto que mueve el cursor a la siguiente línea después de haber impreso el
words. Here is a program that will print "Hello" and then "world" on the next line:

programa Hola;

comenzar
Escribe('Hola');
Escribir('mundo');
Leerln;
end.

Si quieres omitir una línea, solo usa Writeln por sí mismo, sin ningún paréntesis.
Usando comandos de unidades
Los comandos que están integrados en tu compilador de Pascal son muy básicos y necesitaremos algunos.
más. Las unidades se pueden incluir en un programa para darte acceso a más comandos. La unidad crt es
uno de los más útiles. El comando ClrScr en la unidad crt limpia la pantalla. Aquí está cómo tú
úsalo:

programa Hola;

usos
crt;

comenzar
ClrScr;
Escribe('Hola mundo');
Leerln;
fin.

Comentarios
Los comentarios son elementos que se utilizan para explicar qué partes de un programa hacen. Los comentarios son ignorados.
por el compilador y están allí solo para las personas que usan el código fuente. Los comentarios deben ser
pon entre llaves. Siempre debes tener un comentario al principio de tu programa para
diga lo que hace así como comentarios para cualquier código que sea difícil de entender. Aquí hay un
ejemplo de cómo comentar el programa que acabamos de hacer:

Este programa borrará la pantalla, imprimirá "Hola mundo" y esperará por el

usuario para presionar enter.

programa Hola;

usos
crt;

comenzar
ClrScr;{Clears the screen}
Escribe('Hola mundo'); {Imprime "Hola mundo"}
Readln;{Espera a que el usuario presione enter}
fin.

Sangrías
Notarás que he puesto 3 espacios delante de algunos de los comandos. Esto se llama
la indentación y se utiliza para hacer que un programa sea más fácil de leer. Muchos principiantes no entienden
la razón para la indentación y no usarla, pero cuando comenzamos a hacer textos más largos y complejos
programas, entenderás.
Colores
Para cambiar el color del texto impreso en la pantalla usamos el comando TextColor.

programa Colores;

usos
crt;

comenzar
ColorTexto(Rojo);
Escribe('Hola');
ColorTexto(Blanco);
Escribe('mundo');
fin.

El comando CambiarFondoTexto cambia el color del fondo del texto. Si deseas

cambia toda la pantalla a un cierto color, entonces debes usar ClrScr.

programa Colores;

usos
crt;

begin
FondoTexto(Rojo);
Escribe('Hola');
TextColor(White);
ClrScr;
fin.

Coordenadas de la pantalla

Puedes colocar el cursor en cualquier parte de la pantalla usando el comando GoToXY. En DOS, la pantalla
tiene 80 caracteres de ancho y 25 caracteres de alto. La altura y el ancho varían en otras plataformas.
Es posible que recuerdes los gráficos de Matemáticas que tienen un eje X y un eje Y. Las coordenadas de la pantalla funcionan en
una forma similar. Aquí hay un ejemplo de cómo mover el cursor a la décima columna en la quinta fila.

programa Coordenadas;

usos
crt;

comenzar
IrAxy(10,5);
Escriba('Hola');
fin.

Ventanas
Windows te permite definir una parte de la pantalla a la que tu salida estará confinada. Si creas un
La ventana y borrar la pantalla solo borrará lo que esté en la ventana. El comando Ventana tiene
4 parámetros que son las coordenadas de la esquina superior izquierda y las coordenadas de la esquina inferior derecha.

programa Coordenadas;

usos
crt;

comenzar
Ventana(1,1,10,5);
FondoDeTexto(Azul);
ClrScr;
fin.

Usar window(1,1,80,25) restablecerá la ventana a su tamaño normal.

Aprender Programación en Pascal Tutorial Lección 3

-Variables y Constantes
¿Qué son las variables?
Las variables son nombres asignados a bloques de la memoria del ordenador. Los nombres se utilizan para almacenar
valores en estos bloques de memoria.

Las variables pueden contener valores que son números, cadenas o booleanos. Ya sabemos qué
los números son. Las cadenas están compuestas por letras. Las variables booleanas pueden tener uno de dos valores, ya sea
Verdadero o Falso.

Usando variables
Siempre debes declarar una variable antes de usarla. Usamos la declaración 'var' para hacer esto.
también se debe elegir qué tipo de variable es. Aquí hay una tabla de los diferentes tipos de variables:

Byte 0 to 255
Palabra 0 a 65535
ShortInt -128 a 127
Entero -32768 a 32767
LongInt -4228250000 a 4228249000
Real valores de punto flotante
Char 1 carácter
Cadena de hasta 255 caracteres
Booleano verdadero o falso
Aquí hay un ejemplo de cómo declarar una variable entera llamada i:

programa Variables;

var
i: Entero;

comenzar
fin.

Para asignar un valor a una variable usamos :=

programa Variables;

var
i: Entero;

comenzar
i := 5;
fin.

Puedes crear 2 o más variables del mismo tipo si separas sus nombres con comas.
También puedes crear variables de un tipo diferente sin necesidad de otra declaración de variable.

programa Variables;

var
i, j: Entero;
s: String;

comenzar
fin.

Cuando asignas un valor a una variable de cadena, debes ponerlo entre comillas simples. Booleano
Las variables solo pueden asignarse los valores Verdadero y Falso.

programa Variables;

var
i: Entero;
s: String;
b: Boolean;

comenzar
i := -3;
Hola
b := Verdadero;
fin.

Cálculos con variables

Las variables se pueden utilizar en cálculos. Por ejemplo, podrías asignar un valor a una variable y
entonces añádele el número 1. Aquí hay una tabla de los operadores que se pueden usar:

+ Agregar
- Restar
* Multiplicar
/ División de punto flotante
div División Entera
mod Resto de la División Entera

El siguiente ejemplo muestra algunos cálculos que se pueden realizar:

programa Variables;

var
Num1, Num2, Ans: Integer;

comenzar
Ans := 1 + 1;
Num1 := 5;
Resultado := Num1 + 3;
Num2 := 2;
Ans := Num1 - Num2;
Ans := Ans * Num1;
fin.

Las cadenas contienen caracteres. Los caracteres incluyen las letras del alfabeto así como caracteres especiales.
caracteres y números enteros. Es importante entender que los números enteros y las cadenas
los números son cosas diferentes. También puedes sumar cadenas. Todo lo que sucede es que se unen los
2 cadenas. Si sumas las cadenas '1' y '1' obtendrás '11' y no 2.

programa Variables;

var
s: String;

comenzar
s := '1' + '1';
fin.

Puedes leer valores del teclado en variables usando Readln y ReadKey. ReadKey es
de la unidad crt y solo lee 1 carácter. Verás que ReadKey funciona de manera diferente a
Lee

programa Variables;

usa crt;

var
i: Entero;
 s: String;
c: Carácter;

comenzar
Readln(i);
Leerln(s);
c := LeerTecla;
fin.

Imprimir variables en la pantalla es igual de fácil. Si deseas imprimir variables y texto con el
mismoEscribirLuego separarlos con comas.

programa Variables;

var
i: Integer;
s: String;
comenzar
i := 24;
Hola
Escribe(i);
Escribir(s, ' mundo');
fin.

Constantes
Las constantes son como variables, excepto que sus valores no pueden cambiar. Asignas un valor a una
constante cuando la creas. constse utiliza en lugar de varcuando se declara una constante. Las constantes son
utilizado para valores que no cambian, como el valor de pi.

programa Variables;

const
pi: Real = 3.14;

var
c, d: Real;

comenzar
d := 5;
c := pi * d;

Aprende Programación en Pascal Tutorial Lección 4

- Manejo y Conversiones de Cadenas
Manejo de Cadenas
Puedes acceder a un carácter específico en una cadena si pones el número de la posición de ese.
carácter en corchetes detrás de una cadena.
programa Cadenas;

var
s: String;
c: Char;

comenzar
Hola
c := s[1];{c = 'H'}
fin.

Puedes obtener la longitud de una cadena usando el comando theLength.

programa Cadenas;

var
s: String;
l: Integer;

comenzar
Hola
l := Longitud(s);{l = 5}
fin.

Para encontrar la posición de una cadena dentro de otra cadena, utiliza el comandoPos.
Parámetros:
1: Cadena para encontrar
2: Cadena en la que buscar

programa Cadenas;

var
s: Cadena;
p: Entero;

comenzar
Hola mundo
p := Pos('mundo',s);
fin.

El comando Delete elimina caracteres de una cadena.

Parámetros:
1: Cadena de la que eliminar caracteres
2: Posición para comenzar a eliminar desde
3: Cantidad de caracteres a eliminar

programa Cadenas;

var
s: String;

comenzar
Hola
 Eliminar(s,1,1);{s = 'ello'}
fin.

El comando Copy es como los corchetes cuadrados pero puede acceder a más de un solo carácter.
Parámetros:
1: Cadena para copiar caracteres de
2: Posición para copiar desde
3: Cantidad de caracteres para copiar

programa Cadenas;

var
s, t: Cadena;

begin
Hola
t := Copiar(s,1,3);{t = 'Hel'}
fin.

Insertwill insertará caracteres en una cadena en una posición determinada.

Parameters:
Cadena que se insertará en la otra cadena
Cadena en la que se insertarán caracteres
3: Posición para insertar caracteres

programa Cadenas;

var
s: String;

comenzar
Hlo
Insertar('el',s,2);
fin.

El comando TheParamStr te dará los parámetros de línea de comando que se pasaron a un

[Link] te dirá cuántos parámetros se pasaron al programa.
El parámetro 0 es siempre el nombre del programa y desde 1 en adelante son los parámetros que han sido
escrito por el usuario.

programa Cadenas;

var
s: String;
i: Entero;

comenzar
s := ParamStr(0);
i := ParamCount;
fin.
Conversions
El comando Str convierte un entero en una cadena.

programa Convertir;

var
s: String;
i: Entero;

comenzar
i := 123;
Str(i,s);
fin.

El comando Val convierte una cadena en un entero.

programa Convertir;

var
s: String;
i: Entero;
e: Entero;

comenzar
s := '123';
Val(s,i,e);
fin.

Te daré el número antes de la coma en un número real.

programa Convertir;

var
r: Real;

comenzar
r := Int(3.14);
fin.

Fracte dará el número después de la coma en un número real.

programa Convertir;

var
r: Real;

comenzar
r := Frac(3.14);
fin.

Roundwill redondeará un número real al entero más cercano.

program Convert;

var
i: Entero;

comenzar
i := Redondear(3.14);
fin.

Truncará el número antes de la coma de un número real como un entero.

programa Convert;

var
i: Entero;

comenzar
i := Trunc(3.14);
fin.

Las computadoras utilizan los números del 0 al 255 (1 byte) para representar caracteres internamente y estos son
llamados caracteres ASCII. El comando Ord convertirá un carácter en un número y el Chr
el comando convertirá un número en un carácter. Usar un # frente a un número también lo convertirá
a un personaje.

programa Convertir;

var
b: Byte;
c: Char;

comenzar
c := 'a';
b := Ord(c);
c := Chr(b);
c := #123;
fin.

El comando UpCase cambia un carácter de una letra minúscula a una letra mayúscula.

programa Convertir;

var
c: Char;

comenzar
c := 'a';
c := Mayúscula(c);
fin.

No hay un comando de minúsculas, pero puedes hacerlo sumando 32 al valor ordinal de un

uppercase letter and then changing it back to a character.
Extras
El comando Random te dará un número aleatorio del 0 al número que le des menos 1. El
El comando aleatorio genera los mismos números aleatorios cada vez que ejecutas un programa, así que el
El comando Randomize se utiliza para hacerlos más aleatorios utilizando el reloj del sistema.

programa Rand;

var
i: Entero;

comenzar
Aleatorizar;
i := Aleatorio(101);
fin.
5. Aprende a programar en Pascal

Decisiones
Si entonces else
La declaración if permite a un programa tomar una decisión basada en una condición. La siguiente
el ejemplo le pide al usuario que ingrese un número y le dice si el número es mayor que 5:
programa Decisiones;

var
i: Entero;

comenzar
Escriba 'Ingrese un número';
Leer(i);
si i > 5 entonces
Escribe('Mayor que 5');
fin.
Aquí hay una tabla de los operadores que se pueden usar en condiciones:

> Mayor que

< Menos que
>= Mayor que o igual a
Menor o igual que
= Igual a
No igual a

El ejemplo anterior solo te dice si el número es mayor que 5. Si quieres que te diga que lo es
no es mayor que 5 entonces usamos else. Cuando usas else no debes poner un punto y coma en el
fin del comando antes de él.

programa Decisiones;

var
i: Entero;

comenzar
Writeln('Enter a number');
Leer(i);
si i > 5 entonces
Escribe('Mayor que 5')
sino
Escriba('No mayor que 5');
fin.
Si la condición es verdadera, entonces se elige la parte 'then', pero si es falsa, se elige la parte 'else'.
Esto se debe a que las condiciones como i > 5 es una ecuación booleana. Incluso puedes asignar el resultado.
de una ecuación booleana a una variable booleana.

programa Decisiones;

var
i: Entero;
b: Boolean;

comenzar
Escribe('Introduce un número');
Leer(i);
b := i > 5;
fin.
Si quieres usar más de 1 condición, entonces debes poner cada condición entre paréntesis. Para unir
las condiciones que puedes usar son ya sea AND o OR. Si usas AND, entonces ambas condiciones deben ser verdaderas
pero si usas O, entonces solo 1 o ambas de las condiciones deben ser verdaderas.
programa Decisiones;

var
i: Entero;

comenzar
Escribe('Ingrese un número');
Leerln(i);
si (i > 1) y (i < 100) entonces
Escriba('El número está entre 1 y 100');
fin.
Si deseas poner 2 o más comandos para una declaración if para ambas partes, entonces y else.
debes usar begin y end; para agruparlos juntos. Verás que este end tiene un punto y coma
después de él en lugar de un punto final.
programa Decisiones;

var
i: Entero;

comenzar
Escribe('Ingrese un número');
Lee(i);
si i > 0 entonces
comenzar
Escriba('Usted ingresó ',i);
Es un número positivo
fin;
fin.
Tarea
También puedes usar declaraciones if dentro de otras declaraciones if.
 Caso
El comando case es como una declaración if, pero puedes tener muchas condiciones con acciones para
cada uno.
programa Decisiones;
usos
crt;
var
Elección: Char;
comenzar
Escribe: '¿Cuál de estos te gusta?'
Escriba('a - Manzana:');
Escriba('b - Banana:');
Escribe('c - Zanahoria:');
Choice := ReadKey;
caso Elección de
'a': Writeln('You like apples');
'b': Writeln('You like bananas');
'c': Writeln('You like carrots');
else
Escriba('Hiciste una elección inválida');
fin;
fin.
Aprende el tutorial de programación en Pascal Lección 6 - Bucles
Los bucles se utilizan cuando deseas repetir el código muchas veces. Por ejemplo, si quisieras imprimir
"Hola" en la pantalla 10 veces necesitarías 10 comandos Writeln. Podrías hacer lo mismo
cosa poniendo un comando 1Writeln dentro de un bucle que se repite 10 veces.
Hay 3 tipos de bucles: el bucle for, el bucle while y el bucle repeat until.

Bucle for
El bucle for utiliza una variable contador de bucle, a la que le suma 1 cada vez, para iterar desde un primero
número a un último número.
programa Bucles;
var
i: Entero;
comenzar
para i := 1 hasta 10 hacer
Escribe('Hola');
fin.
Si quieres tener más de un comando dentro de un bucle, entonces debes ponerlos entre abegin
y un final.

programa Bucles;
var
i: Entero;
comenzar
para i := 1 hasta 10 hacer
comenzar
Escribe('Hola');
Escribe('Este es el bucle ', i);
fin;
fin.

Bucle while
El bucle while se repite mientras una condición sea verdadera. La condición se prueba en la parte superior del bucle y
no en ningún momento mientras el bucle está en ejecución, como sugiere el nombre. Un bucle while no necesita un
variable de bucle, pero si quieres usar una, debes inicializar su valor antes de entrar en la
bucle.

programa Bucles;

var
i: Entero;

comenzar
i := 0;
mientras i <= 10
comenzar
i := i + 1;
Escriba('Hola');
finalizar;
fin.

Bucle repetir hasta

El bucle repeat until es similar al bucle while, excepto que evalúa la condición al final del bucle.
bucle. Tampoco tiene que tener un inicio y un fin si tiene más de un comando dentro de él.

programa Bucles;

var
i: Entero;

comenzar
i := 0;
repetir
i := i + 1;
Escribe('Hola');
hasta i = 10;
fin.

Si quieres usar más de una condición para los bucles while o repeat, entonces tienes que
pon las condiciones entre paréntesis.

programa Bucles;

var
i: Entero;
s: String;

comenzar
i := 0;
repetir
i := i + 1;
Escribe('Introduce un número: ');
Leerln(s);
 hasta (i = 10) o (s = 0);
fin.

Break and Continue

El comando Break saldrá de un bucle en cualquier momento. El siguiente programa no imprimirá nada
porque sale del bucle antes de llegar allí.

programa Bucles;

var
i: Entero;

comenzar
i := 0;
repetir
i := i + 1;
Descanso;
Escriba(i);
hasta i = 10;
fin.

El comando Continue volverá al principio de un bucle. Este ejemplo tampoco imprimirá

cualquier cosa menos que el ejemplo delBreak, contará hasta 10.

programa Bucles;

var
i: Entero;

comenzar
i := 0;
repetir
i := i + 1;
Continúa;
Escribe(i);
hasta i = 10;
fin.

Learn Pascal ProgrammingTutorial Lesson 7

- Arrays
Arrays are variables that are made up of many variables of the same data type but have only one
nombre. Aquí hay una representación visual de un arreglo con 5 elementos:

1 valor 1
2 valor 2
3 valor 3
4 valor 4
5 valor 5

Los arreglos se declaran casi de la misma manera que se declaran las variables normales, excepto que usted
tienes que decir cuántos elementos quieres en el arreglo.

programa Arreglos;

var
a: arreglo[1..5] de Entero;

comenzar
fin.

Accedemos a cada uno de los elementos utilizando el número de los elementos que hay detrás de él en corchetes.

programa Arreglos;

var
a: arreglo[1..5] de Entero;

comenzar
a[1] := 12;
a[2] := 23;
a[3] := 34;
a[4] := 45;
a[5] := 56;
fin.

Es mucho más fácil cuando usas un bucle para acceder a los valores en un array. Aquí hay un ejemplo de
leyendo 5 valores en un arreglo:

programa Arreglos;

var
a: arreglo[1..5] de Entero;
i: Entero;

comenzar
para i := 1 hasta 5 hacer
Leer(a[i]);
fin.

Ordenar arreglos
A veces querrás ordenar los valores en un array en un cierto orden. Para hacer esto, puedes usar
un ordenamiento burbuja. Un ordenamiento burbuja es solo una de las muchas formas de ordenar un arreglo. Con un ordenamiento burbuja el
los números más grandes se mueven al final del arreglo.
Necesitarás 2 bucles. Uno para recorrer cada número y otro para apuntar al otro número.
que se está comparando. Si el número es mayor, se intercambia con el otro. Tú will
necesitas usar una variable temporal para almacenar valores mientras los intercambias.

programa Arreglos;

var
a: array[1..5] de Integer;
i, j, tmp: Entero;

begin
a[1] := 23;
a[2] := 45;
a[3] := 12;
a[4] := 56;
a[5] := 34;

para i := 1 hasta 4 hacer

para j := i + 1 hasta 5 hacer
si a[i] > a[j] entonces
comenzar
tmp := a[i];
a[i] := a[j];
a[j] := tmp;
fin;

para i := 1 a 5 hacerlo
writeln(i, ': ', a[i]);
end.

Arreglos 2D
Los arreglos pueden tener 2 dimensiones en lugar de solo una. En otras palabras, pueden tener filas y
columnas en lugar de solo filas.

123
1123
2456
3789

Aquí está cómo declarar un array 2D:

programa Arreglos;

var
a: array [1..3,1..3] of Integer;

comenzar
fin.
Para acceder a los valores de un arreglo 2D debes usar 2 números en los corchetes. Los arreglos 2D también
se requieren 2 bucles en lugar de solo uno.

programa Arreglos;

var
r, c: Integer;
a: array [1..3,1..3] of Integer;

comenzar
para r := 1 hasta 3 hacer
para c := 1 a 3 hacer
Leerln(a[r,c]);
fin.

Puedes obtener arreglos multidimensionales que tienen más de 2 dimensiones, pero estos no se utilizan.
muy a menudo, así que no necesitas preocuparte por ellos.

Aprender Programación en Pascal Tutorial Lección 8 - Tipos,

Registros y Conjuntos

Tipos

Es posible crear tus propios tipos de variable utilizando la declaración de tipo. El primer tipo que puedes
hace es registros. Los registros son 2 o más variables de diferentes tipos en uno. Un ejemplo de cómo
esto podría ser utilizado para un estudiante que tiene un número de estudiante y un nombre. Aquí está cómo se crea
un tipo:

programa Tipos;

Tipo
Student = Record
Number: Integer;
Name: String;
fin;

comenzar
fin.

Después de haber creado el tipo, debes declarar una variable de ese tipo para poder usarla.

programa Tipos;

Tipo
StudentRecord = Record
Number: Integer;
Name: String;
fin;

var
Estudiante: RegistroEstudiantil;
comenzar
fin.

Para acceder a las partes del Número y Nombre del registro, debes hacer lo siguiente:

programa Tipos;

Tipo
StudentRecord = Record
Number: Integer;
Name: String;
fin;

var
Student: StudentRecord;

comenzar
[Link] := 12345;
[Link] := 'John Smith';
fin.

El otro tipo es un conjunto. Los conjuntos no son muy útiles y cualquier cosa que puedas hacer con un conjunto se puede hacer
tan fácilmente de otra manera. El siguiente es un ejemplo de un conjunto llamado Animal que tiene perro,
gato y conejo como los datos que puede almacenar:

programa Tipos;

Tipo
Animal = set of (dog, cat, rabbit);

var
MyPet: Animal;

comenzar
MyPet := dog;
end.

No puedes usar Readln ni Writeln en conjuntos, así que la forma anterior de usarlos no es muy útil. Puedes
crear un rango de valores como un conjunto desde 'a' hasta 'z'. Este tipo de conjunto se puede usar para probar si un valor es
en ese rango.

programa Tipos;

usos
crt;

Tipo
Alpha = 'a'..'z';

var
Carta: conjunto de Alpha;
c: Char;
comenzar
c := LeerTecla;
si c en [Letra] entonces
Escriba('Usted ingresó una letra');
fin.

Aprender Programación en Pascal Tutorial Lección 9

Procedimientos y Funciones
Procedimientos
Los procedimientos son sub-programas que se pueden llamar desde la parte principal del programa. Los procedimientos
se declaran fuera del cuerpo principal del programa utilizando la palabra clave procedimiento. Los procedimientos deben
también se le debe dar un nombre único. Los procedimientos tienen su propio comienzo y fin. Aquí hay un ejemplo de
cómo hacer un procedimiento llamado Hola que imprima "Hola" en la pantalla.

programa Procedimientos;

procedimiento Hola;
comenzar
Escribe('Hola');
end;

comenzar
fin.

Para usar un procedimiento, debemos llamarlo usando su nombre en el cuerpo principal.

programa Procedimientos;

procedimiento Hola;
comenzar
Escribe('Hola');
fin;

comenzar
Hola;
fin.

Los procedimientos siempre deben estar por encima de donde se llaman. Aquí hay un ejemplo de un procedimiento.
que llama a otro procedimiento.

programa Procedimientos;

procedimiento Hola;
comenzar
Escriba('Hola');
fin;

procedimiento HelloCall;
comenzar
Hola;
fin;

comenzar
HolaLlamar;
fin.

Los procedimientos pueden tener parámetros al igual que los otros comandos que hemos estado utilizando. Cada
el parámetro se le da un nombre y un tipo y luego se utiliza como cualquier otra variable. Si deseas
si se utilizan más de un parámetro, deben separarse con puntos y coma.

programar Procedimientos;

procedimiento Imprimir(s: Cadena; i: Entero);

comenzar
Escriba(s);
Escribe(i);
fin;

comenzar
Imprimir('Hola',3);
fin.

Variables globales y locales

Las variables que hemos estado usando hasta ahora han sido globales porque se pueden usar en cualquier momento.
durante el programa. Las variables locales solo pueden usarse dentro de los procedimientos, pero la memoria que utilizan
se libera cuando el procedimiento no está en uso. Las variables locales se declaran justo debajo de la
declaración del nombre del procedimiento.

programa Procedimientos;

procedimiento Imprimir(s: Cadena);

var
i: Entero;
comenzar
para i := 1 hasta 3 hacer
Escribe(s);
fin;

comenzar
Imprimir('Hola');
fin.

Funciones
Las funciones son como procedimientos, excepto que devuelven un valor. La palabra clave función se utiliza en lugar de
procedimiento al declarar una función. Para decir qué tipo de dato debe ser el valor de retorno, debes
usa dos puntos y el nombre del tipo después del nombre de la función.
programa Funciones;

función Sumar(i, j: Entero): Entero;

comenzar
fin;

comenzar
fin.

Asignar el valor de una función a una variable hace que la variable sea igual al valor de retorno. Si tú
usa una función en algo como Writeln imprimirá el valor de retorno. Para establecer el valor de retorno solo
haz que el nombre de la función sea igual al valor que deseas devolver.

programa Funciones;

var
Respuesta: Entero;

función Sumar(i, j: Entero): Entero;

comenzar
Añadir := i + j;
fin;

comenzar
Respuesta := Sumar(1,2);
Escriba(Add(1,2));
fin.

Puedes salir de un procedimiento o función en cualquier momento usando el comando Exit.

programa Procedimientos;

procedimiento ObtenerNombre;
var
Name: String;
comenzar
Escribe('¿Cuál es tu nombre?');
Leerln(Nombre);
si Nombre = '' entonces
Salida;
Escribe('Tu nombre es ', Nombre);
fin;

comenzar
ObtenerNombre
fin.

Aprender Programación en Pascal Tutorial Lección

10 - Archivos de texto
Deberías saber que un archivo de texto es un archivo con líneas de texto. Cuando quieras acceder a un
en Pascal, primero tienes que crear una variable de archivo.

Archivos de programa;

var
Texto;

comenzar
fin.

Después de que la variable ha sido declarada, debes asignarle el nombre del archivo.

program Files;

var
Texto;

comenzar
Asignar(f,'[Link]');
fin.

Para crear un nuevo archivo vacío, usamos el comando Rewrite. Esto sobrescribirá cualquier archivo que exista.
con el mismo nombre.
archivos de programa;

var
f: Text;

comenzar
Asignar(f,'[Link]');
Reescribir(f);
fin.

Los comandos Write y Writeln trabajan con archivos de la misma manera que lo hacen en la pantalla, excepto
que debes usar un parámetro adicional para indicarle que escriba en el archivo.

archivos de programa;

var
f: Texto;

comenzar
Asignar(f, '[Link]');
Reescribir(f);
Escribe(f, 'Una línea de texto');
fin.

Si deseas leer de un archivo que ya existe, debes usar Reset en lugar de Rewrite.
UseReadlnto read lines of text from the file. You will also need awhileloop that repeats until it
llega al final del archivo.
Archivos de programa;

var
f: Text;
s: String;

comenzar
Asignar(f, '[Link]');
Reiniciar(f);
mientras no sea eof(f) do
Lee(f,s);
fin.

Append abre un archivo y te permite agregar más texto al final del archivo.

archivos de programa;

var
f: Text;
s: String;

comenzar
Asignar(f, '[Link]');
Agregar(f);
Escribe(f, 'Algo más de texto');
fin.

No importa cuál de los 3 tipos de acceso elijas, todavía debes cerrar un archivo cuando estás
terminé de usarlo. Si no lo cierras, entonces parte del texto que se escribió en él podría perderse.
Archivos de programa;

var
f: Texto;
s: String;

comenzar
Asignar(f, '[Link]');
Agregar(f);
Escribe(f, 'Algun texto más');
Cierra(f);
fin.

Puedes cambiar el nombre de un archivo con el comando Renombrar y puedes eliminar un archivo con el comando Borrar.
comando.
Archivos de programa;

var
f: Texto;

comenzar
Asignar(f,'[Link]');
Renombrar(f, '[Link]');
 Borrar(f);
Cerrar(f);
fin.

Para averiguar si un archivo existe, primero debes desactivar la verificación de errores usando el compilador {$I-}.
directiva. Después de eso, debes restablecer el archivo y si IOResult = 2, entonces el archivo no fue encontrado. Si
IOResult= 0 then the file was found but if it is any other value then the program must be ended
con el comando [Link] pierde su valor una vez que se ha utilizado, así que también tenemos que poner eso
en otra variable antes de usarlo. También debes usar {$I+} para volver a activar la verificación de errores.

Archivos de programa;

var
Texto;
IOR: Entero;

comenzar
Asigna(f,'[Link]');
{$I-}
Reiniciar(f);
{$I+}
IOR := IOResultado;
si IOR = 2 entonces
Escriba('Archivo no encontrado');
más
si IOR <> 0 entonces
Detente;
Cerrar(f);
fin.

Aprender Programación en Pascal Tutorial Lección

11 - Archivos de Datos
Los archivos de datos son diferentes de los archivos de texto en varios aspectos. Los archivos de datos son de acceso aleatorio, lo que significa que
no tienes que leerlos línea por línea, sino acceder a cualquier parte del archivo en cualquier momento
tiempo. Aquí es cómo declaras un archivo de datos:

programa ArchivosDeDatos;

var
f: archivo de Byte;

comenzar
fin.

Luego usamos Assign de la misma manera que lo hacemos con un archivo de texto.

programa ArchivosDeDatos;

var
 f: archivo de Byte;

comenzar
Asignar(f,'[Link]');
fin.

Puedes usar Reescribir para crear un nuevo archivo o sobrescribir uno existente. La diferencia entre
Los archivos de texto y los archivos de datos al utilizar Rewrite pueden ser leídos y escritos.

programa ArchivosDeDatos;

var
f: archivo de Byte;

comenzar
Asignar(f,'[Link]');
Reescribir(f);
fin.

Reset es lo mismo que Reescribir excepto que no sobrescribe el archivo.

programa ArchivosDeDatos;

var
f: archivo de Byte;

comenzar
Asignar(f,'[Link]');
Reiniciar(f);
fin.

Cuando escribes en un archivo usando el comando Write, primero debes poner el valor que se va a escribir.
el archivo en una variable. Antes de que puedas escribir o leer de un archivo de datos, debes usar el Seek
comando para encontrar el lugar adecuado para comenzar a escribir. También debes recordar que los archivos de datos comienzan
desde la posición 0 y no 1.
programa ArchivosDeDatos;

var
f: archivo de Byte;
b: Byte;

comenzar
Asignar(f, '[Link]');
Restablecer(f);
b := 1;
Buscar(f,0);
Escribe(f,b);
fin.

El comando Read se utiliza para leer de un archivo de datos.

programa ArchivosDeDatos;

var
f: archivo de Byte;
b: Byte;

comenzar
Asignar(f,'[Link]');
Restablecer(f);
Seek(f,0);
Leer(f,b);
fin.

Debes cerrar un archivo de datos cuando hayas terminado con él, al igual que con los archivos de texto.

programa ArchivosDeDatos;

var
f: archivo de Byte;
b: Byte;

comenzar
Asignar(f, '[Link]');
Restablecer(f);
Buscar(f,0);
Leer(f,b);
Cerrar(f);
fin.

El comando FileSize se puede usar con el comando FilePos para averiguar cuándo tienes
alcanzó el final del archivo. FileSizereturns el número real de registros lo que significa que comienza en
1 and not 0. TheFilePoscommand will tell at what position in the file you are.
programa ArchivosDeDatos;

var
f: archivo de Byte;
b: Byte;

comenzar
Assign(f,'[Link]');
Reiniciar(f);
mientras FilePos(f) <> FileSize(f) haga
comenzar
Leer(f,b);
Escribe(b);
fin;
Cerrar(f);
fin.

El comando Truncate eliminará todo en el archivo desde la posición actual.

programa ArchivosDeDatos;
var
f: archivo de Byte;

comenzar
Asignar(f,'[Link]');
Reiniciar(f);
Buscar(f,3);
Truncar(f);
Cerrar(f);
fin.

Una de las cosas más útiles sobre los archivos de datos es que puedes usarlos para almacenar registros.

programa ArchivosDeDatos;

tipo
StudentRecord = Record
Number: Integer;
Name: String;
fin;

var
Student: StudentRecord;
f: archivo de RegistroEstudiantil;

comenzar
Asignar(f, '[Link]');
Reescribir(f);
[Link] := 12345;
[Link] := 'John Smith';
Escribe(f, Estudiante);
Cerrar(f);
fin.

Aprender programación en Pascal Tutorial Lección

12 - Unidades
Ya sabemos que las unidades, como la unidad crt, te permiten utilizar más procedimientos y funciones que
los incorporados. Puedes crear tus propias unidades que tienen procedimientos y funciones que tú
han hecho en ellos.

Para crear una unidad, necesitas crear un nuevo archivo Pascal que llamaremos [Link]. La primera línea
el archivo debe comenzar con la palabra clave 'unidad' seguida del nombre de la unidad. El nombre de la unidad y
el nombre del archivo de la unidad debe ser exactamente el mismo.

unit MyUnit;

La siguiente línea es la palabra clave interface. Después de esto debes poner los nombres de los procedimientos que
se pondrá a disposición del programa que utilizará su unidad. Para este ejemplo, estaremos
haciendo una función llamada NewReadln que es como Readln pero te permite limitar la cantidad de
caracteres que se pueden ingresar.

unidad MiUnidad;

interfaz

función NewReadln(Max: Entero): Cadena;

La siguiente línea es implementación. Aquí es donde escribirás el código completo para los procedimientos y
funciones. También necesitaremos usar la unidad crt para hacer NewReadln. Terminamos la unidad justo como un
programa normal con la palabra clave theend.

unidad MiUnidad;

interfaz

función NewReadln(Max: Entero): Cadena;

implementación

función NewReadln(Max: Entero): Cadena;

var
s: String;
c: Char;
comenzar
s := '';
repetir
c := LeerTecla;
si (c = #8){#8 = RETROCESO} y (s <> '') entonces
comenzar
Escribe(#8+' '+#8);
eliminar(s,longitud(s),1);
end;
si (c <> #8) y (c <> #13){#13 = ENTER} y (longitud(s) < Max) entonces
comenzar
Escribir(c);
s := s + c;
fin;
hasta c = #13;
NuevoReadln := s;
fin;

fin.

Una vez que hayas guardado la unidad, debes compilarla. Ahora debemos hacer el programa que utiliza la
unidad que acabamos de crear. Esta vez escribiremos MyUnit en la sección uses y luego usaremos el
NuevaFunciónLeerln.

programa MyProgram;

usos
MiUnidad;
var
s: String;

comenzar
s := NuevoLeer(10);
fin.

Aprender Programación en Pascal Tutorial Lección

13 - Punteros
¿Qué es un puntero?
Un puntero es un tipo de variable que almacena una dirección de memoria. Debido a que almacena una dirección de memoria
se dice que está apuntando a ello. Hay 2 tipos de punteros que son tipados y no tipados. Un puntero tipado
un puntero apunta a una variable como un entero. Un puntero sin tipo puede apuntar a cualquier tipo de
variable.

Declarando y usando punteros tipados

Cuando declaras un puntero tipado, debes poner un ^ delante del tipo de variable que deseas.
señalar a. Aquí hay un ejemplo de cómo declarar un puntero a un entero:

programa Punteros;

var
p: ^entero;

comenzar
fin.

El signo @ se puede usar delante de una variable para obtener su dirección de memoria. Esta dirección de memoria
pueden entonces ser almacenados en un puntero porque los punteros almacenan direcciones de memoria. Aquí hay un ejemplo de
cómo almacenar la dirección de memoria de un entero en un puntero a un entero:

programa Punteros;

var
i: integer;
p: ^entero;

comenzar
p := @i;
fin.

Si quieres cambiar el valor almacenado en la dirección de memoria a la que apunta un puntero, debes
primero desreferencia la variable del puntero utilizando un ^ después del nombre del puntero. Aquí hay un ejemplo de cómo
cambiar el valor de un entero de 1 a 2 usando un puntero:
programa Punteros;

var
i: entero;
p: ^entero;

comenzar
i := 1;
p := @i;
p^ := 2;
writeln(i);
fin.

Puedes asignar nueva memoria a un puntero tipado usando el comando new.

tiene un parámetro que es un puntero. Thenewcommand obtiene la memoria que es del tamaño de la
tipo de variable del puntero y luego establece el puntero para que apunte a la dirección de memoria de él. Cuando
has terminado de usar el puntero, debes usar el comando dispose para liberar la memoria que
fue asignado al puntero. Aquí hay un ejemplo:

programa Punteros;

var
p: ^entero;

comenzar
nuevo(p);
p^ := 3;
writeln(p^);
eliminar(p);
fin.

Declarar y usar punteros no tipados

Cuando declaras un puntero no tipado, debes usar el tipo de variable llamado puntero.

programa Punteros;

var
p: puntero;

comenzar
fin.

Cuando asignas memoria a un puntero no tipado debes usar el comando getmem en lugar de
El nuevo comando y debes usar freemem en lugar de dispose. getmem y freememe tienen
un segundo parámetro que es el tamaño en bytes de la cantidad de memoria que debe ser asignada
al puntero. Puedes usar un número para el tamaño o puedes usar la función sizeof para obtener
el tamaño de un tipo de variable específico.

programa Punteros;

var
 p: puntero;

comenzar
getmem(p,sizeof(integer));
freemem(p,sizeof(integer));
fin.

Aprender Programación en Pascal Tutorial Lección

14 - Listas Enlazadas
¿Qué es una lista enlazada?
Una lista enlazada es como un arreglo, excepto que la cantidad de elementos en una lista enlazada puede cambiar, a diferencia de
un arreglo. Una lista enlazada utiliza punteros para apuntar al siguiente o al elemento anterior.

Listas enlazadas simples

Hay 2 tipos de listas enlazadas simples que se llaman colas y pilas.

Colas
Una cola es como estar en una fila en una tienda. La primera persona que se une a una cola es la primera
persona a ser atendida. Siempre debes unirte al final de la cola porque si te unes al principio
Las otras personas estarán enojadas. Esto se llama FIFO (Primero en entrar, primero en salir).

Item 1 --> Item 2 --> Item 3 --> (Until the last item)

Cada elemento de una lista enlazada es un registro que tiene los datos y un puntero al siguiente o al anterior.
elemento. Aquí hay un ejemplo de cómo declarar el registro para una cola y un puntero a un registro de cola
así como las variables necesarias:

programa cola;

tipo
pQueue = ^tqueue;
tQueue = registro
data: integer;
siguiente: pCola;
fin;

var
cabeza, último, actual: pQueue;

comenzar
fin.
Ahora haremos 3 procedimientos. El primer procedimiento añadirá elementos a la lista, el segundo
ver la lista y el tercero liberará la memoria utilizada por la cola. Antes de que hagamos el
procedimientos, primero echemos un vistazo al programa principal.

comenzar
cabeza := nil;{Establecer cabeza en nil porque no hay elementos en la cola}
agregar(1){Agregar 1 a la cola utilizando el procedimiento de agregar};
agregar(2);
agregar(3);
view;{View all items in the queue}
destroy;{Free the memory used by the queue}
fin.

El procedimiento de adición tomará un entero como parámetro y añadirá ese entero al final de la
cola.

procedimiento agregar(i: entero);

begin
nuevo(cur);{Crear nuevo elemento en la cola}
cur^.data := i;{Establecer el valor del elemento de la cola a i}
cur^.next := nil;{Establecer el siguiente elemento en la cola a nil porque se
no existe
si cabeza = nil entonces {Si no hay cabeza de la cola entonces}
head := cur{Current es la nueva cabeza porque es el primer elemento que se está
agregado a la lista
sino
last^.next := cur;{Establece el último artículo anterior al actual porque es
el nuevo último elemento en la cola
último := cur;{Hacer que el ítem actual sea el último ítem en la cola}
fin;

El procedimiento de vista utiliza un bucle para mostrar los datos desde el primer artículo hasta el último artículo del
cola.

procedimiento ver;
comenzar
cur := cabeza;{Establecer el actual al principio de la cola}
mientras cur <> nil haz {Mientras hay un elemento actual}
comenzar
writeln(cur^.data);{Mostrar el elemento actual}
cur := cur^.siguiente;{Establecer actual al siguiente elemento en la cola}
fin;
fin;

El procedimiento de destrucción liberará la memoria que fue utilizada por la cola.

procedimiento destruir;
comenzar
cur := cabeza; {Establecer el actual al principio de la cola}
mientras cur <> nil haga{Mientras haya un ítem en la cola}
comenzar
cur := cur^.next;{Almacena el siguiente elemento en el actual}
dispón(head);{Libera la memoria utilizada por head}
 cabeza := cur;{Establecer la nueva cabeza de la cola al ítem actual}
end;
fin;

Pilhas
Para entender una pila, debes pensar en una pila de platos. Puedes añadir un plato a la parte superior de
la pila y toma uno de arriba, pero no puedes añadir o quitar un plato de abajo sin
todas las placas cayendo. Esto se llama LIFO (Último en entrar, primero en salir).

Elemento 1 <-- Elemento 2 <-- Elemento 3 <-- (Hasta el último elemento)

Cuando declares el registro para un elemento de la pila, debes usar previous en lugar de next. Aquí hay un
ejemplo.

programa pila;

tipo
pStack = ^tStack;
tStack = registro
data: integer;
prev: pStack;
fin;

var
último, cur: pStack;

comenzar
último := nil;
agregar(3);
agregar(2);
agregar(1);
vista;
destruir
fin.

Verás que los números se suman de 3 a 1 con una pila en lugar de 1 a 3. Esto es
porque las cosas deben salir de la parte superior de la pila en lugar de salir de la cabeza de una cola.

El procedimiento de agregar añade el artículo después del último artículo en la pila.

procedimiento agregar(i: entero);

comenzar
nuevo(cur);{Crear nuevo elemento de pila}
cur^.data := i;{Establecer el valor del ítem al valor del parámetro}
cur^.prev := last; {Establecer el elemento anterior como el último elemento en la pila}
último := cur;{Haz del elemento actual el nuevo último elemento}
fin;

Los procedimientos de ver y destruir son casi los mismos que con una cola, por lo que no será necesario que se
explained.
procedimiento ver;
comenzar
cur := último;
mientras cur <> nil hacer
comenzar
escribe(cur^.data);
cur := cur^.prev;
fin;
fin;

procedimiento destruir;
comenzar
mientras last <> nil haga
comenzar
cur := last^.prev;
eliminar(último);
último := cur;
fin;
fin;