🚀PROMO #PLANCARRERA2024 - 🔥Bonificaciones, Precios Congelados y Cuotas

 X 

✒️ABAP Las subrutinas

ABAP Las subrutinas

ABAP Las subrutinas

Subrutinas:

Subrutinas – Son secciones de códigos que pueden ser utilizadas más de una vez.

Modularizar – Es la acción de pasar código de un programa a una subrutina, para mejorar la lectura y mantenimiento del mismo.

Notas:

1. Lo ideal es que una subrutina no tenga más de 50 lineas de código..

2. Una subrutina se declara con la palabra reservada PERFORM, Ej: PERFORM selecciono_datos.

3. Si hacemos doble clic en el nombre de la subrutina, el programa nos propondrá crear la subrutina.

4. Las opciones para crear subrutinas son: crear un nuevo include de datos o crearlas en el mismo programa de control.

5. El nombre de la subrutina debe ser lo más representativo posible del resultado que produce la subrutina.

6. La longitud del nombre de la subrutina no pude exceder los 30 caracteres.

7. Al crear la subrutina se crea el bloque FORM-ENDFORM donde colocaremos nuestro código de la subrutina.

Tipos de Subrutinas – Existen dos tipos:

1. INTERNAS: Cuando la subrutina está dentro del mismo programa que la llama.

2. EXTERNAS: Cuando la subrutina está en un programa distinto al que la llama. Como puede ser un include de programa u otro programa.

Parámetros: Son datos que se pasan de los programas principales y una subrutina.

Nota: A los definidos en el programa principal, a la derecha de la palabra PERFORM, se le llama Parámetros Actuales y a los definidos en la subrutina, a la derecha de la palabra FORM, se le llama Parámetros Formales.

Tipos de parámetros: Pueden ser de tres tipos.

1. De entrada: Cuando se utilizan para pasar datos del programa principal a la subrutina.

2. De salida: Cuando se utilizan para pasar datos de la subrutina al programa principal.

3. 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 – Utilizaremos tres opciones: TABLES, USING, y CHANGING.

PERFORM procesar_datos TABLES ti_vuelos USING st_vuelos CHANGING v_flag.

Existen tres formas de pasar parámetros:

1. Paso por valor: Durante la llamada a una subrutina, los parámetros formales son creados como copias de los parámetros actuales y los cambios en los parámetros formales no afectan a los 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 Nota: El Resultado sera B 2. Paso por referencia: Solo la dirección de los parámetros actuales a los parámetros formales. Si cambia el valor de los parámetros formales también cambiaran los actuales. ************************************************************************* **** 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 2. Paso por valor y resultado: Durante la llamada a una subrutina, los parámetros formales son creados como copias de los actuales y los cambios de 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. *&---------------------------------------------------------------------* *& 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 ************************************************************************ 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

SUBRUTINAS EXTERNAS: Para 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 a nuestro programa de la siguiente manera:

INCLUDE <report>.

pre { direction: ltr; color: #000000; orphans: 2; widows: 2; background: transparent } pre.western { font-family: "Liberation Mono", "Courier New", monospace; so-language: es-ES } pre.cjk { font-family: "Noto Sans Mono CJK SC", monospace; so-language: zh-CN } pre.ctl { font-family: "Liberation Mono", "Courier New", monospace; so-language: hi-IN } p { margin-bottom: 0.25cm; direction: ltr; color: #000000; line-height: 115%; orphans: 2; widows: 2; background: transparent } p.western { font-family: "Liberation Serif", "Times New Roman", serif; so-language: es-ES } p.cjk { font-family: "Noto Serif CJK SC"; so-language: zh-CN } p.ctl { font-family: "Lohit Devanagari"; so-language: hi-IN } a.sdfootnotesym-western { font-size: 10pt } a.sdfootnotesym-cjk { font-size: 10pt } a.sdendnotesym-western { font-size: 10pt } a.sdendnotesym-cjk { font-size: 10pt }


 

 

 


Sobre el autor

Publicación académica de José Valentín López Montilla, en su ámbito de estudios para la Carrera Consultor ABAP.

SAP Master

José Valentín López Montilla

Profesión: Ingeniero de Sistemas - Venezuela - Legajo: GT35M

✒️Autor de: 134 Publicaciones Académicas

🎓Egresado de los módulos:

Disponibilidad Laboral: FullTime

Presentación:

Ingeniero de sistemas y magister scientiarum en ingeniería de software, con más de 30 años de experiencia en el área de tecnología de información, objetivo principal consultor sap abap

Certificación Académica de José López

✒️+Comunidad Académica CVOSOFT

Continúe aprendiendo sobre el tema "Las subrutinas" de la mano de nuestros alumnos.

SAP Master

las Subrutinas ayudan a que los programas sean mas faciles de leer y mantener. lo ideal es que las subrutinas no tengan mas de 50 lineas de codigo. se declaran con la palabra reservada PERFORM seguida del nombre de la subrutina.

Acceder a esta publicación

Creado y Compartido por: Mauro Fanego / Disponibilidad Laboral: FullTime

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Master

la idea de usar subrutinas es usar el codigo mas de una vez. modularizar es una practica de programacion que facilita el mantenimiento, con las subrutinas nos permite hacer esto de manera eficiente. las subrutinas no deben tener mas de 50 lineas de codigo, se declara con PERFORM NOMBRE_SUBRUTINA. no es claro cuando por sintaxis ver cuando la referencia es por valor, por referencia y por valor y resultado.

Acceder a esta publicación

Creado y Compartido por: Edgar Arturo Moreno Tello

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Master

Al utilizar subrutinas en nuestro código mejoramos la lectura y mantenimiento de los programas, ya que las subrutinas son bloques de código que se pueden utilizar muchas veces. Se recomienda que las subrutinas tengan como máximo 50 líneas de código. Declarar una subrutina: PERFORM nombre_subrutina. El nombre de la subrutina no debe tener más de 30 caracteres. Tipos de subrutinas: internas (está dentro del programa que la llama) y externas (está en un programa distinto al que la llama). Para pasar datos entre los programas principales y subrutinas utilizaremos parámetros, que pueden ser: de entrada (se pasan datos del programa principal a la subrutina), de salida (se pasan datos...

Acceder a esta publicación

Creado y Compartido por: Mónica Robles

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Master

que son las subrutinas las subrutinas son secciones de codigo que pueden ser utilizadas mas de una vez modularizar se llama asi a la acccion de pasar el codigo de un programa a subrituinas para mejorar la lectura y mantenimiento del mismo. se utiliza la palabra reservada perform para declarar una subrutina seguida del nombre de la subrutina. tipos de subrutinas internas cuando la subrutina esta dentro del mismo programa que la llama. externa cuando la subrutina esta en un programa distinto al que las llama como puede ser el caso de un include en subrutinas o otro programa subrutinas internas esta se crea en un bloque FORM.ENDFORM donde colocamos nuestro codigo. los parametros peuden ser tres tipos de entrada cuando se utilizan para pasar datos...

Acceder a esta publicación

Creado y Compartido por: Oscar Sebastian Caicedo Carlier / Disponibilidad Laboral: PartTime + Carta Presentación

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Junior

Subrutinas: Son secciones específicas y completas de un código que podemos ejecutar de forma independiente y cuyo resultado se utiliza para ejecutar el programa principal. Esto se hace para tener un programa mas entendible y de fácil mantenimiento. Existen dos tipos de subrutinas las cuales pueden ser: Subrutinas Internas: cuando de ejecutan dentro del mismo programa, o Subrutinas externas: cuando se ejecutan en otro programa o en secciones include. Modularizar un programa es convertir parte de el programa en subrutinas, debiendo tener la precaución de no ocupar mas de 30 líneas de código en cada subrutina. Se genera una subrutina interna con la siguiente palabra reservada: PERFORM Con el siguiente...

Acceder a esta publicación

Creado y Compartido por: Jose Tomas Gonzalez Saez / Disponibilidad Laboral: FullTime + Carta Presentación

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP SemiSenior

Subrutinas: Las Sub-rutinas son secciones de código que pueden ser utilizadas más de una vez, se utiliza para tener programas de fácil lectura y mantenimiento por parte del programador. Moduladizar: Es la acción de pasar código de un programa a subrutinas, para lograr mejorar la lectura, el ideal es no sobrepasar las 50 lineas de códigos. La subrutina se declara con la palabra reservada PERFORM según el nombre de de la subrutina ejemplo: PERFORM selecciono_datos. El ideal es lograr un nombre representativo a lo que realiza la subrutina y que no sobrepase los 30 caracteres. Tipos de subrutinas Existen dos tipos: Internas: cuando se encuentra dentro del mismo programa que la llama. Externas: Cuando...

Acceder a esta publicación

Creado y Compartido por: Enrique Javier Machuca Silva / Disponibilidad Laboral: FullTime

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Master


Subrutinas. Son secciones de código que pueden ser reutilizados en distintas partes del del código. Una subrutina no debería tener más de 50 líneas de codigo. Las subrutinas se declaran así: PERFORM nombre_subrutina. Se recomienda que el nombre de la función sea lo más claro y resumido posible y que indique su finalidad. No pueden tener nombres más de 30 caracteres. Hay dos tipos de subrutinas o funciones: Internas y Externas. Cuando hablamos de modularizar, hablamos de dividir el código en funciones o subrutinas más pequeñas. Eso permitirá encontrar los errores más rápido y seremos más organizados. ...

Acceder a esta publicación

Creado y Compartido por: Wellington Pierre / Disponibilidad Laboral: PartTime + Carta Presentación

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Junior

Subrutinas: secciones de código que pueden ser usardos mas de una vez Modulos: es pasar el código de un programa a subrutinas, para mejorar la lectura y el mantenimiento del mismo. máximo 50 líneas. subrutina se declara con la palabra PERFORM seguida del nombre Tipos de Subrutinas Internas: Cuando esta dentro del programa Externas: Cuando la subrutina esta en un programa distinto al que las llama. Se pasan datos entre los programas principales y subrutinas a través de parámetros Parámetros de entrada: Se utiliza para pasar datos del programa principal a la subrutina. Parámetros de salida: Se utilizan para pasar datos de la subrutina al programa principal Entrada y Salida: Pasan datos...

Acceder a esta publicación

Creado y Compartido por: Leonardo Isaac Gutierrez Morales / Disponibilidad Laboral: FullTime + Carta Presentación

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Senior

Subrutinas: secciones de código que puede ser utilizadas más de una vez, lo ideal es que cada subrutina no tenga más de 50 líneas de código. Modularizar: pasar el código de un programa a subrutinas para mejorar la lectura y mantenimiento del mismo. PERFORM: para llamar a una subrutina. Consideraciones de las subrutinas. Utilizar nombres representativos. El nombre no puede exceder los 30 caracteres. Tipos de subrutinas: Internas: cuando la subrutina está dentro del mismo programa que la llama. Externas: cuando la subrutina está en un programa distinto, puede ser un include de subrutinas. Actuales: son los que se colocan a la derecha de la palabra PERFORM. Formales:...

Acceder a esta publicación

Creado y Compartido por: Wanderson Esaú López Peraza

*** CVOSOFT - Nuestros Alumnos - Nuestro Mayor Orgullo como Academia ***

SAP Master

UNIDAD 4: SUBRUTINAS FUNCIONES Y BATCH LECCION: SUBRUTINAS: - Son secciones de código que pueden ser utilizados mas de una vez. MODULARIZAR: - Es la acción de pasar porciones de código de un programa a subrutinas, para su mejor lectura y mantenimiento. Creación de subrutinas puede ser en un INCLUDE de datos o el programa control. Nombrarlo de acuerdo a lo que hará y este no debe tener longitud mas de 30 posiciones. TIPOS: Internas.- Dentro del programa Externas.- En un programa distinto del que se llama en un INCLUDE de subrutinas o en otro programa Existen 3 tipos de parámetros: De entrada De salida De entrada y salida Las opciones: Tables - Using - Changing. Cuando se hace una llamada...

Acceder a esta publicación

Creado y Compartido por: Hernan Cabezas

 


 

👌Genial!, estos fueron los últimos artículos sobre más de 79.000 publicaciones académicas abiertas, libres y gratuitas compartidas con la comunidad, para acceder a ellas le dejamos el enlace a CVOPEN ACADEMY.

Buscador de Publicaciones:

 


 

No sea Juan... Solo podrá llegar alto si realiza su formación con los mejores!