Apostila ABAP - Parte 1

Sumário
1. Introdução – Lógica de Programação .............................................................. 2

Conceito de Algoritmo ........................................................................................... 2
Formas de Representação Gráfica (Fluxograma) ............................................... 3
3. Formas de Representação Narrativa (Pseudocódigo) .................................... 4
Instruções Básicas................................................................................................... 5
Operadores ............................................................................................................. 6
Operadores Aritméticos: ........................................................................................ 6
Operadores de Comparação: .............................................................................. 6
Operadores Lógicos: .............................................................................................. 7
Tomadas de Decisão.............................................................................................. 7
Blocos de Repetição .............................................................................................. 8
2. Introdução – ABAP ............................................................................................ 10
O que é ABAP?...................................................................................................... 10
Instruções .............................................................................................................. 10
Comentários .......................................................................................................... 12
Objetos de Dados ................................................................................................. 12
Estrutura Básica de um Programa (report) ......................................................... 13
Operações Aritméticas em ABAP ....................................................................... 15
Funções Matemáticas: ......................................................................................... 15
Variáveis de Sistema ............................................................................................ 17
Controle de Fluxos nos Programas ABAP............................................................ 18
Sentenças de Controle ......................................................................................... 24
Tabelas Internas .................................................................................................... 26
Como Declarar Tabelas Internas ......................................................................... 27
Carregando uma Tabela Interna ........................................................................ 28
Ordenando uma Tabela Interna .......................................................................... 29
Processamento de uma Tabela Interna.............................................................. 30
Leitura de Registro de uma Tabela...................................................................... 31
www.aztreinamentos.com
1. Introdução – Lógica de Programação
Conceito de Algoritmo
Um algoritmo é um conjunto de regras ou instruções bem definidas que
descrevem, passo a passo, como resolver um problema ou obter um resultado
específico. Essas regras formais englobam tanto fórmulas de expressões
aritméticas quanto lógicas.
Ao desenvolver um programa, a aplicação de algoritmos é fundamental para

determinar a sequência de ações necessárias para resolver um problema. Os
algoritmos podem ser expressos em diferentes formas, como fluxogramas,
pseudocódigo ou mesmo em uma linguagem de programação específica,
como o ABAP.
A programação estruturada é uma técnica utilizada no projeto da lógica de

programas que visa otimizar a escrita do código, a detecção de possíveis falhas
e a facilidade de realizar alterações e atualizações nos programas. Essa
metodologia tem como objetivos principais:
Agilizar a codificação da programação: A programação estruturada enfatiza a

organização e a clareza do código, tornando o processo de escrita mais
eficiente. Isso significa que o desenvolvedor segue uma estrutura lógica e bem
definida, utilizando estruturas de controle e técnicas que tornam o código mais
legível e compreensível.
Permitir a verificação de possíveis falhas: Ao utilizar técnicas da programação

estruturada, como a divisão do código em blocos lógicos e o uso de estruturas
de controle condicionais e de repetição, é mais fácil identificar possíveis erros
ou falhas nos programas. Essa abordagem facilita a depuração do código,
tornando mais simples localizar e corrigir problemas.
Facilitar as alterações e atualizações dos programas: Com a programação

estruturada, o código é organizado em módulos lógicos independentes, o que
torna mais simples realizar alterações e atualizações nos programas. Se um
determinado bloco de código precisa ser modificado, é possível fazer isso de
forma isolada, sem afetar o restante do programa. Isso reduz o risco de introduzir
novos erros e facilita a manutenção do software ao longo do tempo.
Em resumo, a programação estruturada é uma técnica que faz uso de

algoritmos e regras formais para desenvolver programas de forma mais
eficiente, visando à agilidade na codificação, à identificação de possíveis
falhas e à facilidade de realizar alterações e atualizações nos programas.
Formas de Representação Gráfica (Fluxograma)
A representação gráfica do algoritmo ou programa, conhecida como
fluxograma, é uma forma visual de ilustrar a execução passo a passo das
instruções. Essa representação utiliza símbolos específicos para representar
diferentes elementos do algoritmo. Aqui estão algumas das simbologias mais
utilizadas em fluxogramas na programação estruturada:
• Símbolo de Início/ Término: Geralmente é representado por um oval ou

retângulo com bordas arredondadas. Indica o início ou o término do
algoritmo ou do trecho de código.
• Símbolo de Processamento: Representado por um retângulo, é utilizado
para indicar uma ação ou operação a ser executada. Geralmente
contém a descrição da tarefa a ser realizada.
• Símbolo de Decisão: Representado por um losango, é utilizado para
indicar uma condição ou uma tomada de decisão. Possui setas de saída
para indicar os possíveis caminhos do fluxo, dependendo do resultado
da condição.
• Símbolo de Entrada/Saída: Representado por um paralelogramo, é
utilizado para representar a entrada ou saída de dados. Pode indicar a
leitura de valores do usuário (entrada) ou a exibição de resultados
(saída).
• Símbolo de Conector: Representado por um pequeno círculo, é utilizado
para conectar partes do fluxograma que estão em locais diferentes da
página.
É importante lembrar que esses símbolos podem variar ligeiramente

dependendo da convenção adotada, mas essas são as representações mais
comuns em fluxogramas.
Ao utilizar fluxogramas, é possível visualizar claramente a sequência de etapas
do algoritmo e a relação entre elas. Isso auxilia no entendimento do fluxo de
execução do programa, na identificação de possíveis problemas e na
comunicação entre membros da equipe de desenvolvimento.
É recomendado o uso de fluxogramas para documentar algoritmos e

programas, pois eles fornecem uma representação visual que facilita a
compreensão e a análise da lógica do código.
Exemplo de Fluxograma
3. Formas de Representação Narrativa (Pseudocódigo)

O pseudocódigo é uma forma de representação narrativa do algoritmo ou
programa, onde as instruções são escritas de forma descritiva, utilizando uma
linguagem estruturada próxima à linguagem natural. É uma maneira de
expressar a lógica do programa sem estar vinculado a uma linguagem de
programação específica.
Aqui está um exemplo de pseudocódigo para ilustrar a representação narrativa

de um algoritmo:
1. Início do programa
2. Ler valor1
3. Ler valor2
4. Somar valor1 e valor2 e armazenar o resultado em soma
5. Se soma for maior que 10, então:
6. Escrever "Resultado maior que 10"
7. Senão:
8. Escrever "Resultado menor ou igual a 10"
9. Fim do programa
Nesse exemplo, o pseudocódigo começa com a indicação do início do
programa. Em seguida, há instruções para ler dois valores (valor1 e valor2) a
partir do usuário. Depois, os valores são somados e o resultado é armazenado
na variável soma. O programa então verifica se a soma é maior que 10 e
imprime uma mensagem correspondente.
O uso do pseudocódigo facilita a compreensão da lógica do programa, pois se

aproxima da linguagem natural e permite uma representação mais abstrata do
algoritmo. Ele é útil para planejar e documentar a estrutura e o fluxo das
instruções, antes de realizar a implementação em uma linguagem de
programação específica.
Além disso, o pseudocódigo é uma forma eficiente de comunicar a lógica do

programa entre membros da equipe de desenvolvimento, permitindo uma
discussão mais clara e uma análise mais precisa da solução proposta.
Vale ressaltar que o pseudocódigo não segue uma sintaxe rígida, e sua estrutura
e convenções podem variar dependendo da preferência ou convenção
adotada pela equipe de desenvolvimento. O importante é que ele seja
compreensível e transmita adequadamente a lógica do algoritmo.
Instruções Básicas
Cada linguagem de programação usa um conjunto de palavras onde cada

uma desenvolve uma ação. Estas palavras reservadas de cada linguagem são
conhecidas como comandos ou instruções.
Abaixo estão algumas instruções básicas específicas do ABAP que você pode
incluir no seu manual:
Declaração de variáveis: No ABAP, é necessário declarar as variáveis antes de

usá-las. Você pode usar a palavra-chave "DATA" seguida pelo nome da variável
e seu tipo de dados. Exemplo:
DATA lv_nome TYPE string.
Atribuição de valores: A atribuição de valores em ABAP é realizada usando o

operador "=". Exemplo:
lv_nome = 'João'.
Estruturas condicionais: ABAP oferece a estrutura condicional "IF" para avaliar

condições. Exemplo:
IF lv_valor > 10.
WRITE 'O valor é maior que 10'.
ELSE.
WRITE 'O valor é menor ou igual a 10'.
ENDIF.
Estruturas de repetição: ABAP oferece diferentes estruturas de repetição, como

"DO", "WHILE" e "FOR". Exemplo usando "DO":
DO 10 TIMES.
WRITE 'Iteração número' && sy-index.
ENDDO.
Entrada e saída de dados: Você pode usar a instrução "WRITE" para exibir
informações na tela. Para receber entrada do usuário, pode-se utilizar a função
"PARAMETERS". Exemplo:
PARAMETERS p_nome TYPE string.

WRITE p_nome.
Essas são apenas algumas das instruções básicas específicas do ABAP SAP.
Lembre-se de consultar a documentação oficial do ABAP para obter
informações detalhadas sobre as instruções e recursos disponíveis.
Operadores
Operadores são símbolos ou palavras reservadas que são utilizados na definição
de expressões aritméticas e lógicas. Eles permitem combinar valores e executar
operações específicas. No ABAP, existem diferentes tipos de operadores que
podem ser usados em expressões. Vou listar alguns dos operadores mais comuns
no ABAP:
Operadores Aritméticos:
✓ Adição (+): Realiza a adição de dois valores.

✓ Subtração (-): Realiza a subtração de dois valores.
✓ Multiplicação (*): Realiza a multiplicação de dois valores.
✓ Divisão (/): Realiza a divisão de dois valores.
✓ Módulo (MOD): Retorna o resto da divisão entre dois valores.
Operadores de Comparação:
✓ Igual a (EQ): Verifica se dois valores são iguais.

✓ Diferente de (NE): Verifica se dois valores são diferentes.
✓ Maior que (GT): Verifica se o primeiro valor é maior que o segundo valor.
✓ Menor que (LT): Verifica se o primeiro valor é menor que o segundo
valor.
✓ Maior ou igual a (GE): Verifica se o primeiro valor é maior ou igual ao
segundo valor.
✓ Menor ou igual a (LE): Verifica se o primeiro valor é menor ou igual ao
segundo valor.
Operadores Lógicos:
✓ E lógico (AND): Retorna verdadeiro se ambas as condições são

verdadeiras.
✓ Ou lógico (OR): Retorna verdadeiro se pelo menos uma das condições
é verdadeira.
✓ Não lógico (NOT): Inverte o valor lógico de uma condição.
Tomadas de Decisão
São utilizadas para controlar o fluxo de processamento do programa. O controle
é efetuado através de condições lógicas.
Exemplo:
Se (NOTA >= 7) então

Aprovado = “Sim”
Senão
Aprovado = “Não”
Fim-Se
As tomadas de decisão são estruturas fundamentais na programação e

permitem controlar o fluxo de processamento do programa com base em
condições lógicas. No exemplo que você mencionou, temos um exemplo de
tomada de decisão utilizando a estrutura condicional "Se-Então-Senão" (if-then-
else) no ABAP.
Nesse exemplo, a decisão é baseada na condição "NOTA >= 7". Se a condição

for verdadeira (ou seja, a nota for maior ou igual a 7), a variável "Aprovado" será
atribuída o valor "Sim". Caso contrário, se a condição for falsa, a variável
"Aprovado" receberá o valor "Não".
A estrutura condicional no ABAP segue a seguinte sintaxe:
IF condição.
<bloco de código a ser executado se a condição for verdadeira>
ELSE.
<bloco de código a ser executado se a condição for falsa>
ENDIF.
Aplicando essa sintaxe ao exemplo mencionado, teríamos o seguinte código

em ABAP:
IF NOTA >= 7.
Aprovado = 'Não'.
ELSE.
Aprovado = 'Sim'.
ENDIF.
Dessa forma, o programa avaliará a condição "NOTA >= 7" e, com base no
resultado, definirá o valor da variável "Aprovado" como "Sim" ou "Não".
As tomadas de decisão são ferramentas poderosas para controlar o fluxo de

execução do programa e permitir que diferentes partes do código sejam
executadas com base em condições específicas.
Blocos de Repetição
Os blocos de repetição, também conhecidos como estruturas de loop, são
utilizados para executar um conjunto de instruções repetidamente enquanto
uma determinada condição for verdadeira. No ABAP, existem diferentes
estruturas de repetição, sendo uma delas o "Enquanto" (While).
No exemplo que você mencionou, temos um loop "Enquanto" que executa um

conjunto de instruções enquanto a condição "Contador < 10" for verdadeira. O
contador é incrementado a cada iteração e a variável "Soma" é atualizada.
A estrutura de repetição "Enquanto" no ABAP segue a seguinte sintaxe:
WHILE condição.
<bloco de código a ser executado repetidamente>
ENDWHILE.
Aplicando essa sintaxe ao exemplo mencionado, teríamos o seguinte código

em ABAP:
WHILE Contador < 10.

Contador = Contador + 1.
Soma = Soma + Contador.
ENDWHILE.
Nesse caso, o bloco de código dentro do loop será repetido enquanto a

condição "Contador < 10" for verdadeira. A cada iteração, o contador é
incrementado em 1 e o valor atual do contador é adicionado à variável "Soma".
Dessa forma, o loop continuará até que a condição seja falsa, ou seja, quando
o contador atingir o valor 10. Assim que a condição se tornar falsa, o
processamento da rotina será desviado para fora do loop.
Os blocos de repetição são úteis quando há a necessidade de executar um

conjunto de instruções repetidamente, com base em uma condição específica.
Isso permite automatizar tarefas e processar conjuntos de dados de maneira
eficiente.
2. Introdução – ABAP
O que é ABAP?
ABAP (Advanced Business Application Programming) é uma linguagem de
programação de quarta geração, desenvolvida e de propriedade da SAP
(Systems, Applications and Products in Data Processing). Ela foi projetada
especificamente para o desenvolvimento de aplicativos empresariais e é
amplamente utilizada no ambiente do sistema SAP, como o SAP ERP (Enterprise
Resource Planning).
As iniciais "ABAP" significam:
▪ Advanced: Refere-se à capacidade da linguagem de programação em

lidar com requisitos avançados de desenvolvimento de software,
incluindo manipulação de dados complexos e integração com outros
sistemas.
▪ Business: Indica que o foco principal do ABAP está no desenvolvimento
de soluções empresariais para atender às necessidades das
organizações, especialmente nas áreas de finanças, recursos humanos,
vendas, logística e muito mais.
▪ Application: Ressalta a natureza do ABAP como uma linguagem voltada
para o desenvolvimento de aplicativos e sistemas de software completos.
▪ Programming: Refere-se ao fato de que o ABAP é uma linguagem de
programação que permite aos desenvolvedores criar, modificar e
manter programas e funcionalidades dentro do ambiente SAP.
O ABAP é amplamente utilizado para a personalização, extensão e integração

de soluções SAP existentes, bem como para o desenvolvimento de novos
aplicativos e funcionalidades específicas. Ele oferece recursos avançados para
lidar com processos de negócios complexos, manipulação de dados, geração
de relatórios e interação com o usuário.
Além disso, o ABAP possui uma ampla biblioteca de funções e classes padrão,
que permitem aos desenvolvedores aproveitar a funcionalidade pré-existente e
acelerar o processo de desenvolvimento.
Em resumo, o ABAP é uma linguagem de programação poderosa e

especializada, projetada para atender às necessidades de desenvolvimento de
software empresarial, especialmente no contexto do sistema SAP.
Instruções
As instruções em um programa ABAP são elementos fundamentais para definir
a lógica e o comportamento do programa. Elas são escritas utilizando palavras-
chave específicas e seguem uma estrutura definida. Vamos explorar os
diferentes tipos de palavras-chave no ABAP:
Palavras-chave Declarativas: Essas palavras-chave são utilizadas para declarar

e definir os dados que serão utilizados no programa. Alguns exemplos de
palavras-chave declarativas são:
DATA: Utilizada para declarar variáveis.
TABLES: Utilizada para declarar tabelas internas ou acessar tabelas de banco
de dados.
TYPES: Utilizada para definir tipos de dados personalizados.
Exemplo de uso da palavra-chave DATA:
DATA lv_nome TYPE string.
Palavras-chave de Eventos: Essas palavras-chave são usadas para especificar

eventos em um programa ABAP. Os eventos representam pontos específicos
onde o ABAP executa um determinado processo. Alguns exemplos de palavras-
chave de eventos são:
START-OF-SELECTION: Esse evento ocorre no início do processamento do

programa.
TOP-OF-PAGE: Esse evento ocorre quando é necessário exibir um novo

cabeçalho de página.
Exemplo de uso da palavra-chave START-OF-SELECTION:
START-OF-SELECTION.
Palavras-chave de Controle: Essas palavras-chave são usadas para controlar o

fluxo de execução do programa. Elas permitem a execução condicional de
blocos de código, repetição de instruções e outras operações de controle.
Alguns exemplos de palavras-chave de controle são:
IF: Utilizada para realizar uma condição de verificação e executar blocos de

código com base no resultado.
WHILE: Utilizada para criar um loop que será executado enquanto uma
condição for verdadeira.
DO: Utilizada para criar um loop que será executado pelo menos uma vez e
repetidamente enquanto uma condição for verdadeira.
Exemplo de uso da palavra-chave IF:
IF lv_valor > 10.
WRITE 'O valor é maior que 10'.
ENDIF.
Palavras-chave Operativas: Essas palavras-chave executam funções

específicas no programa, dependendo do contexto. Elas são usadas para
realizar operações como escrita de dados, movimentação de valores,
chamada de funções, entre outros. Alguns exemplos de palavras-chave
operativas são:
WRITE: Utilizada para exibir informações na tela.

MOVE: Utilizada para atribuir um valor a uma variável.
CALL: Utilizada para chamar uma função ou um método.
Exemplo de uso da palavra-chave WRITE:
WRITE 'Hello, World!'.
Essas são apenas algumas das palavras-chave utilizadas no ABAP para definir
instruções em um programa. Cada palavra-chave possui sua própria sintaxe e
funcionalidade específica. É importante consultar a documentação oficial do
ABAP para obter informações detalhadas sobre as palavras-chave disponíveis
e suas respectivas funcionalidades.
Comentários
Em um programa ABAP, é possível inserir comentários para fornecer informações
adicionais e tornar o código mais legível. Existem duas formas comuns de inserir
comentários em um programa ABAP:
Comentários de linha inteira: Nesse tipo de comentário, um asterisco (*) é

inserido na primeira coluna da linha. Tudo o que estiver na linha após o asterisco
será considerado um comentário e não terá efeito no código. Exemplo:
* Este é um comentário de linha inteira.

WRITE 'Hello, World!'.
Nesse exemplo, a primeira linha é um comentário de linha inteira e o comando

WRITE exibirá "Hello, World!" na tela.
Comentários de linha parcial: Nesse tipo de comentário, as aspas duplas (") são
utilizadas para iniciar um comentário no meio de uma linha. Tudo o que estiver
entre as aspas duplas será considerado um comentário e não será interpretado
como código.
Exemplo:
WRITE 'Hello, World!'. " Exibe uma mensagem na tela
Nesse exemplo, o comentário está localizado após o comando WRITE e fornece

uma descrição do que o comando faz.
É importante observar que os comentários não são executados pelo programa

e são utilizados apenas para documentação e esclarecimentos dentro do
código. Eles são uma prática recomendada para facilitar a leitura, o
entendimento e a manutenção do código ABAP.
Lembre-se de utilizar comentários de forma adequada, fornecendo

informações relevantes e úteis para outros desenvolvedores e para você mesmo
no futuro.
Objetos de Dados
Os objetos de dados no ABAP podem ser classificados em três categorias:
campos de banco de dados, literais e variáveis internas.
Campos de Banco de Dados: São objetos de dados que estão definidos no
dicionário de dados do sistema SAP. Eles representam as colunas das tabelas de
banco de dados e são usados para armazenar e manipular informações
persistentes. Para utilizar campos de banco de dados em um programa ABAP,
é necessário declarar a tabela correspondente usando a sentença TABLES.
Exemplo:
TABLES: LFA1.
Nesse exemplo, a tabela LFA1 é declarada e pode ser utilizada no programa

para acessar os campos de banco de dados associados a ela.
Literais: São valores constantes que podem ser usados diretamente em um

programa ABAP. Existem dois tipos de literais comumente utilizados: literais de
texto e literais numéricos. Os literais de texto são representados entre aspas
simples (' ') e os literais numéricos são representados por valores numéricos.
Exemplo:
WRITE 'DIRECCIÓN'.
COMPUTE SALES = AMOUNT / 100.
Nesse exemplo, 'DIRECCIÓN' é um literal de texto que será exibido na tela e

AMOUNT / 100 é uma expressão envolvendo um literal numérico.
Variáveis Internas: São objetos de dados auxiliares que são declarados no

programa usando a sentença DATA. As variáveis internas são usadas para
armazenar valores temporários durante a execução do programa.
Exemplo:
DATA: VENDAS_TOTAIS TYPE P.
Nesse exemplo, a variável interna VENDAS_TOTAIS é declarada com o tipo de

dados P (numérico com ponto decimal) e pode ser usada para armazenar
valores relacionados às vendas totais.
Observação: As constantes são objetos de dados com conteúdo pré-definido

e protegido. São semelhantes às variáveis internas, mas seu valor não pode ser
alterado durante a execução do programa.
Em resumo, no ABAP, temos campos de banco de dados para manipulação de

dados persistentes, literais para representar valores constantes e variáveis
internas para armazenar valores temporários durante a execução do programa.
As constantes são objetos semelhantes às variáveis internas, mas com valores
pré-definidos e imutáveis.
Estrutura Básica de um Programa (report)

REPORT <nome>. " Nome do Programa
TABLES: <tabelas>. " Tabelas que serão utilizadas
DATA: <variáveis>. " Variáveis / Tabelas Internas / Work Áreas / Objetos internos
TOP-OF-PAGE. " A cada nova página executar as instruções indicadas
END-OF-PAGE. " No final de cada página executar as instruções indicadas
START-OF-SELECTION. " No início do programa executar as instruções indicadas
END-OF-SELECTION. " No final do programa executar as instruções indicadas
Agora, vou explicar brevemente o significado de cada parte da estrutura:
▪ REPORT: É a palavra-chave que indica o início de um programa ABAP

do tipo "report". O <nome> deve ser substituído pelo nome do programa
que você deseja dar.
▪ TABLES: Aqui você pode listar as tabelas que serão utilizadas no
programa. Substitua <tabelas> pelas tabelas relevantes separadas por
vírgula.
▪ DATA: Nesta seção, você pode declarar as variáveis, tabelas internas,
work areas ou objetos internos que serão utilizados no programa.
Substitua <variáveis> pelas declarações apropriadas.
▪ TOP-OF-PAGE: Esta parte contém instruções que serão executadas a
cada nova página de saída. Você pode incluir comandos para exibir
cabeçalhos ou informações relevantes. Preencha com as instruções
apropriadas.
▪ END-OF-PAGE: Aqui você pode colocar instruções que serão
executadas no final de cada página. Pode ser útil para exibir rodapés
ou resumos parciais, por exemplo.
▪ START-OF-SELECTION: Esta parte contém as instruções que serão
executadas no início do programa. É onde você pode realizar o
processamento principal, como a leitura de dados, cálculos ou
chamadas de funções. Insira as instruções adequadas.
▪ END-OF-SELECTION: Aqui você pode colocar as instruções que serão
executadas no final do programa, após a execução principal. Pode ser
útil para exibir resultados finais ou realizar ações de encerramento.
Lembre-se de substituir <nome>, <tabelas>, <variáveis> e preencher as

instruções com o código apropriado para o seu programa ABAP. Essa estrutura
básica serve como um ponto de partida para a organização do programa e
pode ser expandida com mais seções e instruções, dependendo das
necessidades do projeto.
Operações Aritméticas em ABAP
Em ABAP, é possível realizar as quatro operações aritméticas básicas, bem como
usar funções matemáticas para cálculos mais complexos. Vou explicar como
realizar essas operações:
Operações Aritméticas Básicas:
Usando a instrução COMPUTE: A instrução COMPUTE permite realizar operações

aritméticas em ABAP. Você pode usar os símbolos + (adição), - (subtração), /
(divisão) e * (multiplicação) para realizar as operações. Por exemplo:
COMPUTE var1 = var2 + var3.

COMPUTE var4 = var5 * var6.
Nesses exemplos, as variáveis var1, var2, var3, var4, var5 e var6 são utilizadas em
operações de adição e multiplicação.
Usando instruções específicas: ABAP também possui instruções específicas para

realizar operações aritméticas, como ADD TO, SUBTRACT FROM, MULTIPLY BY e
DIVIDE BY. Por exemplo:
ADD 5 TO var1.
SUBTRACT var2 FROM var3.
MULTIPLY var4 BY var5.
DIVIDE var6 BY var7.
Nesses exemplos, as variáveis var1, var2, var3, var4, var5, var6 e var7 são
utilizadas nas operações aritméticas correspondentes.
Funções Matemáticas:
Além das operações aritméticas básicas, ABAP também oferece uma
variedade de funções matemáticas para cálculos mais complexos. Algumas
das funções matemáticas disponíveis são:
EXP: Calcula o valor exponencial de um número.

LOG: Calcula o logaritmo natural (base e) de um número.
SIN: Calcula o seno de um ângulo em radianos.
COS: Calcula o cosseno de um ângulo em radianos.
SQRT: Calcula a raiz quadrada de um número.
DIV: Realiza a divisão inteira de dois números.
MOD: Calcula o resto da divisão inteira de dois números.
Exemplo de uso de funções matemáticas:
EXP: Calcula o valor exponencial de um número.
A função EXP retorna o valor exponencial de um número especificado. Ela é útil

para cálculos que envolvem crescimento exponencial, por exemplo.
DATA lv_exp TYPE f.

lv_exp = EXP(2). " Calcula o valor exponencial de 2
WRITE lv_exp. " Exibe o resultado: 7.389056
LOG: Calcula o logaritmo natural (base e) de um número.
A função LOG retorna o logaritmo natural de um número especificado. É útil

para cálculos que envolvem análise de dados ou redimensionamento de
escalas.
Exemplo de uso:
DATA lv_log TYPE f.

lv_log = LOG(10). " Calcula o logaritmo natural de 10
WRITE lv_log. " Exibe o resultado: 2.302585
SIN: Calcula o seno de um ângulo em radianos.
A função SIN retorna o valor do seno de um ângulo especificado em radianos.

É frequentemente usado em cálculos trigonométricos.
Exemplo de uso:
DATA lv_angle TYPE f VALUE 0.5. " Ângulo em radianos

DATA lv_sin TYPE f.
lv_sin = SIN(lv_angle). " Calcula o seno do ângulo
WRITE lv_sin. " Exibe o resultado: 0.479426
COS: Calcula o cosseno de um ângulo em radianos.
A função COS retorna o valor do cosseno de um ângulo especificado em

radianos. Também é usado em cálculos trigonométricos.
Exemplo de uso:
DATA lv_angle TYPE f VALUE 0.5. " Ângulo em radianos

DATA lv_cos TYPE f.
lv_cos = COS(lv_angle). " Calcula o cosseno do ângulo
WRITE lv_cos. " Exibe o resultado: 0.877583
SQRT: Calcula a raiz quadrada de um número.
A função SQRT retorna a raiz quadrada de um número especificado. É útil para

cálculos que envolvem medidas de distância ou dimensões.
Exemplo de uso:
DATA lv_number TYPE i VALUE 25. " Número para calcular a raiz quadrada
DATA lv_sqrt TYPE f.
lv_sqrt = SQRT(lv_number). " Calcula a raiz quadrada do número
WRITE lv_sqrt. " Exibe o resultado: 5.000000
DIV: Realiza a divisão inteira de dois números.
A função DIV realiza a divisão inteira de dois números especificados. Ela retorna
o resultado como um número inteiro, descartando a parte decimal.
Exemplo de uso:
DATA lv_dividend TYPE i VALUE 10. " Dividendo

DATA lv_divisor TYPE i VALUE 3. " Divisor
DATA lv_result TYPE i.
lv_result = DIV(lv_dividend, lv_divisor). " Realiza a divisão inteira
WRITE lv_result.
Variáveis de Sistema
No ABAP, existem variáveis internas especiais que são atualizadas
automaticamente pelo sistema e podem ser utilizadas nos programas. Essas
variáveis estão agrupadas na estrutura SYST (SY), que oferece informações sobre
o ambiente de execução e o contexto do programa. Algumas das variáveis
disponíveis na estrutura SYST são:
▪ SY-SUBRC: Essa variável indica o status de retorno de uma instrução

executada anteriormente. Ela contém um valor numérico que indica se
a instrução foi executada com sucesso (valor 0) ou se ocorreu algum erro
(valor diferente de zero).
▪ SY-TABIX: Essa variável contém o índice atual da tabela interna sendo
processada. Ela é útil para controlar a posição em uma iteração sobre
uma tabela interna.
▪ SY-MANDT: Essa variável contém o código do cliente (mandante)
atualmente ativo. O mandante é uma unidade organizacional no
sistema SAP que agrupa os dados de uma empresa específica.
▪ SY-LANGU: Essa variável contém o código de idioma do usuário
atualmente logado no sistema. Ela fornece informações sobre o idioma
preferencial do usuário.
▪ SY-DATUM: Essa variável contém a data atual do sistema no formato
AAAAMMDD.
▪ SY-UZEIT: Essa variável contém a hora atual do sistema no formato
HHMMSS.
▪ SY-TCODE: Essa variável contém o código da transação atualmente em
execução. Ela fornece informações sobre a transação sendo
executada no momento.
Essas são apenas algumas das variáveis disponíveis na estrutura SYST (SY). Elas
podem ser utilizadas nos programas para obter informações contextuais
relevantes ou realizar determinadas ações com base nessas informações.
Exemplo de uso:
IF SY-SUBRC = 0.
WRITE 'Instrução executada com sucesso.'.
ELSE.
WRITE 'Ocorreu um erro durante a execução da instrução.'.
ENDIF.
IF SY-DATUM = '20230602'.
WRITE 'Hoje é 02 de junho de 2023.'.
ENDIF.
No primeiro exemplo, a variável SY-SUBRC é verificada para determinar se a

instrução anterior foi executada com sucesso ou se ocorreu um erro. No
segundo exemplo, a variável SY-DATUM é utilizada para exibir uma mensagem
específica caso a data atual seja 02 de junho de 2023.
Essas variáveis internas fornecem informações úteis durante a execução do

programa e podem ser utilizadas para controlar o fluxo do programa ou exibir
informações relevantes para o usuário.
Controle de Fluxos nos Programas ABAP

No ABAP, assim como em outras linguagens estruturadas, podemos utilizar
instruções de controle de fluxo para subdividir o programa em blocos lógicos
que serão executados quando uma determinada condição for atendida. Para
criar uma condição, utilizamos a instrução IF...ELSE...ENDIF, que pode ser usada
em diferentes modalidades.
A estrutura básica de um bloco de condição IF no ABAP é a seguinte:
IF <condição>.
<bloco de código a ser executado se a condição for verdadeira>
ELSE.
<bloco de código a ser executado se a condição for falsa>
ENDIF.
Podemos ter várias condições e blocos de código dentro de um bloco IF.

Também é possível utilizar a instrução ELSEIF para adicionar mais condições
intermediárias. A instrução ELSE é opcional e é usada para especificar um bloco
de código que será executado se nenhuma das condições anteriores for
verdadeira.
Exemplo de uso do bloco de condição IF:
IF idade >= 18.

WRITE 'Você é maior de idade.'.
ELSE.
WRITE 'Você é menor de idade.'.
ENDIF.
Nesse exemplo, a variável idade é verificada. Se a idade for maior ou igual a 18,
a mensagem "Você é maior de idade" será exibida. Caso contrário, a
mensagem "Você é menor de idade" será exibida.
Exemplo de uso do bloco de condição IF com ELSEIF:
IF nota >= 90.

WRITE 'Parabéns! Você obteve uma nota excelente!'.
ELSEIF nota >= 70.
WRITE 'Sua nota está acima da média.'.
ELSE.
WRITE 'Sua nota não atingiu o mínimo necessário.'.
ENDIF.
Nesse exemplo, a variável nota é verificada. Se a nota for maior ou igual a 90, a
mensagem "Parabéns! Você obteve uma nota excelente!" será exibida. Se a
nota estiver entre 70 e 89, a mensagem "Sua nota está acima da média" será
exibida. Caso contrário, a mensagem "Sua nota não atingiu o mínimo
necessário" será exibida.
O controle de fluxo IF...ELSE...ENDIF no ABAP permite que você execute

diferentes blocos de código com base em condições específicas, tornando seu
programa mais flexível e adaptável a diferentes situações.
Correto, ao criar condições no ABAP, podemos utilizar os operadores clássicos

para comparar valores e expressões. Aqui está uma lista dos operadores mais
comumente utilizados no ABAP, juntamente com suas representações:
Nas condições utilizamos os operadores clássicos:
▪ E (AND): O operador lógico "E" é utilizado para verificar se duas

condições são ambas verdadeiras. É equivalente ao operador "AND"
em outras linguagens.
▪ Ou (OR): O operador lógico "Ou" é utilizado para verificar se pelo menos
uma das condições é verdadeira. É equivalente ao operador "OR" em
outras linguagens.
▪ Igual (=, EQ): O operador de igualdade é utilizado para verificar se dois
valores ou expressões são iguais.
▪ Diferente (<> , EN): O operador de diferença é utilizado para verificar se
dois valores ou expressões são diferentes.
▪ Maior (>, GT): O operador de maior é utilizado para verificar se um valor
é maior do que outro.
▪ Menor (<, LT): O operador de menor é utilizado para verificar se um valor
é menor do que outro.
▪ Maior ou igual (>=, GE): O operador de maior ou igual é utilizado para
verificar se um valor é maior ou igual a outro.
▪ Menor ou igual (<=, LE): O operador de menor ou igual é utilizado para
verificar se um valor é menor ou igual a outro.
Exemplos de uso dos operadores em condições:

IF idade >= 18 AND idade <= 30.
WRITE 'Você é um adulto jovem.'.
ENDIF.
IF sexo = 'M' OR sexo = 'F'.

WRITE 'Sexo válido.'.
ENDIF.
IF nota = 10.
WRITE 'Parabéns! Você tirou a nota máxima!'.
ELSEIF nota < 6.
WRITE 'Infelizmente, você foi reprovado.'.
ELSE.
WRITE 'Sua nota está na média.'.
ENDIF.
Nesses exemplos, os operadores são utilizados para comparar variáveis e tomar

decisões com base nos resultados das comparações. Lembre-se de utilizar os
operadores corretos de acordo com a lógica da condição que você deseja
criar.
Existem operadores adicionais que são usados para comparar cadeias de

caracteres. Esses operadores são úteis quando você precisa verificar a
presença ou a correspondência de uma determinada cadeia de caracteres
em outra. Aqui estão os operadores de comparação de cadeias de caracteres
no ABAP:
▪ CO (Contains Only): O operador "CO" é usado para verificar se a
primeira cadeia de caracteres contém apenas os caracteres da
segunda cadeia de caracteres.
▪ CN (Contains Not Only): O operador "CN" é a negação do operador
"CO". Ele é usado para verificar se a primeira cadeia de caracteres não
contém apenas os caracteres da segunda cadeia de caracteres.
▪ CA (Contains Any): O operador "CA" é usado para verificar se a primeira
cadeia de caracteres contém pelo menos um dos caracteres da
segunda cadeia de caracteres.
▪ NA (Contains Not Any): O operador "NA" é a negação do operador
"CA". Ele é usado para verificar se a primeira cadeia de caracteres não
contém nenhum dos caracteres da segunda cadeia de caracteres.
▪ CS (Contains String): O operador "CS" é usado para verificar se a
primeira cadeia de caracteres contém exatamente a segunda cadeia
de caracteres.
▪ NS (Contains No String): O operador "NS" é a negação do operador "CS".
Ele é usado para verificar se a primeira cadeia de caracteres não
contém a segunda cadeia de caracteres.
▪ CP (Contains Pattern): O operador "CP" é usado para verificar se a
primeira cadeia de caracteres corresponde ao padrão especificado
pela segunda cadeia de caracteres.
▪ NP (Contains No Pattern): O operador "NP" é a negação do operador
"CP". Ele é usado para verificar se a primeira cadeia de caracteres não
corresponde ao padrão especificado pela segunda cadeia de
caracteres.
Exemplos de uso dos operadores de comparação de cadeias de caracteres:
DATA lv_text TYPE string VALUE 'Hello, World!'.
IF lv_text CO 'Hello'.
WRITE 'A cadeia de caracteres contém apenas os caracteres da segunda
cadeia.'.
ENDIF.
IF lv_text CN 'Hello'.
WRITE 'A cadeia de caracteres não contém apenas os caracteres da
segunda cadeia.'.
ENDIF.
IF lv_text CA 'ABC'.
WRITE 'A cadeia de caracteres contém pelo menos um dos caracteres da
segunda cadeia.'.
ENDIF.
IF lv_text NA 'XYZ'.
WRITE 'A cadeia de caracteres não contém nenhum dos caracteres da
segunda cadeia.'.
ENDIF.
IF lv_text CS 'Hello, World!'.

WRITE 'A cadeia de caracteres contém exatamente a segunda cadeia.'.
ENDIF.
IF lv_text NS 'OpenAI'.
WRITE 'A cadeia de caracteres não contém a segunda cadeia.'.
ENDIF.
IF lv_text CP 'Hello, World!'.

WRITE 'A cadeia de caracteres corresponde ao padrão especificado pela
segunda cadeia.'.
ENDIF.
IF lv_text NP 'Hello, World!'.

WRITE 'A cadeia de caracteres não corresponde ao padrão especificado
pela segunda cadeia.'.
ENDIF.
Existem operadores especiais no ABAP que podem ser úteis em certas situações.
Aqui estão dois exemplos:
BETWEEN: O operador BETWEEN é usado para verificar se um valor está dentro

de um intervalo específico. Ele é usado principalmente para validar ranges.
Exemplo de uso:
DATA lv_number TYPE i VALUE 10.

IF lv_number BETWEEN 1 AND 100.
WRITE 'O número está no intervalo de 1 a 100.'.
ENDIF.
Nesse exemplo, o operador BETWEEN é usado para verificar se o valor de
lv_number está entre 1 e 100. Se sim, a mensagem "O número está no intervalo
de 1 a 100" será exibida.
IS INITIAL: O operador IS INITIAL é usado para verificar se uma variável foi

inicializada ou possui um valor inicial.
Exemplo de uso:
DATA lv_text TYPE string.
IF lv_text IS INITIAL.
WRITE 'A variável está vazia ou não foi inicializada.'.
ENDIF.
Nesse exemplo, o operador IS INITIAL é usado para verificar se a variável lv_text
está vazia ou não foi inicializada. Se sim, a mensagem "A variável está vazia ou
não foi inicializada" será exibida.
Esses operadores especiais fornecem maneiras convenientes de verificar ranges

ou se uma variável foi inicializada. Eles podem ser usados em combinação com
outras condições para adicionar lógica adicional aos seus programas.
A sentença CASE é utilizada no ABAP para executar diferentes instruções com

base no conteúdo de um campo ou variável. Ela permite realizar uma série de
comparações para determinar qual conjunto de instruções será executado.
Aqui está um exemplo de uso da sentença
CASE:
DATA lv_status TYPE char1 VALUE 'A'.

CASE lv_status.
WHEN 'A'.
WRITE 'Status A - Processando...'.
WHEN 'B'.
WRITE 'Status B - Aguardando aprovação...'.
WHEN 'C'.
WRITE 'Status C - Concluído.'.
WHEN OTHERS.
WRITE 'Status desconhecido.'.
ENDCASE.
Nesse exemplo, a variável lv_status é verificada em diferentes casos.

Dependendo do valor de lv_status, uma mensagem diferente será exibida. Se o
valor for 'A', a mensagem "Status A - Processando..." será exibida. Se for 'B', a
mensagem "Status B - Aguardando aprovação..." será exibida. Se for 'C', a
mensagem "Status C - Concluído." será exibida. Caso o valor não corresponda
a nenhum dos casos anteriores, a mensagem "Status desconhecido." será
exibida.
A cláusula WHEN OTHERS é usada como uma opção de fallback para lidar com
valores que não correspondem a nenhum dos casos específicos definidos
anteriormente. Ela permite executar um conjunto padrão de instruções quando
nenhum dos outros casos se aplica.
A sentença CASE é uma maneira eficiente de lidar com múltiplas condições e

executar diferentes instruções com base no conteúdo de um campo ou
variável. Ela pode ser usada para simplificar a lógica do programa e torná-lo
mais legível.
No ABAP, existe a instrução condicional ON CHANGE OF ... ENDON, que permite

executar um bloco de instruções quando ocorre uma mudança de valor em um
campo específico durante o acesso aos dados. Essa instrução é comumente
usada em relatórios para realizar ações específicas quando um determinado
campo muda de valor. Aqui está um exemplo de uso dessa instrução:
DATA: lv_field1 TYPE c LENGTH 10,
lv_field2 TYPE c LENGTH 10.
DO 10 TIMES.
lv_field1 = 'Value1'.
lv_field2 = 'Value2'.
WRITE: / 'Iteration:', sy-index.

WRITE: / 'Field1:', lv_field1.
WRITE: / 'Field2:', lv_field2.
ON CHANGE OF lv_field1.
WRITE: / 'Field1 value changed!'.
ON CHANGE OF lv_field2.
WRITE: / 'Field2 value changed!'.
ENDDO.
Nesse exemplo, temos dois campos, lv_field1 e lv_field2, e um loop DO que é

executado 10 vezes. A instrução ON CHANGE OF é usada para verificar se
houve uma mudança de valor nos campos lv_field1 ou lv_field2 durante cada
iteração do loop. Se houver uma mudança de valor em lv_field1, a mensagem
"Field1 value changed!" será exibida. Se houver uma mudança de valor em
lv_field2, a mensagem "Field2 value changed!" será exibida. Essas mensagens
serão exibidas apenas quando ocorrer uma mudança de valor em um dos
campos específicos.
A instrução ON CHANGE OF ... ENDON é útil para executar ações condicionais

com base em mudanças específicas de campo durante o processamento de
dados. Ela permite controlar o fluxo do programa e executar blocos de
instruções relevantes quando ocorrem as mudanças desejadas.
Sentenças de Controle
No ABAP, existem várias sentenças de controle que podem ser utilizadas para
finalizar o processamento de um bloco ou processo. Aqui estão algumas das
principais sentenças de controle:
CHECK <cond>: A sentença CHECK é usada para verificar uma condição. Se a

condição for falsa, o processamento é interrompido e o controle passa para a
próxima instrução após o bloco atual.
Exemplo de uso:
DATA lv_value TYPE i.

lv_value = 10.
CHECK lv_value > 0.

WRITE 'O valor é positivo.'.
CHECK lv_value < 0.

WRITE 'O valor é negativo.'.
Nesse exemplo, a primeira sentença CHECK verifica se lv_value é maior que

zero. Se a condição for verdadeira, a mensagem "O valor é positivo" será
exibida. A segunda sentença CHECK não será executada, pois a condição
anterior já foi atendida.
EXIT: A sentença EXIT é usada para sair de um loop ou de um bloco de código.

Ela finaliza imediatamente a execução do loop ou bloco e o controle é
transferido para a próxima instrução após o loop ou bloco.
Exemplo de uso:
DO 10 TIMES.
WRITE sy-index.
IF sy-index = 5.
EXIT.
ENDIF.
ENDDO.
Nesse exemplo, o loop DO é executado 10 vezes. Quando sy-index for igual a

5, a sentença EXIT é acionada, interrompendo o loop imediatamente. O
controle é transferido para a próxima instrução após o loop.
STOP: A sentença STOP é usada para parar completamente a execução de

um programa ABAP. Ela é útil para finalizar abruptamente a execução em
determinadas situações.
Exemplo de uso:
IF lv_error = 'X'.
WRITE 'Erro encontrado. Encerrando o programa.'.
STOP.
ENDIF.
Nesse exemplo, se uma variável lv_error tiver o valor 'X', a mensagem "Erro
encontrado. Encerrando o programa" será exibida e a sentença STOP será
acionada, encerrando imediatamente a execução do programa.
LEAVE: A sentença LEAVE é usada para sair de um loop ou de um bloco de

código específico. Ela finaliza a execução do loop ou bloco atual e o controle
é transferido para a próxima instrução após o loop ou bloco.
Exemplo de uso:
DO 10 TIMES.
WRITE sy-index.
IF sy-index = 5.
LEAVE.
ENDIF.
ENDDO.
Nesse exemplo, o loop DO é executado 10 vezes. Quando sy-index for igual a

5, a sentença LEAVE é acionada, interrompendo o loop. O controle é
transferido para a próxima instrução após o loop.
Essas sentenças de controle são úteis para controlar o fluxo do programa e

finalizar o processamento de blocos ou processos de maneira adequada.
Cada uma delas tem um propósito específico e pode ser utilizada em
diferentes situações, dependendo dos requisitos do seu programa.
Tabelas Internas
As tabelas internas no ABAP são estruturas de dados utilizadas para armazenar
vários registros de dados com a mesma estrutura na memória durante a
execução de um programa. Elas são úteis para organizar e manipular
conjuntos de dados de forma eficiente. Aqui estão algumas características
importantes das tabelas internas:
Estrutura consistente: As tabelas internas têm uma estrutura consistente, o que

significa que cada linha da tabela segue a mesma estrutura de campos
definida.
Acesso sequencial: Os elementos de uma tabela interna podem ser acessados

sequencialmente, um por vez, usando loops ou outras técnicas de iteração.
Flexibilidade de tamanho: As tabelas internas podem ser dimensionadas

dinamicamente para acomodar diferentes quantidades de dados. Elas
podem crescer ou diminuir conforme necessário durante a execução do
programa.
Manipulação de dados: É possível adicionar, modificar, excluir e ler dados de

uma tabela interna usando instruções específicas, como APPEND, MODIFY,
DELETE e READ TABLE.
Ordenação e classificação: É possível ordenar os dados de uma tabela interna

com base em critérios específicos usando a instrução SORT. Além disso, é
possível realizar pesquisas rápidas usando a instrução READ TABLE com uma
cláusula de pesquisa.
Eficiência de memória: As tabelas internas são armazenadas na memória

durante a execução do programa, o que proporciona acesso rápido aos
dados e melhor desempenho em comparação com o acesso a dados em
bancos de dados externos.
Exemplo de declaração e manipulação de uma tabela interna:
DATA: lt_customers TYPE TABLE OF lfa1,

ls_customer TYPE lfa1.
SELECT * FROM lfa1 INTO TABLE lt_customers WHERE land1 = 'BR'.
LOOP AT lt_customers INTO ls_customer.
WRITE: / 'Customer:', ls_customer-kunnr,
'Name:', ls_customer-name1.
ENDLOOP.
Nesse exemplo, uma tabela interna lt_customers é declarada do tipo lfa1, que
é a estrutura de uma tabela de clientes no dicionário de dados. Em seguida, é
realizada uma seleção de clientes no banco de dados, filtrando apenas
aqueles com país igual a 'BR'. Os resultados são armazenados na tabela
interna lt_customers. Em seguida, um loop é realizado na tabela interna para
exibir os campos kunnr e name1 de cada cliente.
As tabelas internas são uma ferramenta poderosa no ABAP para manipulação

de conjuntos de dados temporários e oferecem flexibilidade e eficiência no
processamento de informações durante a execução de um programa.
Como Declarar Tabelas Internas

A declaração de tabelas internas no ABAP segue uma sintaxe específica. Aqui
está um exemplo da maneira de declarar tabelas internas:
DATA: BEGIN OF <tabela> OCCURS <n>,

<Def.Campo1>,
<Def.Campo2>,
...
END OF <tabela>.
Nesse exemplo, <tabela> é o nome da tabela interna que você deseja

declarar, e <n> é o número máximo de linhas que a tabela interna pode
conter.
Dentro da declaração da tabela interna, você pode definir os campos da

tabela usando a sintaxe <Def.Campo>, onde <Def.Campo> é a definição do
campo com seu nome e tipo de dados. Você pode especificar vários campos
separados por vírgula.
A palavra-chave BEGIN OF indica o início da definição da tabela interna, e a

palavra-chave END OF indica o fim da definição. Entre o BEGIN OF e o END OF,
você pode listar os campos desejados, cada um em uma linha separada.
Exemplo de declaração de tabela interna:
DATA: BEGIN OF lt_customers OCCURS 10,

kunnr TYPE lfa1-kunnr,
name1 TYPE lfa1-name1,
city TYPE lfa1-city,
END OF lt_customers.
Nesse exemplo, a tabela interna lt_customers é declarada com um máximo de

10 linhas. A tabela possui três campos: kunnr, name1 e city, que correspondem
aos campos kunnr, name1 e city da tabela de clientes lfa1 no dicionário de
dados.
A declaração de tabelas internas permite definir a estrutura e a capacidade

de armazenamento da tabela, para que você possa manipular os dados de
forma adequada durante a execução do programa.
Carregando uma Tabela Interna

Para carregar dados em uma tabela interna no ABAP, existem algumas
opções disponíveis. Aqui estão algumas das principais maneiras de carregar
uma tabela interna:
APPEND: A instrução APPEND é usada para inserir um registro na tabela interna

com os valores carregados em uma área de trabalho.
Exemplo de uso:
DATA: lt_customers TYPE TABLE OF lfa1,

ls_customer TYPE lfa1.
ls_customer-kunnr = '1001'.
ls_customer-name1 = 'John Doe'.
ls_customer-city = 'New York'.
APPEND ls_customer TO lt_customers.
Nesse exemplo, a tabela interna lt_customers é carregada com os dados de

um registro da estrutura lfa1. O registro é inserido na tabela interna usando a
instrução APPEND.
COLLECT: A instrução COLLECT é usada para realizar a soma de valores em

uma linha de cabeçalho da tabela interna. Ela soma os campos de tipo P
(decimal), F (ponto flutuante) e I (inteiro) se existirem, em uma linha da tabela
com campos do tipo C (caractere) idênticos aos da área de trabalho.
Exemplo de uso:
DATA: lt_sales TYPE TABLE OF zsales,

ls_sales TYPE zsales.
ls_sales-material = 'ABC123'.
ls_sales-quantity = 10.
COLLECT ls_sales INTO lt_sales.
Nesse exemplo, a tabela interna lt_sales é carregada com os dados de um

registro da estrutura zsales. A instrução COLLECT é usada para somar os valores
do campo quantity em uma linha da tabela com o mesmo valor no campo
material.
SELECT INTO TABLE: É possível carregar uma tabela interna com o conteúdo de
uma tabela do banco de dados usando a instrução SELECT INTO TABLE.
Exemplo de uso:
DATA: lt_customers TYPE TABLE OF lfa1.
SELECT * FROM lfa1 INTO TABLE lt_customers.
Nesse exemplo, a tabela interna lt_customers é carregada com o conteúdo

da tabela de clientes lfa1 do banco de dados. Todos os registros da tabela
lfa1 são selecionados e inseridos na tabela interna.
Essas são algumas das maneiras comuns de carregar dados em uma tabela
interna no ABAP. A escolha da abordagem depende das necessidades
específicas do programa e da fonte dos dados que serão carregados na
tabela interna.
Ordenando uma Tabela Interna

Para ordenar uma tabela interna no ABAP, utilizamos a instrução SORT. A
instrução SORT permite classificar os registros em uma tabela interna com base
em critérios específicos. Aqui estão algumas formas de utilização da instrução
SORT:
SORT <intab>: Essa forma básica da instrução SORT é usada para classificar
uma tabela interna em ordem ascendente. Os registros são ordenados com
base nos valores dos campos da tabela interna.
Exemplo de uso:
SORT lt_customers.
Nesse exemplo, a tabela interna lt_customers será classificada em ordem

ascendente com base nos valores dos campos.
SORT <intab> BY <campo1> ... <campo n>: Essa forma da instrução SORT
permite classificar uma tabela interna com base em campos específicos. Os
registros são ordenados de acordo com a sequência dos campos listados.
Exemplo de uso:
SORT lt_customers BY kunnr name1.
Nesse exemplo, a tabela interna lt_customers será classificada primeiro pelo

campo kunnr e, em seguida, pelo campo name1.
SORT ... ASCENDING ou SORT ... DESCENDING: A instrução SORT também
permite especificar a direção da ordenação, seja ascendente ou
descendente. A ordenação ascendente é o padrão, mas você pode
explicitamente indicar a direção usando a palavra-chave ASCENDING. Para
ordenação descendente, você pode usar a palavra-chave DESCENDING.
Exemplo de uso:
SORT lt_customers BY kunnr DESCENDING.
Nesse exemplo, a tabela interna lt_customers será classificada em ordem

descendente pelo campo kunnr.
A instrução SORT é útil para organizar os registros em uma tabela interna de

acordo com uma determinada ordem. Ela pode ser usada em combinação
com outras instruções de manipulação de tabelas internas para realizar
operações eficientes de pesquisa e processamento de dados.
Processamento de uma Tabela Interna

No ABAP, podemos percorrer uma tabela interna utilizando a instrução LOOP
... ENDLOOP. Essa instrução permite iterar sobre os registros de uma tabela
interna e executar um bloco de instruções para cada registro. Aqui estão
algumas formas de utilizar a instrução LOOP:
LOOP AT <intab> (WHERE <cond>): Essa forma do loop permite percorrer os

registros de uma tabela interna que atendem a uma determinada condição.
A condição é especificada após a palavra-chave WHERE.
Exemplo de uso:
LOOP AT lt_customers WHERE city = 'New York'.

WRITE: / 'Customer:', lt_customers-name,
'City:', lt_customers-city.
ENDLOOP.
Nesse exemplo, o loop percorre apenas os registros da tabela interna

lt_customers que têm o valor 'New York' no campo city. Para cada registro que
atende a essa condição, as informações do cliente são exibidas.
LOOP AT <intab> FROM <inicio> TO <fim>: Essa forma do loop permite percorrer
os registros de uma tabela interna em um intervalo específico, definido pelos
valores de <inicio> e <fim>.
Exemplo de uso:
LOOP AT lt_customers FROM 1 TO 5.

WRITE: / 'Customer:', lt_customers-name,
'City:', lt_customers-city.
ENDLOOP.
Nesse exemplo, o loop percorre os registros da tabela interna lt_customers do
índice 1 ao índice 5. Para cada registro nesse intervalo, as informações do
cliente são exibidas.
A instrução LOOP é uma maneira eficiente de processar os registros de uma

tabela interna e executar operações específicas em cada registro. Ela permite
acesso fácil aos dados e a execução de lógica personalizada para cada
registro.
Leitura de Registro de uma Tabela

Sim, no ABAP, é possível buscar um registro específico em uma tabela interna
sem a necessidade de percorrer toda a tabela. Existem várias formas de
realizar essa leitura. Aqui estão algumas delas:
READ TABLE <intab>: Essa forma básica da instrução READ TABLE é usada para
ler um registro da tabela interna.
Exemplo de uso:
READ TABLE lt_customers INDEX 3.
Nesse exemplo, o registro na posição de índice 3 da tabela interna

lt_customers será lido e os valores dos campos correspondentes serão
acessíveis para uso posterior.
READ TABLE <intab> WITH KEY <chave>: Essa forma da instrução READ TABLE
permite buscar um registro com base em uma chave específica.
Exemplo de uso:
DATA: lv_key TYPE lfa1-kunnr.

lv_key = '1001'.
READ TABLE lt_customers WITH KEY kunnr = lv_key.
Nesse exemplo, o registro na tabela interna lt_customers cujo campo kunnr é

igual a '1001' será lido. O registro correspondente será armazenado nas
variáveis correspondentes para uso posterior.
READ TABLE <intab> WITH KEY <chave> BINARY SEARCH: Essa forma da
instrução READ TABLE é usada quando a tabela interna está ordenada. A
busca é realizada usando uma pesquisa binária, que é mais eficiente em
termos de tempo de execução para tabelas grandes.
Exemplo de uso:
DATA: lv_key TYPE lfa1-kunnr.

lv_key = '1001'.
READ TABLE lt_customers WITH KEY kunnr = lv_key BINARY SEARCH.
Nesse exemplo, a tabela interna lt_customers deve estar ordenada pelo
campo kunnr. O registro correspondente ao valor da chave '1001' será lido
usando a pesquisa binária.
READ TABLE <intab> INDEX <num>: Essa forma da instrução READ TABLE permite
ler um registro com base no número de índice.
Exemplo de uso:
READ TABLE lt_customers INDEX 5.
Nesse exemplo, o quinto registro da tabela interna lt_customers será lido.
A instrução READ TABLE é útil para buscar registros específicos em uma tabela
interna de forma eficiente, sem a necessidade de percorrer toda a tabela. Isso
pode economizar tempo e recursos, especialmente quando a tabela é
grande.
Modificando Tabelas Internas

No ABAP, é possível modificar os registros existentes em uma tabela interna
usando as instruções MODIFY, INSERT e DELETE. Aqui estão algumas formas de
modificar uma tabela interna:
MODIFY <intab> (INDEX <i>): Essa forma da instrução MODIFY é usada para
modificar um registro existente na tabela interna com base no índice.
Exemplo de uso:
lt_customers[3]-city = 'London'.
MODIFY lt_customers INDEX 3.
Nesse exemplo, o campo city do terceiro registro da tabela interna

lt_customers é modificado para 'London'. Em seguida, a instrução MODIFY é
usada para aplicar a modificação no registro correspondente.
INSERT <intab> (INDEX <i>): Essa forma da instrução INSERT é usada para inserir
um novo registro na tabela interna em uma posição específica, com base no
índice.
Exemplo de uso:
DATA: ls_new_customer TYPE lfa1.

ls_new_customer-kunnr = '2001'.
ls_new_customer-name1 = 'Jane Doe'.
ls_new_customer-city = 'Paris'.
INSERT ls_new_customer INTO lt_customers INDEX 4.
Nesse exemplo, um novo registro ls_new_customer é criado com os valores

desejados. Em seguida, ele é inserido na tabela interna lt_customers na
posição de índice 4 usando a instrução INSERT.
DELETE <intab> (INDEX <i>): Essa forma da instrução DELETE é usada para excluir
um registro existente na tabela interna com base no índice.
Exemplo de uso:
DELETE lt_customers INDEX 2.
Nesse exemplo, o segundo registro da tabela interna lt_customers é excluído

usando a instrução DELETE.
As instruções MODIFY, INSERT e DELETE permitem modificar os registros em uma

tabela interna de acordo com as necessidades do programa. Essas operações
podem ser realizadas com base no índice ou na chave de um registro
específico. É importante ter cuidado ao modificar tabelas internas para
garantir a consistência e integridade dos dados.
Além das instruções mencionadas anteriormente, existem outras instruções

úteis para manipular tabelas internas no ABAP. Aqui estão algumas delas:
CLEAR <intab>: A instrução CLEAR é usada para limpar uma tabela interna, ou
seja, remover todos os registros e redefinir o contador interno.
Exemplo de uso:
CLEAR lt_customers.
Nesse exemplo, a tabela interna lt_customers será limpa, removendo todos os

registros e redefinindo o contador interno.
REFRESH <intab>: A instrução REFRESH é usada para redefinir uma tabela

interna, removendo todos os registros existentes e redefinindo o contador
interno.
Exemplo de uso:
REFRESH lt_customers.
Nesse exemplo, a tabela interna lt_customers será redefinida, removendo

todos os registros e redefinindo o contador interno.
FREE <intab>: A instrução FREE é usada para liberar a memória ocupada por
uma tabela interna. Isso é útil quando não há mais necessidade de manter os
dados da tabela interna na memória.
Exemplo de uso:
FREE lt_customers.
Nesse exemplo, a memória ocupada pela tabela interna lt_customers será

liberada.
DESCRIBE TABLE <tab> LINES <contador_entradas> OCCURS <valor_occurs>: A

instrução DESCRIBE TABLE é usada para obter informações sobre uma tabela
interna, como o número de registros (linhas) e o número máximo de
ocorrências.
Exemplo de uso:
DESCRIBE TABLE lt_customers LINES lv_lines OCCURS lv_occurs.
Nesse exemplo, as variáveis lv_lines e lv_occurs receberão o número de linhas

e o número máximo de ocorrências da tabela interna lt_customers,
respectivamente.
Essas instruções adicionais permitem manipular e gerenciar tabelas internas de

forma mais eficiente, como limpá-las, redefini-las, liberar memória e obter
informações sobre elas. Isso ajuda a otimizar o uso de recursos e garantir a
correta manipulação dos dados em tempo de execução.
Material elaborado/revisado/ pela equipe da AZ Treinamentos, para mais
informações sobre materiais ou cursos, entre em contato pelo e-mail
contato@aztreinamentos.com ou pelo WhatsApp 11 94599 8429.

Apostila ABAP - Parte 1

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila ABAP - Parte 1

Enviado por

Direitos autorais:

Formatos disponíveis

Sumário

1. Introdução – Lógica de Programação .............................................................. 2

Ao desenvolver um programa, a aplicação de algoritmos é fundamental para

A programação estruturada é uma técnica utilizada no projeto da lógica de

Agilizar a codificação da programação: A programação estruturada enfatiza a

Permitir a verificação de possíveis falhas: Ao utilizar técnicas da programação

Facilitar as alterações e atualizações dos programas: Com a programação

Em resumo, a programação estruturada é uma técnica que faz uso de

• Símbolo de Início/ Término: Geralmente é representado por um oval ou

É importante lembrar que esses símbolos podem variar ligeiramente

É recomendado o uso de fluxogramas para documentar algoritmos e

3. Formas de Representação Narrativa (Pseudocódigo)

Aqui está um exemplo de pseudocódigo para ilustrar a representação narrativa

O uso do pseudocódigo facilita a compreensão da lógica do programa, pois se

Além disso, o pseudocódigo é uma forma eficiente de comunicar a lógica do

Cada linguagem de programação usa um conjunto de palavras onde cada

Declaração de variáveis: No ABAP, é necessário declarar as variáveis antes de

DATA lv_nome TYPE string.

Atribuição de valores: A atribuição de valores em ABAP é realizada usando o

Estruturas condicionais: ABAP oferece a estrutura condicional "IF" para avaliar

IF lv_valor > 10.

Estruturas de repetição: ABAP oferece diferentes estruturas de repetição, como

PARAMETERS p_nome TYPE string.

✓ Adição (+): Realiza a adição de dois valores.

✓ Igual a (EQ): Verifica se dois valores são iguais.

✓ E lógico (AND): Retorna verdadeiro se ambas as condições são

Se (NOTA >= 7) então

As tomadas de decisão são estruturas fundamentais na programação e

Nesse exemplo, a decisão é baseada na condição "NOTA >= 7". Se a condição

A estrutura condicional no ABAP segue a seguinte sintaxe:

Aplicando essa sintaxe ao exemplo mencionado, teríamos o seguinte código

As tomadas de decisão são ferramentas poderosas para controlar o fluxo de

No exemplo que você mencionou, temos um loop "Enquanto" que executa um

A estrutura de repetição "Enquanto" no ABAP segue a seguinte sintaxe:

Aplicando essa sintaxe ao exemplo mencionado, teríamos o seguinte código

WHILE Contador < 10.

Nesse caso, o bloco de código dentro do loop será repetido enquanto a

Os blocos de repetição são úteis quando há a necessidade de executar um

As iniciais "ABAP" significam:

▪ Advanced: Refere-se à capacidade da linguagem de programação em

O ABAP é amplamente utilizado para a personalização, extensão e integração

Em resumo, o ABAP é uma linguagem de programação poderosa e

Palavras-chave Declarativas: Essas palavras-chave são utilizadas para declarar

Exemplo de uso da palavra-chave DATA:

DATA lv_nome TYPE string.

Palavras-chave de Eventos: Essas palavras-chave são usadas para especificar

START-OF-SELECTION: Esse evento ocorre no início do processamento do

TOP-OF-PAGE: Esse evento ocorre quando é necessário exibir um novo

Exemplo de uso da palavra-chave START-OF-SELECTION:

Palavras-chave de Controle: Essas palavras-chave são usadas para controlar o

IF: Utilizada para realizar uma condição de verificação e executar blocos de

Exemplo de uso da palavra-chave IF:

IF lv_valor > 10.

WRITE 'O valor é maior que 10'.

Palavras-chave Operativas: Essas palavras-chave executam funções

WRITE: Utilizada para exibir informações na tela.

Exemplo de uso da palavra-chave WRITE:

WRITE 'Hello, World!'.

Comentários de linha inteira: Nesse tipo de comentário, um asterisco (*) é

* Este é um comentário de linha inteira.

Nesse exemplo, a primeira linha é um comentário de linha inteira e o comando

WRITE 'Hello, World!'. " Exibe uma mensagem na tela

Nesse exemplo, o comentário está localizado após o comando WRITE e fornece

É importante observar que os comentários não são executados pelo programa