mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
203 lines
7.3 KiB
Markdown
203 lines
7.3 KiB
Markdown
---
|
||
filename: learnpascal-es.pas
|
||
contributors:
|
||
- ["Ganesha Danu", "http://github.com/blinfoldking"]
|
||
- ["Keith Miyake", "https://github.com/kaymmm"]
|
||
translators:
|
||
- ["Ivan Alburquerque", "https://github.com/AlburIvan"]
|
||
---
|
||
|
||
|
||
>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.
|
||
```
|
||
|