Guia de introdução
Aplicação de técnicas básicas e conceitos
Trabalhar com classes locais
Ler dados do banco de dados
Trabalhar com objetos de dados estruturados
Trabalhar com tabelas internas complexas
Implementar atualizações do banco de dados utilizando business objects
Descrição do modelo de programação de aplicativos ABAP RESTful

Trabalhar com tabelas internas simples

Objectives

After completing this lesson, you will be able to:
  • Definir tabelas internas simples.
  • Processar dados utilizando tabelas internas simples.

Definição de tabelas internas simples

Tabelas internas

As tabelas internas são objetos de dados variáveis nos quais você pode armazenar vários valores de tipo idêntico. Este tipo deve ser indicado na declaração e é chamado de tipo de linha da tabela interna.

Cada valor ocupa uma linha da tabela interna. O número de linhas não é restrito. Teoricamente, você pode armazenar qualquer número de valores em uma tabela interna. As limitações só têm origem em limites técnicos, como memória disponível ou configuração do sistema.

O valor inicial de uma tabela interna é uma tabela vazia ou, por outras palavras, uma tabela com 0 linhas. Existem diferentes técnicas para preencher uma tabela interna. O exemplo usa a instrução APPEND para adicionar uma nova linha no fim da tabela interna e preenchê-la com um valor.

Tipos de tabela

O tipo de uma tabela interna é chamado de tipo de tabela.

No exemplo anterior, usamos TYPE TABLE OF diretamente na instrução DATA. O tipo de tabela foi vinculado à variável declarada.

Como alternativa, você pode usar TYPE TABLE OF em uma instrução TYPES para definir um tipo de tabela com um nome. Em seguida, você pode usar este tipo de tabela, por exemplo, em uma instrução DATA. A visibilidade destes tipos depende da posição da instrução TYPES.

Existem também tipos de tabela no ABAP Dictionary. Esses tipos de tabela são mantidos com um editor dedicado. Eles são chamados de tipos de tabela global porque são visíveis em qualquer lugar no sistema.

Processamento de dados com tabelas internas simples

Assista a este vídeo para saber como preencher uma tabela interna com a instrução APPEND.

O valor inicial de uma tabela interna é uma tabela vazia, ou seja, uma tabela interna com zero linhas.

Você já aprendeu que, com a instrução CLEAR, você pode reinicializar uma variável ABAP para o respectivo valor inicial específico de tipo.

Quando você usa CLEAR para uma tabela interna, você exclui todo o respectivo conteúdo e define o número de linhas como zero.

Existem várias formas de recuperar dados de uma tabela interna. Este exemplo recupera o conteúdo de uma linha individual usando uma expressão de tabela interna. Na expressão de tabela, o nome da tabela interna é seguido imediatamente por um par de colchetes. Uma expressão de número inteiro entre parênteses especifica a posição da linha a ser lida.

Nota:

A sintaxe correta requer pelo menos um espaço em branco após o parêntese de abertura e antes do parêntese de fechamento.

Leitura de uma tabela interna em um loop

O vídeo seguinte ilustra como você pode ler a partir de uma tabela interna em um loop.

Ao implementar um loop sobre uma tabela interna, você pode usar uma declaração inline após o suplemento INTO em vez de declarar a área de trabalho explicitamente com uma instrução DATA.

Ao efetuar isso, você não só reduz a quantidade de código que você tem que digitar, você também garante que o tipo de área de trabalho se adequa ao tipo de linha da tabela interna, porque o tipo do objeto de dados declarado inline é derivado do contexto, que, neste caso, é a tabela interna.

Experimente: tabelas internas simples

  1. Como no primeiro exercício deste curso, crie uma nova classe global que implemente a interface IF_OO_ADT_CLASSRUN.
  2. Copie o seguinte snippet de código para a parte de implementação do 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.
  3. Pressione CTRL + F3 para ativar a classe e F9 para executá-la como um aplicativo de console.
  4. Analise a saída do console. Jogue com o código-fonte para se familiarizar com os conceitos.

Trabalhar com tabelas internas simples

Neste exercício, você utiliza iterações e tabelas internas simples para calcular e exibir os números de Fibonacci.

Nota

Os números de Fibonacci são uma sequência de números em que cada número é a soma dos dois precedentes. A sequência começa com 0 e 1, e cada número subsequente é a soma dos dois números anteriores. A sequência tem várias propriedades matemáticas, padrões e aplicações em campos como matemática, ciência da computação, natureza e arte.

Modelo:

  • nenhum

Solução:

  • /LRN/CL_S4D400_BTS_ITERATE (classe global)

Tarefa 1: Calcular os números

No seu próprio pacote, crie uma nova classe global. Defina uma constante para o número de iterações e uma tabela interna para os números de Fibonacci. Em seguida, calcule os números de Fibonacci em uma iteração e armazene-os na tabela interna.

Etapas

  1. Crie uma nova classe global que implemente a interface IF_OO_ADT_CLASSRUN (nome sugerido: ZCL_##_ITERATE, onde ## representa seu número de grupo).

    1. Selecione ArquivoNovaclasse ABAP.

    2. Insira o nome do seu pacote no campo Pacote. No campo Nome, insira o nome ZCL_##_ITERATE, onde ## representa seu número de grupo.

    3. Insira uma descrição.

    4. No quadro de grupo Interfaces, selecione Adicionar.

    5. Insira IF_OO_ADT_CLASSRUN. Quando a interface aparecer na lista de ocorrências, clique duas vezes nela para adicioná-la à definição de classe.

    6. Selecione Avançar.

    7. Selecione sua ordem de transporte e, em seguida, Concluir.

  2. No método IF_OO_ADT_CLASSRUN~MAIN, defina uma constante para o número de iterações (nome proposto: max_count) com um valor pequeno, por exemplo, 20.

    1. Adicione o seguinte código:

      Code Snippet
      123
      CONSTANTS max_count TYPE i VALUE 20.
  3. Declare uma tabela interna simples para armazenar os números Fibonacci (nome sugerido: números).

    1. Adicione o seguinte código:

      Code Snippet
      123
      DATA numbers TYPE TABLE OF i.
  4. Implemente uma iteração que é executada max_count vezes.

    1. Após as declarações, adicione o seguinte código:

      Code Snippet
      12345
      DO max_count TIMES. ENDDO.
  5. Dentro da iteração, implemente uma distinção de casos com base no contador de iteração integrado: na primeira iteração, adicione o valor 0 aos números da tabela interna. Na segunda iteração, adicione o valor 1 ao fim dos números de tabela interna.

    Dica

    O contador de iteração integrado é o campo do sistema sy-index.
    1. Entre DO e ENDDO, adicione o seguinte código:

      Code Snippet
      12345678
      CASE sy-index. WHEN 1. APPEND 0 TO numbers. WHEN 2. APPEND 1 TO numbers. ENDCASE.
  6. Adicione uma ramificação executada para todos os outros valores. Nesta ramificação, calcule a nova entrada como o total das duas entradas precedentes em números.

    Dica

    Acesse as entradas precedentes utilizando o índice sy-index - 1 e sy-index - 2.
    1. Ajuste o código da seguinte forma:

      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.

Tarefa 2: Preparar uma saída formatada

Em um loop sobre a tabela interna, prepare uma saída formatada que liste cada número Fibonacci com seu respectivo número sequencial. Prepare a saída em outra tabela interna do tipo de linha string.

Etapas

  1. No início do método if_oo_adt_classrun~main, declare uma tabela interna do tipo de linha string (nome sugerido: output).

  2. Implemente um loop sobre os números da tabela interna para ler os números de Fibonacci um a um em um número variável.

    Dica

    Use uma declaração inline para o número.
    1. No final do método, adicione o seguinte código:

      Code Snippet
      12345
      LOOP AT numbers INTO DATA(number). ENDLOOP.
  3. Declare uma variável inteira (nome sugerido: counter), que você define como zero antes do loop e aumenta em 1 em cada iteração.

    Dica

    Você pode utilizar uma declaração inline para o contador.
    1. Ajuste o código da seguinte forma:

      Code Snippet
      12345678
      DATA(counter) = 0. LOOP AT numbers INTO DATA(number). counter = counter + 1. ENDLOOP.
  4. Em cada iteração, adicione uma nova linha à saída de tabela interna que contém o conteúdo do contador (4 caracteres de largura, alinhado à esquerda), dois pontos (:) e o conteúdo do número (10 caracteres de largura, alinhado à direita).

    Dica

    Utilize um modelo de cadeia com opções de formato adequadas para ajustar o formato.
    1. Ajuste o código da seguinte forma:

      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.

Tarefa 3: Saída e teste

Escreva o resultado no console. Em seguida, ative e teste sua classe como um aplicativo de console.

Etapas

  1. No final do método, chame o método out->write para escrever o conteúdo da saída no console. Forneça o nome do parâmetro de importação com uma legenda adequada.

    1. Após ENDLOOP., adicione o seguinte código:

      Code Snippet
      123456
      out->write( data = output name = |The first { max_count } Fibonacci Numbers| ) .
  2. Ative a classe.

    1. Pressione Ctrl + F3 para ativar a classe.

  3. Execute sua classe como um aplicativo de console.

    1. Pressione F9 para executar a classe como aplicativo de console.