✒️ABAP / Las subrutinas Por Fabian Geldres Del Carpio

Sub rutinas

Son secciones de codigos que pueden ser utilizadas mas de una vez. La idea de pasar el codigo del programa a sub rutina es para que estos sean mas faciles de leer y entender.
MODULARIZAR se llama asi a la accion de pasar el codigo de un programa a subrutinas, para mejorar la lectura y manteniemiento del mismo. lo ideal es que la subrutina no pase de las 50 lineas de codigo. por ejemplo al debuguear solo me preocupo por el resultado de la sub rutina y no entro en detalle en su desarrollo.

PERFORM selecciono_datos.

Si damos doble click, crearemos la sub rutina , Le daremos que si y posterior a esto nos preguntara donde queremos guardar la subrutina : Include de datos (Objetos abap que se crean para agrupar todas las declaraciones de datos que se utilizan en el programa) o programa de control. Para este caso lo crearemos en Programa de control.

Se creara lo siguiente(Se crea dentro del codigo abap.) :

*&---------------------------------------------------------------------*
*& Form SUB_LISTAR_USUARIOS_XT66M
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM SUB_LISTAR_USUARIOS_XT66M .

ENDFORM.

!!El nombre de la subrutina debe de ser lo mas representativo posible del resultado que producto, el nombre no puede pasar de los 30 caracteres.

Tipos de subrutinas.

Internas . cuando esta dentro del mismo programa que lo llama
Externas . cuando esta en un porgrama distinto, como puede ser el caso de Include de subrutinas o otro programa
Sub Rutinas internas.

Se crea dentro del programa FORM-ENDFORM en donde especificaremos nuestra sub rutina.
A los parametros definidos en el programa principal, a la derecha del PERFORM se los llama PARAMETROS ACTUALES
A los parametros definidos en la sub rutina , a la derecha de FORM se llama PARAMETROS FORMALES

Pueden ser de 3 tipos
De entrada : se utilizan para pasar datos del programa principal a la subrutina
De salida : Se utilizan para pasar datos de la subrutina al programa principal
De entrada y Salida : Cuando se utiliza para pasar datos de la subrutina al programa principal y tambien en viceversa.
Paso de Parametros a subrutinas.

Se utilzan USING,CHANGING y TABLES estas se escriben en el siguiente orden.

PERFORM subrutina TABLES <tabla de salida>
USING <Parametro de entrada>
CHANGING <Parametro de salida>


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 se pasan los parametros estos deben respetar el orden en el que fueron declarados en el FORM

Formas de enviar parametros
Paso por valor .- durante la llamada a la subrutina , los parametros formales son creados como copias de los paramentros actuales . Los cambios en los Parametros formales no afecta a los parametros actuales

************************************************************************
*** 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

Salida es B

Paso por referencia durante la llamada a la subrutina , solo de direccion de los parametros actuales se transfieren a los parametros formales . dentro de la rutina , 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_REFERENCIA


Resultado A B , X X

Paso por valor y resultado derante la llamada a la subrutina , los parametros formales son creados 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_resultado1 USING v_h2
CHANGING v_h1.



************************************************************************
END-OF-SELECTION.
************************************************************************
WRITE:/'H1 es:', v_h1.


*&---------------------------------------------------------------------*
*& Form PASO_POR_VALOR_Y_RESULTADO1
*&---------------------------------------------------------------------*
FORM paso_por_valor_y_resultado1 USING value(p_f2)
CHANGING value(p_f1).

p_f1 = p_f2.

ENDFORM. " PASO_POR_VALOR_Y_RESULTADO1

salida ES H1 es:B

Sub Rutinas Externas

podemos llamar de las siguientes maneras.

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

O

INCLUDE <report>