Fundamentos de programación/Entrada y salida de datos

De Wikiversidad
Ir a la navegación Ir a la búsqueda
Lección 11
Entrada y salida de datos

Para que un programa pueda ejecutar las tareas para las que fue creado es necesario que se pueda comunicar con los usuarios para capturar la información y presentar los resultados.[1] También debe poder almacenar y recuperar información de dispositivos de almacenamiento permanente para preservarla ya que el contenido de las variables se pierde una vez que la ejecución del programa termina.[2] El contenido de los dispositivos de almacenamiento permanente se organiza en unidades llamadas archivos que los programas abren para poder leer o escribir información. El mecanismo para interactuar con un usuario se llama interfaz de usuario y puede ser gráfica o de texto.[1]

Interfaz de línea de comandos[editar]

Las interfaces de líneas de comandos o interfaces de texto le permiten a los usuarios interactuar con la computadora usando un teclado y la pantalla de un monitor.[1] Cuando se ejecuta un programa, el sistema operativo de la máquina le permite enviar texto a la pantalla y capturar información desde el teclado,[3] permitiéndole usuario introducir datos para su procesamiento y tener acceso a los resultados. Algunos lenguajes de programación tienen instrucciones específicas para escribir y capturar datos[2] mientras que otros no tienen instrucciones específicas pero proporcionan bibliotecas con funciones predefinidas para procesar información mediante este tipo de interfaces.[3]

Para realizar operaciones de entrada y salida de texto supondremos que existe una biblioteca proporcionada por el lenguaje (es_texto.bib) con funciones para escribir texto a la pantalla y capturar de datos desde el teclado:

subrutina nueva_linea ()
Termina la línea actual y coloca el cursor de la pantalla al inicio de la línea siguiente.
subrutina desplegar_en_pantalla (cadena texto)
Despliega en pantalla el texto especificado en el parámetro texto a partir de la posición actual del cursor.
cadena subrutina leer_texto ()
Activa el modo de captura de datos en la interfaz de texto y regresa una cadena con los carácteres digitados por el usuario. La ejecución del programa se suspende en este punto y se reinicia cuando el usuario indica que ha terminado de escribir al usar la tecla de retorno («Enter»).

La biblioteca se cargaría con el siguiente código:

cargar ("es_texto.bib")

El siguiente ejemplo muestra un programa que le pide al usuario que especifique un número entero, calcula el número de Fibonacci correspondiente y le da el resultado al usuario. Una vez que presenta el resultado, el programa le pregunta al usuario si desea calcular otro número de Fibonacci. Si la respuesta es negativa, el programa termina, si es positiva repite el proceso. Se supondrá que existe una biblioteca llamada funciones_útiles.bib con las siguientes funciones:

  • entero fibonacci (entero número): Calcula el número de fibonacci correspondiente al parámetro indicado.
  • cadena entero_a_texto (entero número): Recibe un número entero y regresa su representación como una cadena de texto.
  • entero texto_a_entero (cadena texto): Recibe una cadena de texto y regresa el número entero correspondiente.
// Cargando las bibliotecas necesarias.
cargar ("cadenas.bib")
cargar ("es_texto.bib")
cargar ("funciones_útiles.bib")

lógico calcular_número := verdadero
cadena calcular_otro

cadena texto_del_número_a_calcular
entero número_a_calcular
entero número_de_fibonacci

mientras calcular_número hacer

  // Captura el número a calcular
  nueva_linea ()
  desplegar_en_pantalla ("¿Cuál número de Fibonacci desea calcular? ")
  texto_del_número_a_calcular := leer_texto ()
  número_a_calcular := texto_a_entero (texto_del_número_a_calcular)

  // Realiza el cálculo solicitado
  número_de_fibonacci := fibonacci (número_a_calcular)

  // Presenta el resultado
  nueva_linea ()
  desplegar_en_pantalla ("El número de Fibonacci solicitado es: ")
  desplegar_en_pantalla ( entero_a_texto (número_de_fibonacci) )

  // Preguntar si es necesario calcular otro número
  nueva_linea ()
  desplegar_en_pantalla ( "¿Desea calcular otro número de Fibonacci? ")
  calcular_otro := leer_texto ()

  // Si el usuario escribió cualquier cosa diferente de «Si», 
  // no se hacen más cálculos.
  si iguales (calcular_otro, "Si") = falso entonces
    calcular_número := falso
  fin_si

fin_mientras

// Mensaje de despedida.
nueva_linea ()
desplegar_en_pantalla ( "Programa terminado. ¡Que tenga un buen día!")

Interfaz gráfica de usuario[editar]

Las intefaces gráficas de usuario representan los objetos a manipular de forma pictórica en la pantalla mediante iconos o imágenes y capturan información mediante dispositivos de entrada como los ratones, lápices electrónicos y pantallas táctiles.[1] Cuando están bien diseñadas son más expresivas y fáciles de usar que las interfaces de texto, pero son mucho más complejas de programar.[4]

Están compuestas de componentes, también llamados controles, que los usuarios manipulan con los dispositivos de entrada para transmitirle instrucciones a los programas.[5] Cada una de las acciones de un usuario en los componentes genera eventos. Los programas definen funciones para realizar las tareas necesarias y le solicitan al sistema operativo de la máquina que los notifique cuando ocurran los eventos que les interesan. Al ocurrir el evento, el sistema operativo interrumpe el programa y le informa que el evento de interés ocurrió. El programa reacciona a la notificación ejecutando la función adecuada.[4]

Una interfaz gráfica de usuario adecuadamente organizada se compone de tres componentes principales: un modelo, una vista y un controlador. La vista se encarga de presentar la información y los componentes de la interfaz a los usuarios. El modelo consiste en el conjunto de funciones que el programa ejecutará en respuesta a los eventos del usuario. El controlador recibe del sistema operativo las notificaciones de los eventos que se generan cuando el usuario manipula la vista e invoca las funciones correspondientes del modelo.[4]

Archivos[editar]

La información almacenada en discos y otros tipos de almacenamiento secundario se organiza típicamente en archivos, estructuras lógicas que agrupan la información de interés y le dan un nombre y una ubicación en la estructura lógica del disco. Los programas acceden a los archivos usando conexiones administradas por los sistemas operativos que les permiten leer la información almacenada en los archivos o escribir en ellos la información que tienen almacenada en memoria.[6]

Las operaciones más frecuentes son abrir un archivo, leer su contenido, escribir datos y cerrar el archivo.[6] El formato más sencillo de archivo es el archivo de texto y se puede considerar como una secuencia de líneas de texto terminadas en un cambio de línea. En este proyecto de aprendizaje supondremos que existe una biblioteca proporcionada por el lenguaje (archivos.bib) con funciones para leer y escribir archivos:

entero subrutina abrir_archivo (cadena nombre_de_archivo, cadena modo_de_uso)
Para poder usar un archivo, primero es necesario abrirlo. Se debe especificar el nombre del archivo a abrir, así como el tipo de operación que se desea realizar con el archivo. La operación puede ser «leer» el contenido, «escribir» texto o «añadir» contenido al final. Si se abre un archivo para escribir, su contenido se pierde y se reemplaza con el contenido nuevo. La función regresa un entero que sirve como identificador de archivo.
cadena subrutina leer_línea_de_archivo (entero identificador_de_archivo)
Si se abre un archivo para «leer», se puede usar la función de lectura de líneas para recuperar su contenido. La función regresa todo el texto presente desde el inicio del archivo hasta el primer indicador de final de línea. Antes de regresar el resultado, la función guarda un indicador o puntero a la posición del último carácter recuperado. De esta forma las llamadas sucesivas a la función inician la lectura del archivo desde ese punto, lo que les permite leer las lineas del archivo ubicadas después de la línea leída en la ejecución anterior de la función. Si el indicador se encuentra al final del archivo y no hay más líneas que leer, la función regresa una cadena vacía.
subrutina escribir_línea_en_archivo (entero identificador_de_archivo, cadena línea_a_escribir)
Si se abre un archivo para «escribir» o «agregar» contenido, se puede usar la función de escritura para agregar cadenas de texto al final del archivo. Al final de cada cadena de texto se agrega un indicador de final de línea. Se pueden agregar líneas en blanco al archivo escribiendo la cadena vacía ("").
subrutina cerrar_archivo (entero identificador_de_archivo)
Una vez que se ha terminado de leer el archivo o de escribir en él, se debe cerrar para que el sistema operativo lo ponga a disposición de otros programas y para asegurarnos de que todo el contenido agregado ha sido escrito en el disco.

El siguiente ejemplo usa las funciones para leer archivos de texto descritas anteriormente para abrir un archivo y mostrarlo en la pantalla del computador.

// Cargando las bibliotecas necesarias.
cargar ("archivos.bib")
cargar ("cadenas.bib")
cargar ("es_texto.bib")

cadena nombre_del_archivo
entero archivo_abierto
cadena línea_actual
lógico más_líneas

// Capturar el  nombre del archivo a leer
nueva_linea ()
desplegar_en_pantalla ("¿Cuál es el archivo que desea leer? ")
nombre_del_archivo := leer_texto ()

más_líneas := verdadero

// Abriendo el archivo
archivo_abierto := abrir_archivo (nombre_del_archivo, "leer")

nueva_linea ()
desplegar_en_pantalla ("=== Inicio del archivo ===")
nueva_linea ()

mientras más_líneas hacer

  línea_actual := leer_línea_de_archivo (archivo_abierto)

  si largo_cadena(línea_actual) = 0 entonces

    más_líneas := falso

  sino

    desplegar_en_pantalla (línea_actual)

  fin_si

fin_mientras

nueva_linea ()
desplegar_en_pantalla ("=== Fin del archivo ===")

cerrar_archivo (archivo_abierto)

Resumen de la lección[editar]

  • Los programas necesitan capturar, presentar, almacenar y recuperar información.
  • Los usuarios pueden interactuar con los programas mediante interfaces de texto o interfaces gráficas.
  • Las interfaces de texto despliegan información en la pantalla y la capturan desde el teclado.
  • Las interfaces gráficas representan los objetos a manipular de forma pictórica en la pantalla mediante iconos o imágenes.
  • Las interfaces gráficas funcionan monitorizando las acciones de los usuarios y ejecutando acciones como respuesta a esos eventos.
  • Los archivos permiten almacenar la información en dispositivos de almacenamiento secundario y recuperarla posteriormente.
  • Las operaciones más frecuentes con archivos incluyen abrirlos, leerlos, escribir en ellos y cerrarlos.
  • Los archivos de texto se pueden considerar secuencias de líneas de texto terminadas en un cambio de línea.

Términos clave[editar]

Lecturas adicionales[editar]

Bibliografía[editar]

  1. 1,0 1,1 1,2 1,3 Brookshear, J. Glenn (2012). Computer Science: An overview [Introducción a la computación] (11.ª edición). Madrid, España: Pearson Educación, S. A. p. 704. ISBN 978-84-78-29139-7. 
  2. 2,0 2,1 Joyanes Aguilar, Luis (2013). Fundamentos generales de programación (1.ª edición). Ciudad de México, México: McGraw Hill. p. 368. ISBN 978-607-15-0818-8. 
  3. 3,0 3,1 Deitel, H. M.; Deitel, P. J. (1995). C How to program [Cómo programar en C/C++] (2.ª edición). México: Prentice Hall Hispanoamericana, S. A. p. 927. ISBN 968-880-471-1. 
  4. 4,0 4,1 4,2 Cartwright, Robert (6 de abril de 2009). «Elements of Object-Oriented Program Design» (PDF). Rice University, Department of Computer Science (en inglés). Texas, Estados Unidos. Consultado el 24 de julio de 2016. 
  5. Deitel, Paul J.; Deitel, Harvey M. (2009). JAVA for programmers. Deitel Developer Series (en inglés) (1.ª edición). Nueva Jersey, Estados Unidos: Prentice Hall. p. 1155. ISBN 978-0-13-700129-3. 
  6. 6,0 6,1 Folk, Michael J.; Zoellick, Bill (1992). File Structures (en inglés) (2.ª edición). Massachusetts, Estados Unidos: Addisin-Wesley. p. 590. ISBN 978-0-201-55713-8. 


Proyecto: Fundamentos de programación
Anterior: Evaluación de la lección 10 — Entrada y salida de datos — Siguiente: Evaluación de la lección 11