✒️ABAP / Las subrutinas Por Vismark Sevillano Moreno

Subrutinas - ¿Qué son las subrutinas?

SUBRUTINAS

Las subrutinas son secciones de código que pueden ser utilizadas más de una vez.

La idea de pasar el código de los programas a subrutinas, es para que los programas sean más fáciles de mantener.

EN LA PRÁCTICA: MODULARIZAR

Se llama así a la acción de pasar el código de un programa a subrutinas, para mejorar la lectura y mantenimiento del mismo. Lo ideal es que una subrutina no tenga más de 50 líneas de código.

La modularización ayuda a encontrar más fácilmente los errores en los programas. Esto se debe a que al debaguear un programa solo me preocupo que el resultado de una subrutina sea el esperado sin entrar en detalle de como se llega a ese resultado.

Una subrutina se declara con la palabra reservada PERFORM seguida del nombre de la subrutina. Veamos un ejemplo:

* Selecciono datos de tabla de usuarios

PERFORM selecciono_datos.

Aquí creamos una subrutina para modularizar la selección de los datos. Si hacemos doble clic en el nombre de la subrutina, el sistema nos propondrá crear la subrutina en la siguiente ventana de diálogo:

Crear objeto

Subrutina selecciono_datos no existe.

¿Desea crear el objeto?

SI NO CANCELAR

Contestaremos que sí y el sistema nos preguntará donde queremos generar la subrutina, las opciones son: crear un nuevo include de datos o crearlas en el mismo programa de control. En este caso, las crearemos en el programa de control. Luego el sistema generará el siguiente bloque de código en nuestro programa para que lo completemos con el código que corresponda:

IMPORTANTE: Es importante que el nombre que se le asigne a una subrutina sea lo más representativo posible del resultado que produce la subrutina. La longitud del nombre no puede exceder los 30 caracteres.

Tipos de subrutinas

Existen dos tipos de subrutinas:

- Internas: cuando la subrutina está dentro del mismo programa que la llama.

- Externas: cuando la subrutina está en un programa distinto al que las llama. Como puede ser el caso de un include de subrutinas u otro programa.

Subrutinas internas

Como vimos en el ejemplo del punto 1, para crear una subrutina interna usamos la palabra clave PERFORM seguida del nombre de la subrutina. Esto crea un bloque FORM-ENDFORM donde colocamos nuestro código.

Se pueden pasar datos entre los programas principales y una subrutina a través de parámetros. A los parámetros definidos en el programa principal, a la derecha de la palabra PERFORM se los llama parámetros actuales.

A los parámetros definidos en la subrutina, a la derecha de la palabra FORM, se los llama parámetros formales.

Los parámetros pueden ser de tres tipos:

• De entrada: cuando se utilizan para pasar datos del programa principal a la subrutina.
• De salida: cuando se utilizan para pasar datos de la subrutina al programa principal.
• De entrada y salida: cuando se utilizan para pasar datos de la subrutina al programa principal y también viceversa.

Paso de parámetros a subrutinas

Para pasar los parámetros utilizaremos tres opciones: USING, CHANGING y TABLES. Estas opciones se deben escribir en el orden que mostramos a continuación en el siguiente gráfico:

PERFORM subrutina TABLES <tabla de salida>

USING <parámetro de entrada>

CHANGING <parámetro de salida>

En el bloque FORM-ENDFORM debemos especificar el tipo de los parámetros formales. De esta forma nos aseguramos que solo se pasen parámetros del tipo que corresponde a la subrutina. Veamos un ejemplo donde pasamos una tabla interna, una estructura y una variable de tipo carácter.

DATA: ti_vuelos LIKE STANDARD TABLE OF sflight,

st_vuelos LIKE LINE OF ti_vuelos,

v_flag TYPE sy-subrc.

* Procesar los datos de entrada

PERFORM procesar_datos TABLES ti_vuelos

USING st_vuelos

CHANGING v_flag.

*&---------------------------------------------------------------------*

*& Form procesar_datos

*&---------------------------------------------------------------------*

* text

*----------------------------------------------------------------------*

FORM procesar_datos TABLES t_vuelos STRUCTURE sflight

USING st_vuelos STRUCTURE sflight

CHANGING p_flag TYPE sy-subrc.

ENDFORM. "procesar_datos

RECUERDA: Cuando una subrutina es llamada, los parámetros deben ser pasados en el mismo orden en el que fueron declarados, por lo tanto, se debe respetar esta misma secuencia en el bloque FORM-ENDFORM.

Existen tres formas de pasar parámetros:

• Paso por valor: durante la llamada a la subrutina, los parámetros formales son creados como copias de los parámetros actuales. Los cambios en los parámetros formales no afectan a los parámetros actuales. Veamos un ejemplo:

************************************************************************

*** Paso de parametros por valor ***************************************

************************************************************************

DATA: v_f1(1) TYPE c VALUE 'B'.

PERFORM paso_por_valor USING v_f1.

WRITE v_f1.

*&---------------------------------------------------------------------*

*& Form PASO_POR_VALOR

*&---------------------------------------------------------------------*

FORM paso_por_valor USING value(pf1).

pf1 = 'X'.

ENDFORM. " PASO_POR_VALOR

Y la salida será B.

AUDIO TIPS 1: Como vemos en la imagen anterior, el nombre del parámetro actual v_f1, es decir, el que se especifica a la derecha de la palabra reservada PERFORM es diferente al nombre del parámetro formal pf1, es decir, el que se especifica a la derecha de la palabra reservada FORM en la declaración de la subrutina paso_por_valor. Basta con que ambos parámetros se encuentren en el mismo orden y su tipo sea el mismo para que ABAP los interprete correctamente. Para pasar parámetros por valor, utilizamos en la declaración de las subrutinas la palabra reservada VALUE y encerramos al parámetro entre paréntesis. Cuando se pasan parámetros por valor debemos tener bien en claro que las modificaciones que se realicen al parámetro dentro de la subrutina no tendrán efecto alguno fuera de la subrutina en el programa principal. Ahora bien, expliquemos porqué la salida por pantalla es B. Al momento de declarar en el programa principal la variable v_f1, le asignamos el valor B. Luego ejecutamos la subrutina paso por valor pasando a la variable v_f1 como parámetro por valor. Dentro de la subrutina paso por valor vemos que el nombre del parámetro cambia y que se le asigna al mismo una x. Tal como mencionamos anteriormente debido al paso por valor a la salida de la subrutina el parámetro v_f1 vuelve a tener el mismo valor que tenía antes de ingresar a la misma es decir B. Finalmente la impresión del contenido de la variable en pantalla será B.

• Paso por referencia: durante la llamada a la subrutina, solo la dirección de los parámetros actuales se transfieren a los parámetros formales. Dentro de la subrutina, se trabaja con el campo del programa que hace la llamada.

Si cambiamos los parámetros formales, el contenido del campo del programa que hace la llamada también cambia.

*************************************************************************

**** Paso de parametros por referencia **********************************

*************************************************************************

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

*&---------------------------------------------------------------------*

FORM paso_por_referencia USING p_g1

CHANGING p_g2.

p_g1 = p_g2 = 'X'.

ENDFORM. " PASO_POR_REFERENCIA

Y la salida será A B y X X.

AUDIO TIPS 2: Como vemos en la imagen anterior los nombres de los parámetros actuales v_g1 y v_g2, es decir, los que se especifican a la derecha de la palabra reservada PERFORM, son diferentes a los nombres de los parámetros formales p_g1 y p_g2, es decir, los que se especifican a la derecha de la palabra reservada FORM en la declaración de la subrutina paso_por_referencia. Basta con que los parámetros se encuentren en el mismo orden y su tipo sea el mismo para que ABAP los interprete correctamente. Cuando se pasan parámetros por referencia debemos tener bien claro que las modificaciones que se realicen al parámetro dentro de la subrutina si tendrán efecto fuera de la subrutina en el programa principal. Ahora bien, expliquemos porqué la salida por pantalla es A B X X. Al momento de declarar en el programa principal las variables v_g1 y v_g2 les asignamos los valores A y B. Luego imprimimos en pantalla las variables por lo que la salida en pantalla es AB. A continuación ejecutamos la subrutina paso_por_referencia pasando ambas variables como parámetros por referencia. Dentro de las subrutina vemos que los nombres de los parámetros cambian por p_g1 y p_g2 y que ambos parámetros se les asigna una X. A la salida de la ejecución de la subrutina en el programa principal, los parámetros conservan, el valor asignado a la subrutina debido al paso por referencia, es decir, X. Finalmente la impresión del contenido de las variables en pantalla será X X.

• Paso por valor y resultado: durante la llamada a la subrutina, los parámetros formales son creados como copias de los parámetros actuales. Los cambios

en los parámetros formales son copiados a los parámetros actuales al final de la subrutina.

************************************************************************

*** Paso de parametros por valor y resultado ***************************

************************************************************************

DATA: v_h1(1) TYPE c VALUE 'A',

v_h2(1) TYPE c VALUE 'B'.

PERFORM paso_por_valor_y_resultado1 USING v_h2

CHANGING v_h1.

WRITE:/'H1 es:', v_h1.

*&---------------------------------------------------------------------*

*& Form PASO_POR_VALOR_Y_RESULTADO

*&---------------------------------------------------------------------*

FORM paso_por_valor_y_resultado USING value(p_f2)

CHANGING value(p_f1).

p_f1 = p_f2.

ENDFORM. " PASO_POR_VALOR_Y_RESULTADO

Y la salida será H1 es: B.

Subrutinas externas

Si quisiéramos llamar a una subrutina que está en un programa distinto al que estamos procesando, debemos utilizar la siguiente sintaxis:

PERFORM<sub>(<programa>)USING ...

También podemos agregar includes de subrutinas a nuestro programa de la siguiente manera:

INCLUDE<report>.