✒️ABAP / Las subrutinas Por Diamela Serignese

¿Qué son las subrutinas?

Son secciones de código que pueden ser usadas mas de una vez.

La idea de pasar el codigo de los programas a subrutinas es para que los programas sean más faciles de leer y mantener.

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 la subrutina no tenga más de 50 líneas de código.

La modularización ayuda a encontrar de forma mas facil los errores en los programas, ya que al debuggear un programa solo nos preaocupamos de 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. Ejemplo:

* Selecciono los datos de la tabla de usuarios

PERFORM selecciono_datos.

En este ejemplo creamos una subrutina para modularizar la seleccion de los datos. Si hacemos doble clic en el nombre de la subrutina, el sistema nos propondrá crear la subrutina a traves de una ventana de diálogo, contestamos que sí y el sistema nos preguntará donde queremos generar la subrutina, las opciones son:

-Crear un nuevo include de datos

-Crearlas en el mismo programa de control

En el ejemplo las creamos 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:

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

*& Form selecciono_datos

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

* text

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

* --> p1 text

* <-- p2 text

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

form selecciono_datos.

endform. " selecciono_datos

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

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.

Podemos pasar datos entre los programas principales y una subrutina usando parámetros:

-Parametros actuales: son los parametros definidos en el programa principal a la derecha de la palabra PERFORM.

-Parametros formales: son los parametros definidos a la derecha de la palabra FORM.

Los parametros pueden ser de tres tipos:

-De entrada: cuando se usan para pasar datos del programa principal a la subrutina

-De salida: cuando se usan para pasar datos de la subrutina al programa principal

-De entrada y salida: cuando se usan para pasar datos de la subrutina al programa principal y viceversa.

Paso de parametros a subrutinas

Usamos tres opciones:

USING

CHANGING

TABLES

Estas opciones debemos escribirlas en el siguiente orden:

PERFORM subrutina TABLES <tabla de salida>

USING <parametro de entrada>

CHANGING <parametro de salida>.

En el bloque FORM-ENDFORM debemos especificar el tipo de los parametros formales. De este modo nos aseguramos de que solo pasen parametros del tipo que corresponde a la subrutina. Ejemplo: pasamos una tabla interna, una estructura y una variable de tipo caracter:

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

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 parametros formales son creados como copias de los parametros actuales. Los cambios en los parametros formales no afectan a los parametros actuales. 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.

El nombre del parámetro v_f1 , es decir, el que se especifica a la derecha de la palabra reservada PERFORM es diferente al nombre del parametro 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 parametros se encuentren en el mismo orden y su tipo sea el mismo para que ABAP los interprete correctamente.

Para pasar parametros por valor usamos en la declaracion de la subrutina la palabra reservada VALUE y encerramos al parametro entre parentesis. Cuando se pasan parametros por valor debemos tener bien claro que las modificaciones que se realicen en el parametro dentro de la subrutina no tendran efecto alguno fuera de la subrutina en el programa principal.

¿Por que 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 parametro por valor. Dentro de la subrutina paso_por_valor vemos que el nombre del parametro cambia y que se le asigna una X, tal como mencionamos antes debido al paso por valor a la salida de la subrutina el parametro v_f1 vuelve a tener el mismo valor que tenia antes de ingresar a la misma (B). Finalmente el valor que se imprime en pantalla será B.

-Paso por referencia: durante la llamada a la subrutina, solo la direccion de los parametros actuales se transfieren a los parametros formales. Dentro de la subrutina se trabaja con el campo del programa que hace la llamada.

Si cambiamos los parametros formales el contenido del campo del programa que hace la llamada tambien 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_VALOR

Y la salida será A B y X X.

En este ejemplo los nombres de los parametros 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 parametros formales p_g1 y p_g2, es decir los que se especifican a la derecha de la palabra reservada FORM en la declaracion de la subrutina PASO_POR_REFERENCIA.

Basta con que los parametros se encuentren en el mismo orden y su tipo sea el mismo para que ABAP los interprete correctamente.

Cuando se pasan parametros por referencia debemos tener bien claro que las modificaciones que se realicen al parametro dentro de la subrutina sí tendran efecto fuera de la subrutina en el programa principal.

¿Por qué la salida por pantalla es A B y 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 A B.

Luego ejecutamos la subrutina PASO_POR_REFERENCIA pasando ambas variables como parametros por referencia, dentro de la subrutina vemos que los nombres de los parametros cambian por p_g1 y p_g2 y que a ambos parametros se les asigna una X. A la salida de la ejecucion de la subrutina en el programa principal los parametros conservan el valor asignado a la subrutina debido al paso por referencia, es decir X, finalmente el resultado en pantalla será X X.

-Paso por valor y resultado: durante la llamada a la subrutina los parametros formales se crean como copias de los parametros actuales. Los cambios en los parametros formales son copiados a los parametros 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_resultado 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 quisieramos llamar a una subrutina que está en un programa distinto al que estamos procesando debemos usar la siguiente sintaxis:

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

Tambien podemos agregar includes de subrutinas a nuestro programa de la siguiente manera:

INCLUDE <report>.

Agradecimiento:

Ha agradecido este aporte: William Lemus