✒️ABAP Las subrutinas

Qué son las subrutinas?

Sin secciones de código que pueden ser utilizadas más de una vez. La ide a del mismo es para que los programas sean más fáciles de leer y de mantener.

Modularizar

Es 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 te tenga más de 50 líneas de código. La modularizacion ayuda más fácil a encontrar errores en los programas. Esto se debe al aplicar el debbug a un solo programa me preocupo por el resultado de una subrutina sea el espero sin entrar en detalle de como se llego al resultado.

Una subrutina se declara con la palabra reservada PERFORM seguida del nombre de la subrutina.

*selecciono datos de tabla de usuarios.

PERFORM seleciono_datos.

Aquí creamos una subrutina para modularizar la selección de datos, nos aparece una ventana de dialogo donde nos dice desea crear objeto, ponemos que sí. Se crea un nuevo include de datos en el mismo programa de control. Luego el sistema generara un bloque de código en nuestro programa para que completemos.

from selecciono_datos.

endfrom.

Es importante que el nombre que se le asigne a la subrutina sea los más representativo posible del resultado que produce. Longitud del nombre no puede exceder los 30 caracteres.

Tipos de subrutinas

• Internas: cuando la subrutina esta dentro del mismo programa que la llama.
• Externas: cuando la subrutina está e un programa distinto al que llama. como puede ser el caso de un include de subrutinas o otro programa.

Subrutinas internas: el código se usa en bloque FORM-ENDFORM donde colocamos el código.se pueden pasar datos entre los programas principales y de una subrutina a travéz 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 FROM, se llama parámetro formales.

Pueden ser de tres tipos:

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

Paso de parámetros a subrutinas.

Utilizaremos tres opciónes: USING, CHANGING y TABLES.

PERFORM subrutina TABLES <tabla de salida>

USING <parámetro de entrada>

CHANGING <parámetro de salida>

En el bloque FORM-ENDFORM debemos espeficifar el tipo de los parámetros formales. De esta forma nos aseguramos que solo pasen los parámetros del tipo correspondiente a la subrutina. EJ: donde pasamos una tabla interna, una estructura y una variable de tipo carácter.

DATA: ti_vuelos LIKE STANDART TABLE OF sflight,

st_vuelos LIKE LIN 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.

-----------------------------------------------------------------------------------------

FROM procesar_datos TABLES t_vuelos STRUCTURE sflight

USING st_vuelos STRUCTURE sfligth

CHANGING p_flag TYPE sy-subrc.

ENDFORM.

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

Existen tres formas de pasar parámetros.

Paso por valor: durante la llama 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 al actual.

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

PERFORM paso_por_valos USING v_f1.

WRITE v_f1.

---------------------------------------------------------

FROM paso_por_valor USING value (pf1).

pf1 = 'X'.

ENDFORM.

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 a subrutina se trabaja con el campo del programa que hace la llamada. En este caso si cambiamos los parámetros formales, el contenido del campo del programa que hace la llamada también cambia.

DATA :v_g1(1) TYPE c VALVUE '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 p_g1

CHANGING p_pg2.

p_g1 = p_g2 = 'X'.

ENDFORM.

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 de los parámetros formales son copiados a los parámetros actuales al final de la subrutina.

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.

------------------------------------------------------------------------------------

FROM paso_por_valor_y_resultado USING value (p_f2)

CHANGING value (p_f1).

p_f1 = p_f2.

ENDFROM.

Subrutinas Externas

Si queremos llamar a una subrutina que está en un programa distinto al que estamos procesando, se útiliza:

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

También podemos agregar INCLUDES de subrutina a nuestro programa

INCLUDE<report>.