Merge pull request #1 from adambard/master

Update from Upstream

1 files changed, 205 insertions, 0 deletions

diff --git a/es-es/pascal-es.html.markdown b/es-es/pascal-es.html.markdown
new file mode 100644
index 00000000..8328fa1e
--- /dev/null
+++ b/es-es/pascal-es.html.markdown
@@ -0,0 +1,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.
+
+```
+