diff options
Diffstat (limited to 'es-es')
| -rw-r--r-- | es-es/pascal-es.html.markdown | 204 |
1 files changed, 204 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..d1e0345a --- /dev/null +++ b/es-es/pascal-es.html.markdown @@ -0,0 +1,204 @@ +--- +language: Pascal +filename: learnpascal.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://en.wikipedia.org/wiki/Pascal_(programming_language)) + +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's Not 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 estandar) + 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 factorial_recursion(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 + factorial_recursion := a * factorial_recursion(a-1) + Else + factorial_recursion := 1; +End; // termine una función usando un punto y coma después de la instrucción End. + +procedure get_integer(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; + get_integer(i, dummy); + writeln(i, '! = ', factorial_recursion(i)); + // outputs i! + writeln('dummy = ', dummy); // siempre muestra '3' ya que dummy no ha cambiado. +End. + +``` + |