TP 330 2020-1

330 TP Lapso 2020-1 1/7
UNIVERSIDAD NACIONAL ABIERTA

VICERRECTORADO ACADÉMICO
AREA: INGENIERÍA
TRABAJO PRÁCTICO
ASIGNATURA: PROCESAMIENTO DE DATOS
CÓDIGO: 330
FECHA DE ENTREGA AL ESTUDIANTE: 20/07/2020
FECHA DE DEVOLUCIÓN POR PARTE DEL ESTUDIANTE:

El estudiante contará hasta el día 16/10/20202 para su realización y envío.
El trabajo debe ser enviado al correo electrónico del asesor académico de la

asignatura Procesamiento de Datos (Cód. 330) en su centro local, o en su
defecto, si la corrección de la asignatura se encuentra a cargo del Nivel
Central, el estudiante deberá enviar su trabajo al Jefe de Unidad Académica
de su Centro Local, dentro del lapso previamente establecido. Luego el Jefe
de Unidad Académica procederá a remitir en un único correo los referidos
TPS a la Coordinación de la carrera de Ingeniería de Sistemas
(isistemas@una.edu.ve), a más tardar el 16/10/2020 sin prórroga.
NOMBRE DEL ESTUDIANTE: Juan Miguel Briceño Paredes
CÉDULA DE IDENTIDAD: V-27.587.375
CORREO ELECTRÓNICO DEL ESTUDIANTE: bricenojuan09@gmail.com

TELÉFONO: 0424-7261984
CENTRO LOCAL: Mérida
CARRERA: INGENIERÍA DE SISTEMAS
LAPSO ACADÉMICO: 2020-1
NUMERO DE ORIGINALES: 1
FIRMA DEL ESTUDIANTE: Juan Miguel Briceño Paredes
UTILICE ESTA MISMA PÁGINA COMO CARÁTULA DE SU TRABAJO
PRÁCTICO
RESULTADOS DE CORRECCIÓN:
OBJ. Nº 5
0:NL 1:L
Especialista: Nilda Altuna I Ing. de Sistem

Universidad Nacional Abierta
Procesamiento de Datos (330)
Juan Miguel Briceño Paredes
C.I: V-27.587.375
Mérida, octubre de 2020

Contenido
2. RESUMEN.......................................................................................................................................3
3. INTRODUCCIÓN.............................................................................................................................3
3.1. DEFINICIÓN CONTEXTUAL..................................................................................................4
4. DESARROLLO TEÓRICO.......................................................................................................................5
Normas de Codificación......................................................................................................................5
Estructura del programa.....................................................................................................................7
ENVIRONMENT DIVISION...................................................................................................................7
DATA DIVISION...................................................................................................................................8
PROCEDURE DIVISION........................................................................................................................8
Párrafos y bucles.............................................................................................................................8
Párrafos o Rutinas.............................................................................................................................................9
PERFORM…THRU...............................................................................................................................................9
PERFORM…TIMES............................................................................................................................................10
PERFORM…UNTIL............................................................................................................................................10
PERFORM…VARYING.......................................................................................................................................11
Ficheros:...........................................................................................................................................12
2. RESUMEN
Este trabajo práctico se enfoca en la ejecución de un software empleando el

lenguaje cobol para la tabulación de un inventario de instrumentos deportivos
necesarios para el apoyo de un centro deportivo público.
El lenguaje COBOL se desarrolló con el objetivo principal de conseguir un

lenguaje de programación que se pudiese utilizar en cualquier tipo de ordenador, y
que además fuese más sencillo que sus predecesores a la hora de ejecutarlo.
3. INTRODUCCIÓN
El lenguaje de programación COBOL surgió de la necesidad de crear un lenguaje

más sencillo y universal. Un lenguaje que sirviese para todo tipo de ordenadores,
y además que se dirigiese de manera preferente a entornos de empresa.
Fue en 1959 cuando se gestó este lenguaje, y a partir de ahí tuvo una gran
evolución en la que se han ido añadiendo diversas funciones. Los responsables
de esta creación fueron CODASYL, una entidad integrada por los fabricantes de
ordenadores, usuarios y el Departamento de Defensa de Estados Unidos.
Los profesionales de la industria que demandaban algo así, se vieron satisfechos

gracias a la puesta en marcha de COBOL, lo que permitió que se implementase
como un lenguaje estándar para las actividades de gestión que eran tan
necesarias en el ámbito empresarial.
Por lo tanto, se desarrolló para aplicaciones de carácter comercial, datos y

archivos, preferentemente. Esta es la principal diferencia con otro tipo de
lenguajes de programación como Linux, que en su caso está originado para
escribir y desarrollar programas de sistemas.
3.1. DEFINICIÓN CONTEXTUAL
Es un lenguaje de programación de alto nivel desarrollado por primera vez por el

Comité CODASYL (Conference on Data Systems Languages) en 1960. Desde
entonces, la responsabilidad por el desarrollo de nuevas normas COBOL ha sido
asumida por el American National Standards Institute (ANSI).
Ha habido 3 modificaciones de normas ANSI para este lenguaje: en 1968, 1974 y
1985.
COBOL es un acrónimo que significa Common Business Oriented Language

(Lenguaje orientado a los negocios comunes). Está diseñado para el desarrollo de
negocios, por lo general orientada a archivos y aplicaciones. No está diseñado
para escribir programas de sistemas, como por ejemplo un sistema operativo o un
compilador.
Durante más de cuatro décadas COBOL ha sido el lenguaje de programación

dominante en la informática empresarial, gracias a la capacidad de manejar
ficheros grandes. En ese tiempo se ha encontrado desafíos de un gran número
lenguajes de programación como PL1, Algol68, Pascal, Modula, Ada, C, C + +.
Todos estos lenguajes han encontrado su sitio en el mercado, pero ninguno ha
desplazado a COBOL.
Actualmente hay desafíos recientes como Java y Visual Basic y Python, que están
demostrando ser serios competidores.
4. DESARROLLO TEÓ RICO
Un programa es un conjunto de instrucciones escritas en un lenguaje que el
ordenador pueda entender.
El ordenador ejecuta instrucciones del programa, uno tras otro en secuencia hasta
que alcanza el final del programa, a menos que alguna instrucción en el programa
altere el orden de ejecución.
Veamos un ejemplo práctico muy simple para hacernos una pequeña idea de lo
que es un programa.
Queremos escribir un programa que acepte dos números desde el teclado,
multiplicarlos y mostrar el resultado en la pantalla del ordenador.
Cuando se nos plantea un problema debemos estudiar un poco e identificar los

datos que necesitamos y que queremos que haga el programa con esos datos:
 ¿Qué Necesitamos? Dos números, que le vamos a llamar Num1 y Num2.
 ¿Cuál es el proceso? Multiplicar Num1 por Num2.
 ¿Qué hacemos con la información que obtenemos? Vamos amostrarlo en

pantalla.
Los datos conocidos que necesitamos en un proceso, se almacenan en un

pequeño trozo en la memoria. Este trozo de memoria es lo que se llama variable.
Se le asigna un nombre para identificarlo y tener acceso a él en cualquier
momento del programa.
Normas de Codificación. Un programa en Cobol se escribe secuencialmente

en líneas de 80 columnas o menos con la siguiente división:
La parte (1) comprende las columnas de la 1 a la 6 ambas inclusive y se utiliza

para numerar las líneas. Prácticamente esto ya no se utiliza.
La parte (2) comprende la columna 7 y en ella podemos encontrar, un guión (-)

que nos indica que esta línea es continuación de la anterior pero que por su
tamaño ocupa mas de una línea, un asterisco (*) que nos indica que es un
comentario y por lo tanto el compilador lo ignora.
La parte (3) se le llama Área A comprende las columnas 8 a 11 ambas inclusive y

aquí es donde se escriben los nombre de las divisiones, de las secciones, de los
párrafos, los indicadores de FD (File Description) y los niveles de variables 01 y
77.
La parte (4) llamada Área B comprende desde la columna 12 a la 72 y en ellas se

incluirán todas las instrucciones del programa, las líneas de las secciones y los
niveles de variables mayores a 01.
La parte (5) de la columna 73 a la 80 no se utiliza y por lo tanto es ignorada por el

compilador.
En conclusión, sólo tenemos disponibles para escribir el código desde la columna
8 hasta la 72, todo aquello que escribamos a partir de ésta última el compilador lo
ignora y no lo compila y dará muchos errores de compilación.
El punto es algo muy a tener en cuenta en COBOL ya que nos indica el final de
una línea y determinan todas las secciones, divisiones y párrafos. Un simple punto
que se nos olvide, daría muchos errores al compilar y tendríamos muchos dolores
de cabeza hasta dar con el problema.
Todos los nombres definidos por el usuario, como variables, nombres de

párrafo…, deben cumplir con las siguientes reglas:
 Deben contener al menos un carácter, pero no más de 30 caracteres.
 Deben contener al menos un carácter alfabético.
 No debe comenzar ni terminar con un guión.
 Deben construirse a partir de los caracteres de la A a la Z, números del 0 al 9 y

el guión.
 No deben contener espacios y no se distinguen entre mayúsculas y

minúsculas, es decir, que es lo mismo NUM1, nUm1, num1.
Estructura del programa
La jerarquía de un programa en COBOL se compone de cuatro divisiones principales:
 IDENTIFICATION DIVISION. Consta de la información del programa.
 ENVIRONMENT DIVISION. Consta de la información del entorno.
 DATA DIVISION. Consta de las descripciones de los datos.
 PROCEDURE DIVISION. Consta de todo el algoritmo del programa.
IDENTIFICATION DIVISION. Esto es un ejemplo de la típica información que se

suele añadir en esta sección:
IDENTIFICATION DIVISION.
PROGRAM-ID Nombre del programa.
AUTHOR Nombre del autor.
INSTALLATION Lugar donde está instalado.
DATE-WRITTEN Fecha de creación.
DATE-COMPILED Fecha de compilación.
REMARKS Comentarios.
Ejemplo:
PROGRAM-ID. Programa1.
AUTHOR. Ismael.
INSTALLATION. WWW.
REMARKS. Programa de prueba.
ENVIRONMENT DIVISION.
Se utiliza para describir el ambiente en el que se ejecutará el programa, detalles

como el orden de clasificación, el símbolo de la moneda y el símbolo de punto
decimal.
DATA DIVISION.
Es donde definiremos los datos que vayamos a utilizar en nuestro programa. Existen
Otras secciones dentro de la DATA DIVISION que las veremos más adelante.
PROCEDURE DIVISION.
Es aquí donde el programador escribe el código o algoritmo del programa para su

correcto funcionamiento.
Algunos compiladores COBOL requieren que todas las divisiones deben estar
presente en un programa, mientras que otros sólo requieren mínimo de la
IDENTIFICATION DIVISION y la PROCEDURE DIVISION. Yo estoy haciendo estos
pequeños apuntes con el compilador OpenCobol bajo linux.
Este ejemplo del programa “hola mundo” que encontraremos en casi todos los
manuales y tutoriales que existen, es perfectamente válido cuando se compila con el
compilador OpenCobol:
PROGRAM-ID. Prueba.
PROCEDURE DIVISION.
Inicio.
DISPLAY "Hello world"
STOP RUN.
Párrafos y bucles
En casi todos los programas que se pueden crear, existen tareas que pueden o no
ser objeto de repetición. A estos procesos se les llama bucles o estructuras
repetitivas.
Por ejemplo, podemos tener un proceso que nos pida dos números unas 10 veces y
realizar cálculos matemáticos. Como es lógico, no vamos a escribir 10 veces el
proceso, lo que hacemos es hacer un bucle y que lo haga 10 veces, pero en realidad
a nivel de programación el proceso lo hemos definido una sola vez.
En esta parte vamos a aprender cómo se crean bucles o instrucciones repetitivas y
párrafos o rutinas para controlar el orden de ejecución del programa.
Párrafos o Rutinas. Siempre que se ejecuta un programa en COBOL, se hace de

forma secuencial, empezando desde arriba hasta que encuentre la instrucción de
finalizar el programa. Las rutinas es una forma de alterar ese orden, es decir, le
damos el control a un párrafo y ejecuta todas las instrucciones que haya en éste.
Veamos un ejemplo:
PROGRAM-ID. Parrafos.
AUTHOR. Ismael.
* Esto es un ejemplo usando rutinas o párrafos. PROCEDURE DIVISION.
Inicio.
DISPLAY "Este es el principio del programa"
PERFORM Rutina2
DISPLAY "Ahora voy a terminar el programa"
STOP RUN.
Rutina1.
DISPLAY "Estoy en la rutina1"
PERFORM Rutina3.
Rutina2.
DISPLAY "Ahora estoy en la rutina2"
PERFORM Rutina1.
Rutina3.
DISPLAY "Ahora estoy en la rutina3".
Si observamos detenidamente este ejemplo, lo que hacemos es el párrafo Inicio,
dentro de este llamamos a la Rutina 2, dentro de éste llamamos a la Rutina 1 y por
último desde la rutina1 llamamos al párrafo rutina 3. Una vez terminado estas rutinas,
el programa vuelve a su orden normal, es decir, realiza las sentencias que le faltaban
del párrafo Inicio, terminando así con la ejecución del programa. También hay que
decir, que hacer párrafos estructura un poco mejor el programa y puede resultar un
poco más legible y comprensible.
PERFORM…THRU. Esto es otra forma de usar los párrafos como rutinas, es

ejecutando más de un párrafo a la vez. Veamos un ejemplo:
PROGRAM-ID. Programa.
AUTHOR. Ismael.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 NOMBRE PIC X(12).
01 APELLIDO PIC X(12).
PROCEDURE DIVISION.
INICIO.
PERFORM PIDENOMBRE THRU PIDEAPELLIDO
STOP RUN.
PIDENOMBRE.
DISPLAY "DAME TU NOMBRE:"
ACCEPT NOMBRE.
PIDEAPELLIDO.
DISPLAY "DAME TUS APELLIDOS:"
ACCEPT APELLIDO.
PERFORM…TIMES. Vamos a ampliar un poco el número de veces que queremos

que repita un proceso. Esta sentencia sirve para repetir un párrafo un número de
veces determinado, su sintaxis es la siguiente:
Vamos a hacer un ejemplo, para aclarar un poco como funciona:

AUTHOR. Ismael.
DATA DIVISION.
01 NOMBRE PIC X(12).
01 APELLIDO PIC X(12).
PROCEDURE DIVISION.
INICIO.
PERFORM PIDENOMBRE THRU PIDEAPELLIDO 3 TIMES
STOP RUN.
PIDENOMBRE.
DISPLAY "DAME TU NOMBRE:"
ACCEPT NOMBRE.
PIDEAPELLIDO.
DISPLAY "DAME TUS APELLIDOS:"
ACCEPT APELLIDO.
PERFORM…UNTIL. Este tipo de sentencia sirve para realizar un párrafo hasta que
se cumpla la condición. Veamos un ejemplo:
AUTHOR. Ismael.
DATA DIVISION.
77 LI PIC 99 VALUE 0.
PROCEDURE DIVISION.
INICIO.
DISPLAY "PROGRAMA DE SALUDO"
PERFORM SALUDAR UNTIL LI =5
STOP RUN.
SALUDAR.
ADD 1 TO LI
DISPLAY "SALUDO Nº.: ", LI.
También podemos hacer el bucle de otra forma:

AUTHOR. Ismael.
DATA DIVISION.
PROCEDURE DIVISION.
INICIO.
DISPLAY "PROGRAMA DE SALUDO"
PERFORM UNTIL LI =5
ADD 1 TO LI
DISPLAY "SALUDO Nº.: ", LI
END-PERFORM
STOP RUN.
Si observamos un poco, la diferencias radican en que ahora tiene un “fin del bucle”.
Este proceso lo que haces es mostrar un saludo 5 veces. Para eso lo que hemos
utilizado es una variable (LI) para contar el número de veces que saludamos. A
continuación repetimos el párrafo SALUDAR hasta que se cumpla la condición es
decir, sea igual a 5.
Si nos fijamos bien en el código del programa, hemos iniciado la variable LI a 0,
¿Porque hacemos esto? Este tipo de procesos repetitivos lo que primero que hace es
comprobar la condición, y si no se cumple continúa con el proceso repetitivo. En este
caso le he dado el valor 0, si la diéramos un valor superior o igual 5 no entraría jamás
en el proceso repetitivo y terminaría el programa.
PERFORM…VARYING. Este tipo de bucles se le da valor a una variable y se

aumenta o disminuye dicho valor y el proceso lo hace tantas veces hasta que se
cumpla la condición. Con este tipo de bucle nos ahorraríamos algunas instrucciones,
ya que hace varias instrucciones en una sola. Veamos un ejemplo:

AUTHOR. Ismael.
DATA DIVISION.
PROCEDURE DIVISION.
INICIO.
PERFORM VARYING LI FROM 1 BY 1 UNTIL LI >5
DISPLAY "Saludo Nº.: ", LI
END-PERFORM
STOP RUN.
¿Cómo trabaja el VARYING?. Lo primero que hace es iniciar la variable LI al valor
que indica el FROM, pregunta por la condición y si no se cumple realiza las
sentencias que hay dentro. A continuación aumenta el valor de LI según lo que tenga
en el BY y vuelve a preguntar por la condición…y así sucesivamente hasta que se
cumpla la condición. En este caso realizará las sentencias con los valores 1, 2, 3, 4 y
5.
Ficheros: Los ficheros son archivos de datos donde se almacenan los valores que
necesitemos de un programa a nivel de registro, algo parecido como ocurre con los
registros de las bases de datos. Aunque COBOL se puede utilizar para procesar otros
tipos de archivo de datos, se utiliza generalmente sólo para procesar registros.
Hay esencialmente dos tipos de organización de registros:
 Archivos Secuenciales. Los registros se organizan y se accede en serie, es
decir, de forma secuencial pasando por los registros anteriores para ir a uno
específico.
 Archivos de acceso directo o Indexados. En un archivo de acceso directo, los
registros se organizan de una manera que permite el acceso directo a un registro
determinado sin tener que pasar por cualquiera de los registros anteriores.
Algunas organizaciones son más versátiles que otras, por ejemplo, un archivo con
una organización indexada puede tener acceso a sus registros de forma secuencial o
de forma directa, pero los registros en un archivo con una organización secuencial
sólo se pueden acceder de forma secuencial.
En la actualidad se suelen usar ficheros indexados, ya que los secuenciales sólo se
pueden agregar y leer y son un poco más engorrosos para poder actualizar, modificar
o borrar un registro.
Veamos algunos conceptos básicos para orientarnos y saber de lo que hablamos:
 Se usa el término archivo o fichero para almacenar todos aquellos valores que
necesitemos en un programa.
 El término registro se usa para describir un conjunto de campos que registran
información acerca de un sólo objeto.
 Usamos el término campo para describir cada información registrada sobre un
solo objeto, por ejemplo teléfono, dirección.

Vamos a imaginar una agenda de teléfono:
 El fichero sería toda la agenda. Un fichero con el nombre agenda.
 El registro sería el conjunto de información de cada persona, es decir; nombre,
teléfono, dirección, código postal…etc.
 El campo sería cada información independiente que tiene una persona de la
agenda, por ejemplo, el nombre es un campo, teléfono sería otro campo, la
dirección otro campo más y así sucesivamente.
 Todos los campos juntos es lo que forma registro, es decir, la fila entera, que
resulta que es toda la información que tenemos de una sola persona u objeto.
Vamos a usar de ejemplo la agenda e iremos definiendo un fichero de organización
secuencial en cobol:
Agenda.dat (así lo llamaremos).
Cada registro tendra esta estructura:

Orden Nombre Dirección Codigo Postal Teléfono
1 Ismael Calle Perú, 5 06010 999255124
2 Javier Calle Faisan, 16 06025 989525289
3 Lourdes Calle Perdiz, 21 06259 929444548
Ahora para definir este estructura de fichero en cobol:

…
ENVIRONMNET DIVISION.
INPUT-OUTPUT SECTION.
* Esta claúsula nos permite dar el nombre real del fichero en el disco.
* También podemos indicar el camino, por ejemplo “c:\ficheros\agenda.dat”
* El nombre que le asignemos en la SELECT debe coincidir con el de la FD.
SELECT AGENDA ASSIGN TO “AGENDA.DAT”.
DATA DIVISION.
FILE SECTION.
* El nombre interno que le asignamos se llamara agenda.
FD AGENDA.
* A continuación definimos como se llama el registro y como se estructura.
01 AGENDA-REG.
02 ORDEN PIC 9(2) VALUE ZEROS.
02 NOMBRE PIC X(15) VALUE SPACES.
02 DIRECCION PIC X(30) VALUE SPACES.
02 CODIGO-POSTAL PIC 9(4) VALUES ZEROS.
02 TELEFONO PIC 9(9) VALUES ZEROS.
Vemos como es la sintaxis de la instrucción SELECT:

SELECT NombreFichero ASSIGN TO NombreFicheroExterno
En estos tipos de archivos debemos tener en cuenta 4 instrucciones fundamentales.
OPEN, CLOSE, READ, WRITE . Vamos a ir viéndolos poco a poco y como funcionan.
OPEN. Veamos su sintaxis: OPEN modo nombreinternodelfichero
Antes de trabajar con un fichero, hay que asegurarse de abrirlo correctamente para
acceder a los datos que pueda contener para trabajar con ellos. Existen 3 formas de
abrir un fichero:
INPUT. Se abre un fichero en modo lectura. Usando este cláusula se coloca el
puntero en el primer registro. Si el fichero no existiera daría un error, ya que el primer
requisito es que el fichero exista.
OUTPUT. Se abre un fichero en modo escritura. Usando esta cláusula tiene la
peculiaridad de que si no existe lo crea y si existe, lo elimina y vuelve a crearlo. Hay

que tener cuidado con esto, ya que crea un nuevo fichero cada vez que lo utilizamos,
borrando los datos que pudiéramos tener almacenados.
EXTEND. Como su nombre indica, se abre un fichero para extenderlo, es decir, para
agregar más registros a los ya existentes. Cuando se abre de esta forma, el puntero
se coloca en el último registro para continuar almacenando datos. Obviamente el
requisito fundamental es que el fichero exista, si no fuera asi la instrucción OPEN nos
mostraría un error.
CLOSE. Su sintaxis es la siguiente: CLOSE nombreficherointerno…

Se debe siempre asegurase, antes de terminar con un programa, que se cierran
debidamente todos los ficheros que hayamos utilizado, ya que puede grabarse los
datos de mala manera y perder el acceso a estos ficheros en el futuro.
READ. Su sintaxis es la siguiente:

READ nombreinternodelfichero NEXT/PREVIOUS RECORD INTO descripción
AT END / NO AT END instrucciones
END-READ
Una vez que tengamos un fichero abierto, toca usar una instrucción para leer cada
registro, veamos cómo funciona:
 Cuando utilizamos esta instrucción, lo que hace es almacenar en un la
memoria una copia del registro que está leyendo para trabajar con él.
 INTO. Esto se utiliza para usar una variable en donde almacenar el registro. Al
hace esto, tendremos el registro en dos lugares, en la memoria y en la variable
para su posterior utilización.
 AT END. Este instrucción es la que nos indica cuando ha llegado al final del
fichero, es decir, cuando haya terminado de leer todos los registros que haya en
el fichero.
 NOT AT END. Es posible que queramos hacer algún tipo de procedimiento
cuando no ha llegado al final del fichero.
WRITE. Veamos su sintaxis; WRITE registró FROM variable.
 Esta instrucción sirve para grabar los datos en el fichero que usamos como
almacenamiento de datos.
 FROM. Esto sirve para realizar una copia en una variable del registro que
vayamos almacenar en el fichero.
Vamos a coger el ejemplo de la agenda de teléfono. Agregaremos un par de registros
y luego los leeremos y visualizaremos sus datos para ir viendo cómo funciona:
identification division.
program-id. Ficheros.
author. Ismael.
environment division.
input-output section.
file-control.
select agenda assign to "agenda.dat"
organization is line sequential.
data division.
file section.
fd agenda.
01 agenda-reg.
02 orden pic 9(2).
02 nombre pic X(15).
02 direccion pic X(30).
02 codigo-postal pic 9(5).
02 telefono pic 9(9).
working-storage section.
77 fin-fichero pic 9 value 0.
procedure division.
Inicio.
open output agenda
perform 3 times
perform agregar
perform limpiar-pantalla
end-perform
perform leer-agenda
close agenda
stop run.
agregar.
display "programa de la agenda"
display "dame el orden: "with no advancing
accept orden
display "dame el nombre: "with no advancing
accept nombre
display "dame la direccion: "with no advancing
accept direccion
display "dame el codigo postal: "with no advancing
accept codigo-postal
display "dame el telefono: "with no advancing
accept telefono
write agenda-reg.
limpiar-pantalla.
* usando esta instrucción, puedo llamar a cualquier comando del S.O.
CALL "SYSTEM" USING "clear".
leer-agenda.
move 0 to fin-fichero
close agenda
open input agenda
perform until fin-fichero=1
read agenda
at end move 1 to fin-fichero
not at end perform leer-registro
end-read
end-perform.
leer-registro.
display "orden: "orden
display "nombre: "nombre
display "direccion: “ direccion
display "codigo postal: "codigo-postal
display "telefono: "telefono.
Organización y Acceso.
Cuando hablamos de Organización de los datos, se refiere a la forma en la que se
organizan los registros en un dispositivo de almacenamiento. Existen en COBOL 3
tipos de organizaciones;
Secuencial. Registros organizan en serie.
Relativa. Organización basada en el número relativo de registro.
Indexado. Organización basada en uno o varios índices, es decir, por una o varias
claves como pasa con los las bases de datos.
Si hablamos de Método de acceso, se refiere a la forma en que se accede a los
registros. Dependiendo del tipo de organización hay varias formas de hacerlo:
Organización Secuencial. El modo de acceso sólo puede ser secuencial.
Organización Indexada. Este tipo de archivos o ficheros son los más utilizados en
cobol, ya que permiten en acceso de varias formas:
 Dynamic. Permite el acceso de forma secuencial o directa según nos interese
a lo largo del procedimiento.
 Random. Permite el acceso de forma directa, sin necesidad de pasar por los
registros anteriores.
Cuando utilizamos los ficheros indexados, existen varios parámetros extras que
debemos indicarle al a hora de definir el archivo en la SELECT, vamos a verlo:

SELECT nombrefichero ASSIGN TO nombreficherofisico
ORGANIZATION IS SEQUENTIAL
INDEXED
ACCESS MODE IS SEQUENTIAL
RANDOM
DYNAMIC
RECORD KEY IS claveprincipal
ALTERNATE RECORD KEY IS clavealternativa (WITH DUPLICATES)
FILE STATUS IS variable
 ACCESS MODE SEQUENTIAL. Modo de acceso es secuencial o de serie, es
decir, pasará por todos los registros anteriores para consultar uno específico.
 ACCESS MODE RANDOM. Modo de acceso directo, es decir, se desplazará
directamente al registro que vayamos a consultar sin necesidad de pasar por los
anteriores.
 ACCESS MODE DYNAMIC. Es el modo de acceso más utilizado, podemos
acceder de forma secuencial o directa cuando más nos interese dentro de un
programa.
 RECORD KEY. Clave principal se refiere a un campo numérico que debe ser
único para cada registro para poder identificarlo inequívocamente.
 ALTERNATE RECORD KEY. Clave alternativa se refiere a otro campo
numérico o alfanumérico para poder darle otro orden al fichero a la hora de
consultar. Se pueden hacer hasta 254 claves de este tipo en un sólo archivo.
Este tipo de claves se suele utilizar para realizar consultas por otro campo que no
sea la clave principal, por ejemplo, por fechas o por nombre…etc. Por defecto si
no se dice nada, son claves que no pueden duplicarse y son únicas por registro.
Si queremos una clave alternativa que se pudiera repetir hay que indicarle la
cláusula “WITH DUPLICATES”.
 FILE STATUS. Aquí se usa un campo alfanumérico de dos caracteres para
guardar el estado del fichero. Por ejemplo si abriéramos un archivo y este no
existiera por algún motivo, o no lo abra correctamente, almacenaría un código de
error en esa variable.
El código de error con el que trabajaremos será el “35”. Este número se guarda en la
variable que indiquemos en el FILE STATUS, cuando al abrir un fichero éste no
exista.
¿Qué cosas podemos hacer con los archivos indexados? Pues básicamente
podemos hacer OPEN, READ, WRITE y con estos tipos de archivos podemos hacer
REWRITE, DELETE y START gracias a los índices para identificar a cada registro.
OPEN. Veamos su sintaxis:

OPEN modo nombreinternodelfichero
Antes de trabajar con un fichero, hay que asegurarse de abrirlo correctamente para
acceder a los datos que pueda contener para trabajar con ellos. Existen 4 formas de
abrir un fichero:
 INPUT. Se abre un fichero en modo lectura. Si el fichero no existiera daría un
error, ya que el primer requisito es que el fichero exista.
 OUTPUT. Se abre un fichero en modo escritura. Usando esta cláusula tiene la
peculiaridad de que si no existe lo crea y si existe, lo elimina y vuelve a crearlo.
Hay que tener cuidado con esto, ya que crea un nuevo fichero cada vez que lo
utilizamos, borrando los datos que pudiéramos tener almacenados.
 I-O. El archivo se abre en modo lectura/escritura de forma que podemos
agregar, leer, escribir, rescribir o modificar y borrar la información de los
registros.
CLOSE. Su sintaxis es la siguiente:

CLOSE nombredelficherointerno…
Se debe siempre asegurase, antes de terminar con un programa, que se cierran
debidamente todos los ficheros que hayamos utilizado, ya que puede grabarse los
datos de mala manera y perder el acceso a estos ficheros en el futuro.
READ.
Hay que tener en cuenta que la lectura en este tipo de archivos se debe hacer en
función del tipo de acceso, es decir, si el acceso es secuencial se lee exactamente

igual que los ficheros de organización secuencial. Veamos que cambiaría si la
organización es indexada pero el acceso secuencial:

as
…
file-control.
select agenda assign to "agenda.dat"
organization is indexed
access mode is sequential
record key is orden
alternate record key is nombre
alternate record key is codigo-postal
file status is estado.
…
Agregar.
…
accept telefono
write agenda-reg
invalid key display "error al guardar"
end-write.
Si nos fijamos bien hay que darle un par de datos más, propio de los ficheros
indexados, como son por ejemplo las claves principales o alternativas, en el caso de
que las hubiere. La variable con la que trabajamos en la “file status” debemos
declararla en la “Working” como es lógico. También existiría un pequeño cambio a la
hora de escribir los registros, ya que dependemos de una clave principal para guardar
los cambios.
Ahora bien, si el acceso lo hemos definido como “Dynamic/Random”, dependerá del
valor de la clave que vayamos a utilizar para la consulta.

READ nombreinternodelfichero INTO descripción
KEY IS clave
INVALID KEY instrucciones
END-READ
Ahora dependemos del valor de uno o varios índices para poder leer un registro.
 KEY IS. Se debe indicar el campo que utilizamos como índice para la consulta.
 INVALID KEY. Ejecuta las instrucciones expuestas aquí cuando la clave no es
válida.
WRITE.
WRITE registro FROM variable
NOT INVALID KEY instrucciones
END-WRITE
 INVALID KEY. Ocurre cuando se produce un error al grabar el registro en el
fichero.
 NOT INVALID KEY. Realiza las instrucciones que aquí se exponen cuando no
ocurre error alguno al grabar los datos en el archivo.
REWRITE.
REWRITE registro FROM variable
END-REWRITE
fichero.
ocurre error alguno al grabar los datos en el archivo.
DELETE.
DELETE nombreinternodelfichero
END-DELETE
fichero.
ocurre error alguno al grabar los datos en el archivo. Hay que tener en cuenta
que para usar esta instrucción hay que hacer un READ antes, como ocurre con
la START.
START.
Esta instrucción es esencial en el uso de ficheros indexados con acceso dinámico
cuando queremos hacer lecturas secuenciales. Vamos a imaginar un archivo con
20.000 registros y sólo queremos visualizar a partir del registro 8000. Si lo hiciéramos
de la forma que sabemos hasta ahora, pasaríamos por los 7999 registros que se
encuentran antes y sería un poco engorroso y lento. Para esto sirve la START, se
posiciona en el registro que queramos sin pasar por los anteriores para hacer una
lectura más rápida. Vamos a ver cómo funciona:

START nombreinternodelfichero KEY (expresión) nombredelaclave
END-START
Expresión. Esto se refiere a las comparaciones lógicas de campos claves que
vayamos a usar en la consulta:
 IS EQUAL TO. Igual a…
 IS =. Igual a..
 IS GREATER THAN. Mayor que.
 IS > Mayor que.
 IS NOT LESS THAN. No es menor que.
 IS NOT < No es menor que.
Cuando utilizamos esta sentencia, éste no lee, sólo coloca el “cursor” en el registro
que le indicamos. Después toca leer el fichero con la instrucción READ.

TP 330 2020-1

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

TP 330 2020-1

Cargado por

Copyright:

Formatos disponibles

330 TP Lapso 2020-1 1/7

UNIVERSIDAD NACIONAL ABIERTA

ASIGNATURA: PROCESAMIENTO DE DATOS

FECHA DE ENTREGA AL ESTUDIANTE: 20/07/2020

FECHA DE DEVOLUCIÓN POR PARTE DEL ESTUDIANTE:

El trabajo debe ser enviado al correo electrónico del asesor académico de la

NOMBRE DEL ESTUDIANTE: Juan Miguel Briceño Paredes

CÉDULA DE IDENTIDAD: V-27.587.375

CORREO ELECTRÓNICO DEL ESTUDIANTE: bricenojuan09@gmail.com

CENTRO LOCAL: Mérida

CARRERA: INGENIERÍA DE SISTEMAS

LAPSO ACADÉMICO: 2020-1

Especialista: Nilda Altuna I Ing. de Sistem

Mérida, octubre de 2020

3.1. DEFINICIÓN CONTEXTUAL..................................................................................................4

Estructura del programa.....................................................................................................................7

Este trabajo práctico se enfoca en la ejecución de un software empleando el

El lenguaje COBOL se desarrolló con el objetivo principal de conseguir un

El lenguaje de programación COBOL surgió de la necesidad de crear un lenguaje

Los profesionales de la industria que demandaban algo así, se vieron satisfechos

Por lo tanto, se desarrolló para aplicaciones de carácter comercial, datos y

3.1. DEFINICIÓN CONTEXTUAL

Es un lenguaje de programación de alto nivel desarrollado por primera vez por el

COBOL es un acrónimo que significa Common Business Oriented Language

Durante más de cuatro décadas COBOL ha sido el lenguaje de programación

4. DESARROLLO TEÓ RICO

Un programa es un conjunto de instrucciones escritas en un lenguaje que el

ordenador pueda entender.

altere el orden de ejecución.

Queremos escribir un programa que acepte dos números desde el teclado,

multiplicarlos y mostrar el resultado en la pantalla del ordenador.

Cuando se nos plantea un problema debemos estudiar un poco e identificar los

 ¿Cuál es el proceso? Multiplicar Num1 por Num2.

 ¿Qué hacemos con la información que obtenemos? Vamos amostrarlo en

Los datos conocidos que necesitamos en un proceso, se almacenan en un

Normas de Codificación. Un programa en Cobol se escribe secuencialmente

La parte (1) comprende las columnas de la 1 a la 6 ambas inclusive y se utiliza

La parte (2) comprende la columna 7 y en ella podemos encontrar, un guión (-)

La parte (3) se le llama Área A comprende las columnas 8 a 11 ambas inclusive y

La parte (4) llamada Área B comprende desde la columna 12 a la 72 y en ellas se

La parte (5) de la columna 73 a la 80 no se utiliza y por lo tanto es ignorada por el

Todos los nombres definidos por el usuario, como variables, nombres de

 Deben contener al menos un carácter, pero no más de 30 caracteres.

 Deben contener al menos un carácter alfabético.

 No debe comenzar ni terminar con un guión.

 Deben construirse a partir de los caracteres de la A a la Z, números del 0 al 9 y

 No deben contener espacios y no se distinguen entre mayúsculas y

Estructura del programa

La jerarquía de un programa en COBOL se compone de cuatro divisiones principales:

 IDENTIFICATION DIVISION. Consta de la información del programa.

 ENVIRONMENT DIVISION. Consta de la información del entorno.

 DATA DIVISION. Consta de las descripciones de los datos.

 PROCEDURE DIVISION. Consta de todo el algoritmo del programa.

IDENTIFICATION DIVISION. Esto es un ejemplo de la típica información que se

Se utiliza para describir el ambiente en el que se ejecutará el programa, detalles

Es aquí donde el programador escribe el código o algoritmo del programa para su

ser objeto de repetición. A estos procesos se les llama bucles o estructuras

realizar cálculos matemáticos. Como es lógico, no vamos a escribir 10 veces el

a nivel de programación el proceso lo hemos definido una sola vez.

En esta parte vamos a aprender cómo se crean bucles o instrucciones repetitivas y

párrafos o rutinas para controlar el orden de ejecución del programa.

Párrafos o Rutinas. Siempre que se ejecuta un programa en COBOL, se hace de

Si observamos detenidamente este ejemplo, lo que hacemos es el párrafo Inicio,

dentro de este llamamos a la Rutina 2, dentro de éste llamamos a la Rutina 1 y por