Introducción

Aplicación de técnicas y conceptos básicos

Trabajar con clases locales

Lectura de datos de la base de datos

Trabajar con objetos de datos estructurados

Trabajar con tablas internas complejas

Implementación de actualizaciones de base de datos mediante business objects

Descripción del modelo de programación de aplicaciones ABAP RESTful

Trabajar con tablas internas simples

Objectives

After completing this lesson, you will be able to:

Definir tablas internas simples.
Procesar datos utilizando tablas internas simples.

Definición de tablas internas simples

Tablas internas

Las tablas internas son objetos de datos variables en los que puede almacenar varios valores de tipo idéntico. Este tipo debe especificarse en la declaración y se denomina tipo de fila de la tabla interna.

Cada valor ocupa una fila de la tabla interna. El número de filas no está restringido. Teóricamente, puede almacenar cualquier número de valores en una tabla interna. Las limitaciones solo provienen de límites técnicos como la memoria disponible o la configuración del sistema.

El valor inicial de una tabla interna es una tabla vacía o, en otras palabras, una tabla con 0 líneas. Existen diferentes técnicas para rellenar una tabla interna. El ejemplo utiliza la sentencia APPEND para añadir una nueva fila al final de la tabla interna y rellenarla con un valor.

Tipos de tabla

El tipo de una tabla interna se llama tipo de tabla.

En el ejemplo anterior, utilizamos TYPE TABLE OF en la sentencia DATA directamente. El tipo de tabla se ha vinculado a la variable declarada.

Como alternativa, puede utilizar TYPE TABLE OF en una sentencia TYPES para definir un tipo de tabla con un nombre. A continuación, puede utilizar este tipo de tabla, por ejemplo, en una sentencia DATA. La visibilidad de estos tipos depende de la posición de la sentencia TYPES.

También existen tipos de tabla en el Dictionary ABAP. Estos tipos de tabla se actualizan con un editor dedicado. Se denominan tipos de tabla globales porque son visibles en cualquier lugar del sistema.

Procesamiento de datos con tablas internas simples

Vea este vídeo para saber cómo puede rellenar una tabla interna con la sentencia APPEND.

El valor inicial de una tabla interna es una tabla vacía, es decir, una tabla interna con cero filas.

Ya ha aprendido que con la sentencia CLEAR puede restablecer una variable ABAP a su valor inicial específico de tipo.

Cuando utiliza CLEAR para una tabla interna, elimina todo su contenido y fija el número de filas en cero.

Existen varias formas de recuperar datos de una tabla interna. Este ejemplo recupera el contenido de una fila individual utilizando una expresión de tabla interna. En la expresión de tabla, el nombre de la tabla interna va seguido inmediatamente de un par de corchetes. Una expresión de número entero dentro de los paréntesis especifica la posición de la fila que se leerá.

Nota:

La sintaxis correcta requiere al menos un espacio en blanco después del paréntesis de apertura y antes del paréntesis de cierre.

Lectura de una tabla interna en un loop

El siguiente vídeo ilustra cómo puede leer de una tabla interna en un loop.

Cuando implementa un loop sobre una tabla interna, puede utilizar una declaración en línea después de añadir INTO en lugar de declarar el área de trabajo explícitamente con una sentencia DATA.

Al hacerlo, no solo reduce la cantidad de código que debe escribir, sino que también se asegura de que el tipo de área de trabajo se ajuste al tipo de línea de la tabla interna, porque el tipo del objeto de datos declarado en línea se deriva del contexto, que, en este caso, es la tabla interna.

Pruébelo: tablas internas simples

Como en el primer ejercicio de este curso, cree una nueva clase global que implemente la interfaz IF_OO_ADT_CLASSRUN.

Copie el siguiente fragmento de código en la parte de implementación del método if_oo_adt_classrun~main( ):

Code Snippet

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879

* Declarations
**********************************************************************

    " Internal tables
    DATA numbers TYPE TABLE OF i.

    "Table type (local)
    TYPES tt_strings TYPE TABLE OF string.
    DATA texts1      TYPE tt_strings.

    " Table type (global)
    DATA texts2 TYPE string_table.

    " work areas
    DATA number TYPE i VALUE 1234.
    DATA text TYPE string.

* Example 1: APPEND
**********************************************************************

    APPEND 4711       TO numbers.
    APPEND number     TO numbers.
    APPEND 2 * number TO numbers.

    out->write(  `-----------------` ).
    out->write(  `Example 1: APPEND` ).
    out->write(  `-----------------` ).

    out->write( numbers ).

* Example 2: CLEAR
**********************************************************************

    CLEAR numbers.

    out->write(  `----------------` ).
    out->write(  `Example 2: CLEAR` ).
    out->write(  `----------------` ).

    out->write( numbers ).

* Example 3: table expression
**********************************************************************
    APPEND 4711       TO numbers.
    APPEND number     TO numbers.
    APPEND 2 * number TO numbers.

    out->write(  `---------------------------` ).
    out->write(  `Example 3: Table Expression` ).
    out->write(  `---------------------------` ).

    number = numbers[ 2 ] .

    out->write( |Content of row 2: { number }|    ).
    "Direct use of expression in string template
    out->write( |Content of row 1: { numbers[ 1 ]  }| ).

* Example 4: LOOP ... ENDLOOP
**********************************************************************
    out->write(  `---------------------------` ).
    out->write(  `Example 4: LOOP ... ENDLOOP` ).
    out->write(  `---------------------------` ).

    LOOP AT numbers INTO number.

      out->write( |Row: { sy-tabix } Content { number }| ).

    ENDLOOP.

* Example 5: Inline declaration in LOOP ... ENDLOOP
**********************************************************************
    out->write(  `-----------------------------` ).
    out->write(  `Example 5: Inline Declaration` ).
    out->write(  `-----------------------------` ).

    LOOP AT numbers INTO DATA(number_inline).
      out->write( |Row: { sy-tabix } Content { number_inline }| ).
    ENDLOOP.

Pulse CTRL + F3 para activar la clase y F9 para ejecutarla como una aplicación de consola.
Analice la salida de la consola. Juega con el código fuente para familiarizarte con los conceptos.

Trabajar con tablas internas simples

En este ejercicio, utilizará iteraciones y tablas internas simples para calcular y visualizar los números de Fibonacci.

Nota

Los números de Fibonacci son una secuencia de números en la que cada número es la suma de los dos precedentes. La secuencia empieza por 0 y 1, y cada número subsiguiente es la suma de los dos números anteriores. La secuencia tiene varias propiedades matemáticas, patrones y aplicaciones en campos como las matemáticas, la informática, la naturaleza y el arte.

Modelo:

ninguno

Solución:

/LRN/CL_S4D400_BTS_ITERATE (clase global)

Tarea 1: Calcular los números

En su propio paquete, cree una nueva clase global. Defina una constante para el número de iteraciones y una tabla interna para los números de Fibonacci. A continuación, calcule los números de Fibonacci en una iteración y almacénelos en la tabla interna.

Pasos

Cree una nueva clase global que implemente la interfaz IF_OO_ADT_CLASSRUN (nombre sugerido: ZCL_##_ITERATE, donde ## representa su número de grupo).
1. Seleccione Archivo→Nuevo→Clase ABAP.
2. Introduzca el nombre del paquete en el campo Paquete. En el campo Nombre, introduzca el nombre ZCL_##_ITERATE, donde ## representa su número de grupo.
3. Introduzca una descripción.
4. En el marco de grupo Interfaces, seleccione Añadir.
5. Introduzca IF_OO_ADT_CLASSRUN. Cuando la interfaz aparezca en la lista de aciertos, haga doble clic en ella para añadirla a la definición de clase.
6. Seleccione Siguiente.
7. Marque su orden de transporte y seleccione Finalizar.
En el método IF_OO_ADT_CLASSRUN~MAIN, defina una constante para el número de iteraciones (nombre sugerido: max_count) con un valor pequeño, por ejemplo 20.
1. Añada el código siguiente:
  Code Snippet
```
123

   CONSTANTS max_count TYPE i VALUE 20.
```
Declare una tabla interna simple para almacenar los números de Fibonacci (nombre sugerido: números).
1. Añada el código siguiente:
  Code Snippet
```
123

  DATA numbers TYPE TABLE OF i.
```
Implemente una iteración que se ejecute max_count veces.
1. Después de las declaraciones, añada el siguiente código:
  Code Snippet
```
12345

  DO max_count TIMES.

  ENDDO.
```
Dentro de la iteración, implemente una distinción CASE basada en el contador de iteración integrado: En la primera iteración, añada el valor 0 a los números de tabla internos. En la segunda iteración, añada el valor 1 al final de los números de tabla internos.
Consejo
El contador de iteración integrado es el campo de sistema sy-index.
1. Entre DO y ENDDO, añada el siguiente código:
  Code Snippet
```
12345678

   CASE sy-index.
      WHEN 1.
        APPEND 0 TO numbers.
      WHEN 2.
        APPEND 1 TO numbers.
   ENDCASE.
```
Añada una rama que se ejecute para todos los demás valores. En esta rama, calcule la nueva entrada como la suma de las dos entradas anteriores en números.
Consejo
Acceda a las entradas anteriores mediante el índice sy-index - 1 y sy-index - 2.
1. Ajuste el código de la siguiente manera:
  Code Snippet
```
123456789101112

   CASE sy-index.
      WHEN 1.
        APPEND 0 TO numbers.
      WHEN 2.
        APPEND 1 TO numbers.
      WHEN OTHERS.
          APPEND numbers[  sy-index - 2 ]
               + numbers[  sy-index - 1 ]
              TO numbers.
   ENDCASE.
```

Tarea 2: Preparar una salida formateada

En un loop sobre la tabla interna, prepare una salida formateada que enumere cada número de Fibonacci con su número secuencial respectivo. Prepare la salida en otra tabla interna del tipo de fila string.

Pasos

Al principio del método if_oo_adt_classrun~main, declare una tabla interna del tipo de fila string (nombre sugerido: salida).
Implemente un bucle sobre los números de la tabla interna para leer los números de Fibonacci uno por uno en un número variable.
Consejo
Utilice una declaración en línea para el número.
1. Al final del método, añada el siguiente código:
  Code Snippet
```
12345

  LOOP AT numbers INTO DATA(number).

  ENDLOOP.
```
Declare una variable entera (nombre sugerido: contador), que fija en cero antes del loop y aumenta en 1 en cada iteración.
Consejo
Puede utilizar una declaración en línea para el contador.
1. Ajuste el código de la siguiente manera:
  Code Snippet
```
12345678

  DATA(counter) = 0.
  LOOP AT numbers INTO DATA(number).

     counter = counter + 1.

  ENDLOOP.
```
En cada iteración, añada una nueva fila a la salida de tabla interna que contenga el contenido del contador (4 caracteres de ancho, alineado a la izquierda), dos puntos (:) y el contenido del número (10 caracteres de ancho, justificado a la derecha).
Consejo
Utilice un modelo de cadena con opciones de formato adecuadas para ajustar el formato.
1. Ajuste el código de la siguiente manera:
  Code Snippet
```
1234567891011

  DATA(counter) = 0.
  LOOP AT numbers INTO DATA(number).

     counter = counter + 1.

     APPEND |{ counter WIDTH = 4 ALIGN = LEFT }: { number WIDTH = 10 ALIGN = RIGHT }|
         TO output.

  ENDLOOP.
```

Tarea 3: Salida y prueba

Escriba el resultado en la consola. A continuación, active y pruebe su clase como una aplicación de consola.

Pasos

Al final del método, llame al método out->write para escribir el contenido de la salida en la consola. Proporcione el nombre del parámetro de importación con un título adecuado.
1. Después de ENDLOOP., añada el siguiente código:
  Code Snippet
```
123456

  out->write( 
         data   = output
         name   = |The first { max_count } Fibonacci Numbers|
                ) .
```
Active la clase.
1. Pulse Ctrl + F3 para activar la clase.
Ejecute su clase como una aplicación de consola.
1. Pulse F9 para ejecutar la clase como aplicación de consola.

Next lesson