learnxinyminutes-docs/es/pascal.md

---
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.
```