1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
---
language: Pascal
filename: learnpascal-es.pas
contributors:
- ["Ganesha Danu", "http://github.com/blinfoldking"]
- ["Keith Miyake", "https://github.com/kaymmm"]
translators:
- ["Ivan Alburquerque", "https://github.com/AlburIvan"]
lang: es-es
---
>Pascal es un lenguaje de programación imperativo y de procedimiento, que Niklaus Wirth diseñó en 1968–69 y publicó en 1970, como un lenguaje pequeño y eficiente destinado a fomentar las buenas prácticas de programación utilizando programación estructurada y estructuración de datos. Se nombra en honor al matemático, filósofo y físico francés Blaise Pascal. fuente: [wikipedia](https://es.wikipedia.org/wiki/Pascal_(lenguaje_de_programación)))
Para compilar y ejecutar un programa pascal puede usar un compilador pascal gratuito. [Descargar aquí](https://www.freepascal.org/)
```pascal
//Anatomía de un programa en Pascal
//Esto es un comentario
{
Esto es un
comentario multilínea
}
//nombre del programa
program learn_pascal; //<-- no olvides el punto y coma
const
{
Aquí es donde se debe declarar valores constantes.
}
type
{
Aquí es donde se debe declarar un tipo de datos personalizado
}
var
{
aquí es donde se debe declarar una variable
}
//área principal del programa
begin
{
área para declarar su instrucción
}
end. // El final de un área principal del programa debe requerir un símbolo "."
```
```pascal
//declarando variable
//puedes hacer esto
var a:integer;
var b:integer;
//o esto
var
a : integer;
b : integer;
//o esto
var a,b : integer;
```
```pascal
program Learn_More;
//Aprendamos sobre los tipos de datos y sus operaciones.
const
PI = 3.141592654;
GNU = 'GNU No Es Unix';
// las constantes se nombran convencionalmente usando CAPS (mayúscula)
// sus valores son fijos y no se pueden cambiar durante el tiempo de ejecución
// tiene cualquier tipo de datos estándar (enteros, reales, booleanos, characteres, cadenas)
type
ch_array : array [0..255] of char;
// los son nuevos 'tipos' que especifican la longitud y el tipo de datos
// esto define un nuevo tipo de datos que contiene 255 caracteres
// (esto es funcionalmente equivalente a una variable string[256])
md_array : array of array of integer;
// los arreglos anidados son equivalentes a los arreglos multidimensionales
// puede definir arreglos de longitud cero (0) que son de tamaño dinámico
// esta es una matriz bidimensional de enteros
//Declarando variables
var
int, c, d : integer;
// Tres variables que contienen números enteros.
// los enteros son de 16 bits y están limitados al rango [-32,768..32,767]
r : real;
// una variable que contiene un número real como tipos de datos
// el rango de los reales pueden variar entre [3.4E-38..3.4E38]
bool : boolean;
// una variable que contiene un valor booleano (True/False)
ch : char;
// una variable que contiene un valor de carácter
// Las variables char se almacenan como tipos de datos de 8 bits, por lo que no hay UTF
str : string;
// una variable no estándar que contiene un valor de cadena
// Las cadenas son una extensión incluida en la mayoría de los compiladores de Pascal.
// se almacenan como una matriz de caracteres con una longitud predeterminada de 255.
s : string[50];
// una cadena con longitud máxima de 50 caracteres.
// puede especificar la longitud de la cadena para minimizar el uso de memoria
my_str: ch_array;
// Puedes declarar variables de tipos personalizados.
my_2d : md_array;
// Las matrices de tamaño dinámico deben dimensionarse antes de que puedan usarse.
// tipos de datos enteros adicionales
b : byte; // rango [0..255]
shi : shortint; // rango [-128..127]
smi : smallint; // rango [-32,768..32,767] (entero estándar)
w : word; // rango [0..65,535]
li : longint; // rango [-2,147,483,648..2,147,483,647]
lw : longword; // rango [0..4,294,967,295]
c : cardinal; // longword
i64 : int64; // rango [-9223372036854775808..9223372036854775807]
qw : qword; // rango [0..18,446,744,073,709,551,615]
// tipos reales adicionales
rr : real; // rango depende de la plataforma (i.e., 8-bit, 16-bit, etc.)
rs : single; // rango [1.5E-45..3.4E38]
rd : double; // rango [5.0E-324 .. 1.7E308]
re : extended; // rango [1.9E-4932..1.1E4932]
rc : comp; // rango [-2E64+1 .. 2E63-1]
Begin
int := 1;// como asignar un valor a una variable
r := 3.14;
ch := 'a';
str := 'manzana';
bool := true;
//pascal no es un lenguaje sensible a mayúsculas y minúsculas
//operación aritmética
int := 1 + 1; // int = 2 sobrescribiendo la asignacion anterior
int := int + 1; // int = 2 + 1 = 3;
int := 4 div 2; //int = 2 operación de división donde el resultado será redondeado.
int := 3 div 2; //int = 1
int := 1 div 2; //int = 0
bool := true or false; // bool = true
bool := false and true; // bool = false
bool := true xor true; // bool = false
r := 3 / 2; // un operador de división para reales
r := int; // Puede asignar un entero a una variable real pero no a la inversa
c := str[1]; // asigna la primera letra de str a c
str := 'hola' + 'mundo'; // combinando cadenas
my_str[0] := 'a'; // asignación de matriz necesita un índice
setlength(my_2d,10,10); // inicializa matrices de tamaño dinámico: matriz 10 × 10
for c := 0 to 9 do // los arreglos comienzan en 0 y terminan en longitud - 1
for d := 0 to 9 do // Para los contadores de bucle hay que declarar variables.
my_2d[c,d] := c * d;
// aborda las matrices multidimensionales con un único conjunto de corchete
End.
```
```pascal
program Functional_Programming;
Var
i, dummy : integer;
function recursion_factorial(const a: integer) : integer;
{ calcula recursivamente el factorial del parámetro entero a }
// Declare variables locales dentro de la función.
// e.g.:
// Var
// local_a : integer;
Begin
If a >= 1 Then
// devuelva valores de las funciones asignando un valor al nombre de la función
recursion_factorial := a * recursion_factorial(a-1)
Else
recursion_factorial := 1;
End; // termine una función usando un punto y coma después de la instrucción End.
procedure obtener_entero(var i : integer; dummy : integer);
{ obten la entrada del usuario y almacenarla en el parámetro entero i.
los parámetros que preceden a 'var' son variables, lo que significa que su valor
puede cambiar fuera del parámetro. Los parámetros de valor (sin 'var') como 'dummy'
son estáticos y los cambios realizados dentro del alcance de la función/procedimiento
no afectan la variable que se pasa como parámetro }
Begin
write('Escriba un entero: ');
readln(i);
dummy := 4; // dummy no cambiará el valor fuera del procedimiento
End;
Begin // bloque de programa principal
dummy := 3;
obtener_entero(i, dummy);
writeln(i, '! = ', recursion_factorial(i));
// muestra i!
writeln('dummy = ', dummy); // siempre muestra '3' ya que dummy no ha cambiado.
End.
```
|
