En nuestra segunda lección vimos como mostrar mensajes en pantalla (salida estándar) mediante los procedimientos write y writeln mostrando la diferencia entre uno y otro. Si no comprendieron eso vuelvan a la segunda lección y practiquen o pregunten hasta que se entienda.
En esta lección hablaremos principalmente de la entrada estándar, o sea, hablaremos de cómo introducir información a un programa. Esto es sumamente amplio por lo cual no es posible desarrollarlo en una sola lección, al menos no de forma que quede claro, por eso solo mostraré lo básico primero.
De este modo debo introducir un primer concepto de variables y tipos primitivos de datos, lo cual nos lleva a hablar de lo que es un identificador.
-------------------------------------------------------------------------------------
Identificadores
Como habrán visto hice alusión a lo que es un identificador cuando en nuestra segunda lección dije que luego de la palabra reservada PROGRAM debíamos colocar un nombre para nuestro programa, sin embargo no expliqué más nada por lo cual esa idea quedó en el aire.
Un identificador es un nombre que nosotros asignamos a algo en nuestro programa para luego reconocerlo y hacer alusión a eso mediante dicho nombre. Por ejemplo, le daremos nombre a las variables, a los tipos, a los subprogramas, a las constantes y a alguna otra cosa más, todo siendo visto poco a poco en el curso.
Un identificador puede ser cualquier cadena de caracteres alfanuméricos o de subrayado que comience al menos con una letra.
No puede contener espacios ni caracteres especiales así como tampoco puede ser igual a una palabra reservada.
De este modo, identificadores válidos pueden ser: Abuela, ABuela2, Ejemplo_de_identificador, E2B214, etc.
Identificadores inválidos podrían ser: 1Abuela, Abuela 2, Ejemplo de Identificador, Abk$, Variable(), pascal, var, program, etc.
NOTA: No podemos repetir identificadores, o sea, no puede haber dos o más cosas con el mismo nombre.
-------------------------------------------------------------------------------------
Variables
Cuando nosotros queremos ingresar información a un programa o trabajar con valores dentro de él se hace necesario poder almacenar dichos valores y obtenerlos cuando queramos. Allí entran en juego las variables.
De forma sencilla, una variable guarda información de un tipo específico permitiéndonos luego trabajar con dicho valor y/o modificarlo.
Los tipos de datos que puede almacenar una variable existen de forma predeterminada en pascal (tipos primitivos) y constan principalmente de números y caracteres. Más adelante aprenderemos a definir nuestros propios tipos, pero para eso falta bastante.
En esta lección veremos dos tipos básicos de datos numéricos en los ejemplos, con lo cual todo esto quedará mucho más claro.
-------------------------------------------------------------------------------------
Pascal nos provee de dos tipos de datos numéricos muy útiles y sencillos de usar: enteros (integer) y reales (real).
Un entero, matemáticamente, es cualquier número que no tiene cifras luego de la coma, pudiendo este ser positivo, negativo o cero. Por ejemplo: 1, 2, 3 y 4 son números enteros, -1, -2, -3 y -4 también lo son y como ya dije el 0 también lo es.
Un número real, matemáticamente, es cualquier número existente, cualquier número que se nos ocurra, sea entero o no. Sin embargo en pascal hay que tener cuidado con esto, lo digo por aquellos que entienden la matemática. Veremos que hay mucha diferencia entre trabajar con enteros que con reales en pascal.
Veamos un ejemplo en el que declararé una variable de tipo entero (integer) y luego le asignaré el valor 10:
Código Pascal:
Ver original
La primera línea de nuestro programa es igual que siempre, la palabra PROGRAM y luego un identificador seguido de un punto y coma. Luego dejo una línea en blanco para que quede más prolijo y en la línea número tres ven la palabra reservada VAR.
VAR indica que luego de allí se declararán todas las variables que usará nuestro programa. Esto se hace siempre antes de comenzar con el código de instrucciones, o sea, antes de la palabra reservada BEGIN. En este caso concreto luego de VAR he declarado una variable llamada numero del tipo integer, o sea que numero almacenará valores numéricos enteros.
Como pueden observar allí, la declaración de una variable es así:
nombre_de_la_variable: tipo_de_datos;
o sea, le damos un nombre (identificador) a la variable, luego ponemos dos puntos y finalmente indicamos el tipo de datos que almacenará esa variable. Noten que luego de la palabra VAR no va punto y coma, eso es porque VAR no es una instrucción, solo indica que luego de allí declararemos las variables, igual que sucede con BEGIN. Sin embargo, cada declaración de variable sí lleva punto y coma.
Este programa consta de una única instrucción que lo único que hace es asignarle a la variable numeroel valor 10. La asignación de valores a una variable es una operación muy común y se hace así:
nombre_de_la_variable:= valor_a_asignar;
Como pueden apreciar, hemos utilizado el identificador numero para hacer alusión a nuestra variable, ya que mediante esa palabra el programa la identifica.
El símbolo (:=) es el símbolo de asignación y solo se usará para dar un valor a algo. Esto sustituye el valor anterior, o sea, sobreescribe la variable; mucho cuidado con eso, una vez modificada una variable no es posible recuperar el valor anterior.
------------------------------------------------------------------------------------
Salida Estándar: Mostrar contenido de una variable
Ahora veamos el mismo programa pero esta vez mostraremos en pantalla el valor que contiene nuestra variable:
Código Pascal:
Ver original
Este programa es idéntico al anterior salvo que agregamos una instrucción. Si ponemos el nombre de una variable dentro de un procedimiento write o writeln le estamos diciendo al programa que muestre el valor de dicha variable en pantalla. Como ven, el identificador de una variable es nuestra forma de reconocerla y hacer alusión a ella.
NOTA: No es lo mismo la instrucción writeln(numero) que writeln('numero'). ¿Cuál es la diferencia?
------------------------------------------------------------------------------------
Ahora vean el siguiente programa:
Código Pascal:
Ver original
¿Cuál será la salida de este programa?
Ahora trabajemos con dos variables para ver algunos ejemplos interesantes:
Código Pascal:
Ver original
En este ejemplo he declarado dos variables del tipo integer. Como pueden observar, es posible declarar varias variables de un mismo tipo en una sola sentencia, simplemente declaramos a las variables separadas por coma y luego decimos de qué tipo serán. La forma general sería
variable1, variable2, ... , variableN: tipo;
También es posible declararlas por separado, quedaría así
Código Pascal:
Ver original
Observen la línea 8 de nuestro programa: a la variable numero2 le asignamos mediante el símbolo := el valor de la variable numero más (+) el valor 5. De este modo, numero2 vale 15.
El símbolo + es para la suma. Es posible asignar a una variable el resultado de una operación, sea una suma, resta, producto o división, incluso operaciones combinadas. Esto lo veremos a medida que trabajemos con programas más complejos.
Este tema le ha gustado a 1 personas