Para mostrar datos, tanto en pantalla como en impresora, se emplean write y writeln. La diferencia entre ambos es que "write" deja el cursor en la misma línea, a continuación del texto escrito, mientras que "writeln" baja a la línea inferior. Ambas órdenes pueden escribir tipos casi de cualquier clase: cadenas de texto, números enteros o reales, etc. No podremos escribir directamente arrays, records, ni muchos de los datos definidos por el usuario.
Cuando se desee escribir varias cosas en la misma línea, todas ellas se indican entre un mismo paréntesis, y separadas por comas.
Un comentario para quien ya haya programado en Basic: en la mayoría de las versiones de este lenguaje si separamos varios datos mediante comas en una sentencia PRINT, se verán separados en pantalla por un cierto número de espacios. En ese aspecto, la "," de Pascal recuerda más al ";" de Basic, ya que escribe los datos uno a continuación del otro. De hecho, si fueran números, ni siquiera aparecerían espacios entre ellos (también al contrario que en la mayoría de versiones de Basic):
WriteLn (1,10,345);daría como resultado
110345
Se puede especificar la anchura de lo escrito, mediante el símbolo de dos puntos (:) y la cifra que indique la anchura. Si se trata de un número real y queremos indicar también el número de decimales, esto se hace también después de los dos puntos, con el formato ":anchura_total:decimales". Como ejemplos:
program Write1;
var
nombre: string[40];
edad: byte;
resultado: real;
begin
nombre := 'Pepe';
edad := 18;
resultado := 13.12;
write ('Hola, ',nombre,' ¿qué tal estás? ');
writeln (resultado:5:2);
writeln('Hola,',nombre:10,'. Tu edad es: ',edad:2);
end.
En el caso de una cadena de texto, la anchura que se indica es la que se tomará como mínima: si el texto es mayor no se "parte", pero si es menor, se rellena con espacios por la izquierda hasta completar la anchura deseada.
Igual ocurre con los números: si es más grande que la
anchura indicada, no se "parte", sino que se escribe
completo. Si es menor, se rellena con espacios por la
izquierda. Los decimales sí que se redondean al
número de posiciones indicado:
program Write2;
var num: real;
begin
num := 1234567.89;
writeln(num);
(* La línea anterior lo escribe con el formato por defecto:
exponencial *)
writeln(num:20:3); (* Con tres decimales *)
writeln(num:7:2); (* Con dos decimales *)
writeln(num:4:1); (* Con un decimal *)
writeln(num:3:0); (* Sin decimales *)
writeln(num:5); (* ¿Qué hará ahora? *)
end.
La salida por pantalla de este programa sería:
1.2345678900E+06
1234567.890
1234567.89
1234567.9
1234568
1.2E+06
Aquí se puede observar lo que ocurre en los distintos casos:
writeln(num:20:3); (* Con tres decimales *)
Un comentario es algo el compilador va a ignorar, como si no hubiéramos escrito nada, y que nosotros incluimos dentro del programa para que nos resulte más legible o para aclarar lo que hace una línea o un conjunto de líneas.
En Pascal, los comentarios se encierran entre (* y *). También está permitido usar { y }, tanto en Turbo Pascal como en SURPAS. Como se ve en el ejemplo, los comentarios pueden ocupar más de una línea.
A partir de ahora, yo emplearé los comentarios para ayudar a que se entienda un poco más el desarrollo del programa, y también para incluir una cabecera al principio, que indique el cometido del programa y los compiladores con los que ha sido comprobado.
En la práctica, es muy importante que un programa esté bien documentado. Cuando se trabaja en grupo, la razón es evidente: a veces es la única forma de que los demás entiendan nuestro trabajo. En estos casos, el tener que dar explicaciones "de palabra" es contraproducente: Se pierde tiempo, las cosas se olvidan... Tampoco es cómodo distribuir las indicaciones en ficheros aparte, que se suelen extraviar en el momento más inoportuno. Lo ideal es que los comentarios aclaratorios estén siempre en el texto de nuestro programa.
Pero es que cuando trabajamos solos también es importante, porque si releemos un programa un mes después de haberlo escrito, lo habitual es que ya no nos acordemos de lo que hacía la variable X, de por qué la habíamos definido como "Record" y no como "Array", por qué dejábamos en blanco la primera ficha o por qué empezábamos a ordenar desde atrás.
Por cierto, que de ahora en adelante, como ya entendemos eso de los comentarios, los usaré para indicar las versiones en las que está comprobado cada uno de los programas, y para explicar un
poco lo que hace.
(Nota: según el compilador que manejemos, es habitual que un comentario que empezamos con (* se deba terminar con *), y no con }. También es frecuente que no se puedan "anidar" comentarios, de modo que algo como begin {{} end es correcto, porque la segunda llave abierta se ignora en la mayoría de los compiladores, mientras que algunos exigirán que se cierre también: begin {{}} end Puede incluso que algún compilador nos permita escoger cual de las dos opciones preferimos.
Una observación: si queremos escribir las comillas (o algún símbolo extraño que no aparezca en el teclado) como parte de un texto, podemos hacerlo de varias formas. La forma habitual es conociendo su código ASCII y usando la función CHR. Por ejemplo, el símbolo ~ corresponde al código ASCII 126, de modo que usaríamos “write(chr(126))”. En Turbo Pascal existe también una notación alternativa, que es usar # en vez de CHR, de manera que podríamos escribir “write(#126)”. Y para el caso particular de las comillas, hay una posibilidad extra: si dentro de una orden write ponemos dos comillas seguidas, el compilador entenderá que queremos escribir una de ellas.
Vamos a verlo con un ejemplo:
Ejercicio propuesto: Crea un programa que pida al usuario dos números reales y muestre en pantalla el resultado de su división, con dos cifras decimales.
{--------------------------}
{ Ejemplo en Pascal: }
{ }
{ Como escribir las }
{ comillas }
{ COMILLA.PAS }
{ }
{ Este fuente procede de }
{ CUPAS, curso de Pascal }
{ por Nacho Cabanes }
{ }
{ Comprobado con: }
{ - Free Pascal 2.2.0w }
{ - Turbo Pascal 7.0 }
{ - FPK Pascal 1.0 }
{--------------------------}
program comilla;
begin
writeln(' writeln(' + chr(39) + 'Esto es un ejemplo' +chr(39) +')');
writeln(' writeln(' + #39 + 'Esto es un ejemplo' + #39 +')');
writeln(' writeln(''Esto es un ejemplo'')');
end.
writeln('Por favor, introduzca su nombre');
readln(nombre);
"Readln" tiene algunos inconvenientes:
A pesar de estos inconvenientes, es la forma estándar de leer datos del teclado, así vamos a ver un ejemplo de cómo usarla:
{--------------------------}
{ Ejemplo en Pascal: }
{ }
{ Introducción de datos }
{ con ReadLn }
{ READLN1.PAS }
{ }
{ Este fuente procede de }
{ CUPAS, curso de Pascal }
{ por Nacho Cabanes }
{ }
{ Comprobado con: }
{ - Free Pascal 2.2.0w }
{ - Turbo Pascal 7.0 }
{ - Turbo Pascal 5.0 }
{ - Surpas 1.00 }
{--------------------------}
program Readln1;
var
nombre: string[40];
edad: byte;
begin
write ('Escribe tu nombre: ');
readln(nombre);
write ('Y ahora tu edad: ');
readln(edad);
write ('Hola, ',nombre,' ¿qué tal estás?');
writeln('Hola,',nombre:10,'. Tu edad es:',edad:2);
end.
Más adelante, veremos que existen formas mucho más versátiles y cómodas de leer datos a través del teclado, en el mismo tema en el que veamos cómo se maneja la pantalla en modo texto desde Pascal...
Ejercicio propuesto: Crea un programa que pida al usuario su nombre y su apellido y luego los escriba al revés, separados por una coma. Por ejemplo si el usuario introduce Nacho como nombre y Cabanes como apellido, se escribirá Cabanes, Nacho.