Unidad n°4: Las subrutinas, los módulos de funciones y el procesamiento batch
Lección n°1: Las subrutinas
Las subrutinas son selecciones de código que pueden usarse más de una vez dentro del mismo programa y también pueden usarse por otros programas que las referencien.
La idea de pasar el código de los programas a subrutinas, es para que los programas sean más fáciles de leer y de mantener.
La modularización ayuda a encontrar fácilmente los errores en los programas, gracias a que al debaguear un programa solo nos preocupamos que el resultado de una subrutina sea el esperado sin entrar en detalle de cómo se llega a ese resultado.
*Modularizar: acción de pasar el código de un programa a subrutinas, para mejor lectura y mantenimiento. La idea de la subrutina es que no tenga más de 50 líneas.
Las subrutinas se declaran con la palabra reservada PERFORM seguida del nombre de la subrutia:
PERFORM seleccionar_datos.
Acá creamos una subrutina para modularizar la selección de los datos:
Hacemos doble clic en el nombre de esta y el sistema nos preguntará si queremos crear el objeto.
Le damos al si y debemos elegir donde queremos crear la definición de la subrutina, las opciones son:
Crear un nuevo include.
Crearlas en el mismo programa de control.
Elegimos la 2da.
El sistema generará un bloque de código en el programa para que lo completemos con el código correspondiente:
*&------------------------------------------------------------------------------------*
*& Form SELECCIONAR_DATOS
*&------------------------------------------------------------------------------------*
* text Reservado para escribir que hace la subrutina
*--------------------------------------------------------------------------------------*
* --> p1 text Reservado para escribir los parámetros de entrada y salida
* <-- p2 text
*--------------------------------------------------------------------------------------*
FORM seleccionar_datos.
ENDFORM "SELECCIONAR_DATOS
Dentro de la plantilla de comentarios creada cuando se genera la subrutina, podemos especificar el objetivo de esta y más abajo podemos detallar su parám de ent. y sal. junto con una descr. de cada uno.
EJ: para la subrutina "SELECCIOANR_DATOS" podemos escribir "Seleccionamos los datos de la taba de usuarios ZTABLA_USUARIOS" y especificaremos el param. de salida P_TI_USUARIOS que será la ti que contendrá los registros de la tbd de usuarios ZTABLA_USUARIOS:
*&------------------------------------------------------------------------------------*
*& Form SELECCIONAR_DATOS
*&------------------------------------------------------------------------------------*
* Seleccionamos los datos de la tabla de usuarios ZTABLA_USUARIOS
*--------------------------------------------------------------------------------------*
* --> p_ti_usuarios tabla interna de usuarios
*--------------------------------------------------------------------------------------*
FORM seleccionar_datos.
ENDFORM "SELECCIONAR_DATOS
Tipos de subrutina:
- Internas: cuando se encuentra dentro del programa que la llama o en un include de subrutinas, declarado en el programa de control. Este sería el caso de la subru. SELECCIONAR_DATOS (ver ejemplo).
- Externas: cuando se encuentra en un programa distinto al que la llama. Para llamar una subru. externa desde otro programa usaremos la sentencia PERFORM:
PERFORM <nombre_subrutina> IN PROGRAM <nombre_programa_subrutina>.
EJ con la subru. SELECCIONAR_DATOS desde otro programa:
*&------------------------------------------------------------------------------------*
*& Report ZTEST_SUBRUTINAS_2
*&------------------------------------------------------------------------------------*
*&
*&------------------------------------------------------------------------------------*
REPORT ztest_subrutinas_2.
START-OF-SELECTION.
PERFORM seleccionar_datos IN PROGRAM ztest_subrutinas.
El paso de parámetros a subrutinas:
Se pueden pasar datos entre el programa principal y una subrutina por medio de parámetros.
Estos pueden ser de tres tipos:
De entrada: cuando se usa para pasar datos del programa principal a la subrutina.
De salida: cuando se usa para pasar datos de la subrutina al programa principal.
De ent. y sal.: cuando se usa para pasar datos de la subrutina al programa principal y viceversa.
Para pasar parám. en las subru. usaremos tres palabras reservadas:
USING: para declarar los parám. de ent. que serán usados en la subru.
CHANGING: para declarar parám. de ent/sal. que serán usados en la subru.
TABLES: para declarar parám. de ent/sal. que son tablas, que serán usadas en la subru.
Estas palabras deben ser escritas en el siguiente orden:
PERFORM <nombre_subrutina> TABLES <tabla_interna>
USING <parametro_de_entrada>
CHANGING <parametro_de_entrada_y_salida>.
Los parám. definidos dentro del programa inicial, el la declaración de la subru., a la derecha de la palabra PERFORM son llamados "parámetros actuales".
En el ej, V_HAY_DATOS es un param. actual:
...
"Seleccionamos los datos de la tabla de usuarios
PERFORM seleccionar_datos CHANGIN v_hay_datos
...
Los param. que se especifican en la def. de la subru, a la derecha de la palabra FORM, son llamados "parámetros formales".
Ej de que P_HAY_DATOS es un param. formal:
...
FORM seleccionar_datos CHANGING p_hay_datos.
ENDFORM.
...
En el bloque FORM-ENDFORM hay que especificar el tipo de los param. formales, para asegurarnos de que solo se pasen los param. del tipo correspondiente a la subru.
EJ: pasamos una ti, una estructura y una variable tipo carácter:
...
PERFORM procesar_datos TABLES ti_usuarios
USING wa_usuarios (Param. actuales)
CHANGING v_flag.
...
FORM procesar_datos TABLES ti_usuarios STRUCTURE ztabla_usuarios
USING wa_usuarios STRUCTURE ztabla_usuarios (Param. actuales formales)
CHANGING v_flag TYPE sy-subrc.
ENDFORM. "procesar_datos
Cuando una subru. es llamada, los param. deben ser pasados en el mismo orden en el que fueron declarados.
Tres formas de pasar parámetros:
- Paso por valor: durante la llamada a la subru, los param. formales son creados como copias de los param actuales. Los cambios en los param. formales no afectan a los actuales:
DATA: v_f1(1) TYPE c VALUE 'B'.
PERFORM paso_por_valor USING v_f1.
WRITE v_f1.
FORM paso_por_valor USING value (pf1).
pf1 = 'x'.
ENDFORM.
La salida por pantalla luego de ejecutar, será "B".
- Paso por referencia: durante la llamada a la subru. solo la dirección de los param. actuales se transfieren a los param. formales. Dentro de la subru. se trabaja con el campo del programa que hace la llamada.
Si cambiamos los param. formales, el contenido del campo del programa que hace la llamada también cambia.
DATA: v_g1(1) TYPE c VALUE 'A',
v_g2(1) TYPE c VALUE 'B'.
WRITE:/ v_g1, v_g2.
PERFORM paso_por_referencia USING v_g1
CHANGING v_g2.
WRITE:/ v_g1, v_g2-
FORM paso_por_referencia USING v_g1
CHANGING v_g2.
p_g1 = p_g2 = 'x'.
ENDFORM,
La salida por pantalla será "A", "B" y "X X"
- Paso por valor y resultado: durante la llamada a la subru. los param. formales son creados como copia de los actuales. Los cambios en los param. formales son copias de los actuales al final de la subru.
DATA: v_h1(1) TYPE c VALUE 'A',
v_h2(1) TYPE c VALUE 'B'.
PERFORM paso_por_valor_y_resultado USING v_h2
CHANGING v_h1.
WRITE:/ 'H1 es: ', v_h1.
FORM paso_por_valor_y_resultado USING value(p_f2)
CHANGING value(p_f1).
p_f1 = p_f2
ENDFORM
En la salida por pantalla veremos "H1 es: B"
Las declaraciones de los datos globales y locales:
Cuando declaramos datos en un programa (variables, estructuras, ti, etc) podemos hacerlo globalmente o localmente.
Hasta ahora cuando declaramos datos en los programas hacemos las declaraciones luego de la ejecución de REPORT y antes de la declaración del evento START-OF-SELECTION.
Las declaraciones hechas dentro de este lugar son "declaraciones globales", lo que significa que estas declaraciones pueden usarse en cualquier lugar del programa, es decir, pueden usarse en el programa principal como en cualquier subru.
La ventaja es que facilita el armado del programa debido a que no tenemos que estar pensando en donde particularmente a ser usada una declaración de datos, si no que la declaramos y la usamos donde corresponda.
La desventaja es que al realizar todas las declaraciones de datos en forma global no estamos generando un código eficiente en cuanto a la modularización, lo cual en cierto punto puede complicar el mantenimiento.
También se pueden hacer las declaraciones locales, dentro de una subru. podríamos declarar exclusivamente los datos que usaremos, de modo de modularizar lo más posible el código y consumir menor cantidad de recursos del sist., evitando declarar globalmente datos que solo usaremos localmente.