Arquivo da categoria ‘Abap’

Message – Abap

Publicado: 19 de fevereiro de 2014 em Abap
0

Usado para eviar menssagens ao usuario do programa.

Sintaxe:

MESSAGE ‘menssagem de texto’ TYPE ‘[tipo]’.

Tipos de Menssagem

  • I – informação Exibir mensagem. Programa continua depois do usuário descartar a mensagem. Caixa de diálogo Modal
  • S – mensagem de Sucesso Exibir mensagem. Programa continua sem interrupção. Barra de status ou caixa de diálogo modal. *
  • W – aviso Exibir mensagem. Comportamento depende do contexto. Barra de status ou caixa de diálogo modal. *
  • E  – erro Exibir mensagem. Comportamento depende do contexto. Barra de status ou caixa de diálogo modal. *
  • A – terminação. Programa rescindido. Caixa de diálogo Modal.
  • X – curto despejo. Erro de tempo desencadeada com despejo Dump para a tela.

* Depende das configurações do SAP GUI.

Mais informações: http://help.sap.com/saphelp_46c/helpdata/en/85/daf6d14bac11d1890e0000e8322f96/content.htm

Exemplo:

Neste exemplo apenas imprimimos na tela algumas mensagens ao usuário.

Abap

*&---------------------------------------------------------------------*

*& Report  ZMENSSAGEM

*&

*&---------------------------------------------------------------------*

*& Desenvolvimento Aberto

*& Menssagens

*&---------------------------------------------------------------------*

REPORT  ZMENSSAGEM.

MESSAGE 'Menssagem de Sucesso' TYPE 'S'.

MESSAGE 'Menssagem de tipo Informação' TYPE 'I'.

MESSAGE 'Menssagem de tipo de termino do programa' TYPE 'A'.

Form e Perform – Abap

Publicado: 18 de fevereiro de 2014 em Abap
1

Similar às funções em outras linguagens de programação. Fornece encapsulamento de funcionalidade. Permite a passagem de parâmetro usando métodos diferentes.

A declaração FORM define uma sub-rotina e sua interface. Convenções de nomenclatura se aplicam ao nome da sub-rotina. As funções da sub-rotina são implementadas entre as declarações FORM e ENDFORM. As adições definem os parâmetros formais da sub-rotina e declaram a propagação das exceções de classe até a instrução que a invocou.

Você pode usar o comando PERFORM para chamar uma sub-rotina ABAP (FORM) a partir de qualquer programa, sujeito à verificação normal de autorização ABAP em tempo de execução. Você pode usar essas chamadas a sub-rotinas para a realização de cálculos, para a obtenção de dados a partir do banco de dados, formatação de dados, e assim por diante.

Métodos de Parâmetros

Apesar de uma sub-rotina poder operar em dados globais, este é um design pobre e nunca deve ser feito. O risco de erros de manutenção é muito maior.

Escolha o método mais conservador de passagem de parâmetros com base em objetivos de design:

  • Chamada por valor tem a vantagem de proporcionar segurança do objeto de dados. Mudanças na variável na sub-rotina não afetará o principal objeto de dados.
  • Chamada por valor e chamada por valor e resultado têm a desvantagem de sobrecarga associada ao fazer cópias de objetos de dados. Evite para grandes objetos de dados.

Sintaxe:

Escreve uma sub-rotina basica:

FORM minhasubrotina.

[instruções]

ENDFORM.

Chama uma sub-rotina basica:

PERFORM minhasubrotina.

Mais informações sobre sub rotinas: http://help.sap.com/abapdocu_702/en/abapform.htm

Exemplo:

Neste exemplo criamos três sub-rotinas, a primeira com uma sintaxe básica, a segunda enviando parâmetros e a terceira usando uma troca de valores dentro da sub-rotina.

Abap

*&---------------------------------------------------------------------*
*& Report  ZSUBROTINA *&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Sub Rotinas
*&---------------------------------------------------------------------*

REPORT  ZSUBROTINA.

* Declara variavel
DATA :  menssagem TYPE c LENGTH 100,
        num1      TYPE i,
        num2      TYPE i,
        resultado TYPE i.

* Alimenta variáveis
 menssagem = 'Enviando Menssagem Com Parametro'.
 num1 = 10.
 num2 = 2.
 resultado = 0.

* Chama Sub Rotina

PERFORM basico.
PERFORM msg USING menssagem.

* Troca valores depois da execução da Sub Rotina
PERFORM multiplica USING num1 num2 CHANGING resultado.
 WRITE : / 'Depois da Sub Rotina',
         / 'Reultado =' UNDER 'Resultado =', resultado.

* Cria Sub Rotina

* Sub Rotina Comum
FORM basico.
   WRITE : / 'Menssagem de uma Sub Rotina Basica'.
ENDFORM.

* Utiliza Parametros
FORM msg  USING messagem TYPE any.
   WRITE : / menssagem.
ENDFORM.

FORM multiplica USING    VALUE(x1) TYPE any
                          VALUE(x2) TYPE any
            CHANGING      VALUE(x)  TYPE any.
   x = x1 * x2.
   WRITE : / 'Multiplica X pelos parametros e troca pelo resultado',
           / ' Dentro da Sub Rotina :',
           / ' X = ', x , ' Resultado = ', resultado.
ENDFORM.

O que é um BOM programa?

Publicado: 18 de fevereiro de 2014 em Abap, C#, C/C++, Java, Python
0

Utilize Melhores praticas

Melhores práticas é uma expressão derivada do inglês best practices que denomina as técnicas identificadas como as melhores em termos de eficácia, eficiência e reconhecimento de valor para os envolvidos e afetados direta e ou indiretamente na realização de determinadas tarefas, atividades, procedimentos, ou até mesmo, na realização de um conjunto de tarefas, atividades, procedimentos devidamente agrupados ou integrados por um objetivo comum.

Best Pratices:

Sap: https://help.sap.com/bestpractices

Oracle: http://www.oracle.com/us/support/best-practices/overview/index.html?ssSourceSiteId=otnru

Microsoft: http://msdn.microsoft.com/en-us/library/ms184412(v=vs.110).aspx

Python: http://www.python.org/dev/peps/pep-0008/

Leia os White Papers de suas Ferramentas

Um White Paper ou, em português, “Livro branco” ou “Relatório Branco”, é um documento oficial publicado por um governo ou uma organização internacional, a fim de servir de informe ou guia sobre algum problema e como enfrentá-lo. Os “White Paper” são utilizados para educar os leitores e ajudar as pessoas a tomar decisões. São usados na política e nos negócios. Também podem ser um informe governamental que descreve uma política, geralmente, a longo prazo.

White Papers:

Sap: http://scn.sap.com/docs/DOC-17149

Java: http://www.oracle.com/technetwork/java/javase/documentation/whitepapers-jsp-139357.html

Microsoft: http://technet.microsoft.com/en-us/library/cc736902(v=ws.10).aspx

Python: http://www.deitel.com/Default.aspx?tabid=768

Design Pattern

Em engenharia de software, design pattern é uma solução reutilizável geral para um problema que comumente ocorre dentro de um determinado contexto em design de software. Um design pattern não é um projeto acabado que pode ser transformado diretamente em fonte ou código de máquina. É uma descrição ou modelo de como resolver um problema que pode ser utilizado em diversas situações diferentes. Os padrões são formalizadas as melhores práticas que o programador deve implementar na aplicação.

Design Pattern:

Sap: http://wiki.scn.sap.com/wiki/display/ABAP/ABAP+Objects+Design+Patterns+-+Singleton

Oracle: http://www.oracle.com/webfolder/ux/applications/DPG/OBIEE/patterns/index.html

Microsoft: http://msdn.microsoft.com/library/cc467894.aspx

Python: http://www.python.org/workshops/1997-10/proceedings/savikko.html

Um bom programa

Correto / sem erros.

Fácil de entender.

Fácil de modificar / ampliar.

Bom desempenho (velocidade).

Consistência

Escrever código de forma consistente torna mais fácil escrever e entender.

Guia de “estilo” Programação :

  • Definir regras sobre como fazer as coisas .
  • Diretrizes de estilo “padrão” tem sido amplamente aceita.

Variáveis​​:

substantivos (Primeira letra minúscula, palavras subsequentes maiúscula).

ex: x, forma, altaPontuação, arquivoNome.

Métodos:

verbos (Primeira letra minúsculas palavras subsequentes maiúsculas).

ex: getSize (), desenhe (), desenheComCor ()

Classes:

substantivos (Primeira letra maiúscula )

ex: Forma, PaginaDaWeb, EnderecoEmail.

Melhor Design de Classe

  • Uma boa classe  é fácil de entender e usar.
  • Escreva campos e métodos privados por padrão.
  • Só escreva métodos público, se você precisar.
  • Se você precisar de acesso a um campo, escreva um Metodo:   public int GetBar () {return bar;}

Depuração (Debugging)

O processo de encontrar e corrigir um erro em um programa

Uma habilidade fundamental na programação

Bom Desenvolvimento em 6 Passos

Passo 1: Não cometer erros

  • Não introduzir erros em primeiro lugar.
  • Reutilização: encontrar o código existente que faz o que você quer.
  • Projeto: pense antes de escrever um código.
  • Melhores Práticas: procedimentos recomendados / técnicas para evitar problemas comuns.

Desing Pseudocódigo

Um alto nível, descrição compreensível do que o programa supostamente faz.

Não se preocupe com os detalhes, se preocupe com a estrutura.

Desing

  • Design visual de objetos, ou como o programa funciona.
  • Não se preocupe com notação específica, basta fazer algo que faça sentido para você.
  • Racunhar em um pedaço de papel é útil.

desenho

Passo 2: Encontre erros no início

Mais fácil corrigir os erros quanto mais cedo você encontrá-los.

  • Teste o seu projeto.
  • Use ferramentas para detectar possíveis erros.
  • Teste a sua implementação.
  • Confira seu trabalho.

Teste: Entradas importantes

Confira todos os “caminhos” através do programa.

Pense em um exemplo para cada um “caminho”.

Warnings (Compilador)

Ferramentas: Avisos (Advertências).

  • Advertências: pode não ser um erro, mas trate como se fosse.
  • Sugestão: sempre corrigir todos os avisos.
  • Verificações extras: encontrar bugs e ferramentas relacionadas.
  • O teste de unidade: Ferramentas facilitam o teste de unidade.

Passo 3: reproduzir o erro

  • Descobrir como reproduzir o erro.
  • Criar um caso de teste mínimo.
  • Volte para a versão de trabalho, e introduza mudanças uma de cada vez até que o erro desapareça.
  • Elimine o material extra que não é usado.

Passo 4: Gerar Hipótese

  • O que está acontecendo de errado?
  • O que pode estar causando o erro?
  • Questionar suas premissas: “possivelmente não pode ser  X”.
  • E se é, devido a alguma outra coisa?

Passo 5: coletar informações

  • Se x é o problema, como você pode verificar?
  • Precisa de informações sobre o que está acontecendo dentro do programa.

Passo 6: Examinar dados

  • Examine seus dados A sua hipótese está correta?
  • Corrigir o erro, ou gerar uma nova hipótese.

Looping – While e Expressões Aritméticas – Abap

Publicado: 15 de fevereiro de 2014 em Abap
0

A declaração WHILE executa continuamente um bloco de instruções enquanto uma determinada condição é verdadeira.

Sintaxe:

WHILE condição.
[bloco de instruções.]
ENDWHILE.

Operadores Aritméticos

  • (+) – adição.
  • (-) – subtração.
  • (*) – multiplicação.
  • (/) – divisão.
  • DIV – divisão inteira.
  • MOD – Resto da divisão inteira.
  • ** – Potenciação.

Ao usar expressões matemáticas, os operadores +, -, *, **, e /, bem como abertura e fechamento de parênteses, são interpretados como palavras ABAP e devem ser precedidos e seguidos por espaços em branco.

Em operações de divisão, o divisor não pode ser zero se o dividendo não é zero. Com a divisão inteira, você usa os operadores DIV ou MOD em vez de /. DIV calcula o quociente inteiro, MOD calcula o resto da divisão.

Exemplo:

Neste exemplo criamos dois loopings para calcular os números primos em uma faixa de 1 à 1000. Vale  deixar como nota que a linguagem ABAP possui uma sintaxe estilo velha guarda, as linguagens mais modernas reformularam a sintaxe do comando While para que não gere erros de logica.

Podemos ver isto no exemplo abaixo, em ABAP inicializamos o valor do looping e alimentamos o contador fora do comando while, o que não acontece em linguagens como Java, C# e  o moderno C++. Em nosso exemplo a inicialização do looping é essencial para o resultado do calculo e pode ser facilmente esquecida ou não prevista, criando um resultado indesejado, já o contador se não for incrementado  irá entrar em um laço infinito impedindo a continuidade do programa, para entender melhor você pode ver o mesmo exemplo de laço com a sintaxe moderna clicando aqui:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZPRIMOS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Primos
*&---------------------------------------------------------------------*

REPORT  ZPRIMOS.

DATA : numeros TYPE i,
       primos  TYPE i.

numeros = 1.
*// Inicie a variável primos aqui e obterá um erro logico.

WHILE numeros LE 1000.

   primos  = 2. " // Old Style, tente inicializar a variável fora do looping.
   WHILE primos LE ( numeros - 1 ).

       IF ( ( numeros MOD primos ) EQ 0 ).
         EXIT.
       ENDIF.

   primos = primos + 1. " // Old Style, sem está instrução obterá um laço infinito.
   ENDWHILE.

   IF primos EQ numeros.
     WRITE : numeros, ','.
   ENDIF.

 numeros = numeros + 1. " //Old Style, sem está instrução obterá um laço infinito.
 ENDWHILE.

Condição – Case e Switch – Java, C++, C# e Abap

Publicado: 14 de fevereiro de 2014 em Abap, C#, C/C++, Java
0

A instrução CASE como o IF também é um comando clássico e existe em muitas linguagens de programação, seja ela compilada ou interpretada. O comando Case predominou por muitos anos e nos tempos atuais ganhou uma nova cara e um novo nome apesar de permanecer com a mesma estrutura, o SWITCH. Comando CASE ainda é usado nos dias atuais por varias linguagens de programação e linguagens de scripts entre elas o ABAP, PL/SQL, TRANSACT-SQL e outras.

A instrução CASE e SWITCH é como uma série de instruções IF, apenas usando a palavra-chave WHEN (Quando) ou CASE (Caso). A instrução é avaliada a partir de cima para baixo. Se a condição for verdadeira, então correspondente a cláusula é executado e execução salta para o fim do caso (avaliação curto-circuito).

Ou seja ao contrário de if-then e declarações if-then-else, a instrução switch pode ter um número de possíveis caminhos de execução. Um switch funciona com o byte, short, char, e tipos primitivos de dados int. Ele também funciona com tipos enumerados, a classe String, e algumas classes especiais que envolvem certos tipos primitivos: Character, Byte, Short, e Integer.

Exemplo:

Neste simples exemplo podemos ver como mostrar na tela o dia da semana usando um numero de 1 a 7.

Java

public class Caso {

public static void main(String[] args)
 {
      int dia = 5;
     switch (dia)
   {
       case 1:
      System.out.println("Segunda");
    break;
          case 2:
       System.out.println("Terça");
    break;
           case 3:
       System.out.println("Quarta");
    break;
           case 4:
       System.out.println("Quinta");
    break;
          case 5:
       System.out.println("Sexta");
    break;
          case 6:
       System.out.println("Sabado");
    break;

    default:
       System.out.println("Domingo");
    break;
  }

}

}

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication55
 {
     class Program
     {
         static void Main(string[] args)
         {
              int dia = 5;
     switch (dia)
   {
       case 1:
      Console.WriteLine("Segunda");
    break;
          case 2:
       Console.WriteLine("Terça");
    break;
           case 3:
       Console.WriteLine("Quarta");
    break;
           case 4:
       Console.WriteLine("Quinta");
    break;
          case 5:
       Console.WriteLine("Sexta");
    break;
          case 6:
       Console.WriteLine("Sabado");
    break;

   default:
   Console.WriteLine("Domingo");
   break;
  }

   Console.ReadKey();
         }
     }
 }

C++

#include "stdafx.h"
#include <iostream>
#include <cstdlib>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {
  int dia = 5;

switch (dia)
  {
  case 1:
   cout << "Segunda" << endl;
   break;

case 2:
   cout << "Terça" << endl;
   break;

case 3:
   cout << "Quarta" << endl;
   break;

case 4:
   cout << "Quinta" << endl;
   break;

case 5:
   cout << "Sexta" << endl;
   break;

case 6:
   cout << "Sabado" << endl;
   break;

default:
   cout << "Domingo" << endl;
   break;
  }
  system("pause");
  return 0;
 }

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCASO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Caso
*&---------------------------------------------------------------------*
REPORT  ZCASO.

DATA dia TYPE i.

dia = 5.

CASE dia.

WHEN 1.
               WRITE : / 'Segunda'.

WHEN  2.
               WRITE : / 'Terça'.

WHEN  3.
               WRITE : / 'Quarta'.

WHEN  4.
               WRITE : / 'Quinta'.

WHEN  5.
               WRITE : / 'Sexta'.

WHEN  6.
               WRITE : / 'Sabado'.

WHEN OTHERS.
               WRITE : / 'Domingo'.
ENDCASE.

Condição IF, ELSE, ELSEIF – Abap

Publicado: 14 de fevereiro de 2014 em Abap
1

IF é um dos comandos mais comuns e um dos mais importantes na programação, este comando é responsável pelas tomadas de decisões, existe praticamente em todas as linguagens de programação, antigamente este comando era conhecido como “se-então-senão” ou “if-then-else” mas as linguagens mais modernas substituirão o “então” pelo símbolo “{}” (colchetes), se a condição puder ser executada por apenas uma linha de comando então não é necessário usar o colchete.

Em ABAP a condição IF tem uma sintaxe um pouco diferente ficando assim:

IF(se) a condição for atendida faça algo, ELSEIF (senão, se) outra condição for atendida faça algo, ELSE (senão) faça algo, ENDIF (fim da condição).

Uma grande diferença do ABAP em relação as outras linguagens de programação é que mesmo nas instruções de condição se faz necessário dizer ao compilador que a linha foi terminada com o caractere .(ponto).

Sintaxe:

IF condição.
[bloco de comandos 1]
[ELSEIF condição.
[bloco de comandos 2]]
…
[ELSE.   [bloco de comando N]]
ENDIF.

Essas instruções definem uma estrutura de controle que pode conter vários blocos de instrução dos quais no máximo de um serão executados em conjunto com as expressões lógicas.

Outra diferença do ABAP são seus operadores, por não utilizar os símbolos padrões e sim instruções literais para avaliar as condições.

Operadores ABAP:

  • EQ  (=)  – É igual a.
  • NE (<>) – Não é igual a.
  • LT  (<) – É menor que.
  • GT  (>) – é maior do que.
  • LE (<=) – é menor do que ou igual a.
  • GE (>=) – é maior do que ou igual a.
  • AND – lógico e .
  • OR  – Lógico ou .
  • NOT – logico não.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCONDICAO 
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Condições
*&---------------------------------------------------------------------*

REPORT  ZCONDICAO.

* Declarando Variáveis
DATA :    variavel1 TYPE i,
          variavel2 TYPE i,
          variavel3 TYPE i.

* Alimenta as Variáveis
variavel1 = 100.
variavel2 = 150.
variavel3 = 200.

* Verifica as Condições.

* Comando IF
IF variavel1 LT variavel2.
WRITE : / 'Condicao1:', variavel1, ' é menor que ', variavel2.
ENDIF.

* Comando IF e ELSE
 IF variavel1 GT variavel2.
   WRITE : / 'Condicao2:', variavel1, ' é menor que ', variavel2.
 ELSE.
   WRITE : / 'Condicao2:', variavel2, ' é maior que ', variavel1.
 ENDIF.

* Comando IF e ELSEIF
 IF variavel1 EQ variavel2.
   WRITE : / 'Condicao3:', variavel1, ' é menor que ', variavel2.
 ELSEIF variavel2 LT variavel3.
   WRITE : / 'Condicao3:', variavel2, ' é menor que ', variavel3.
 ENDIF.

PARAMETERS – ABAP

Publicado: 13 de fevereiro de 2014 em Abap
0

Você pode usar a declaração PARAMETERS para declarar variáveis ​​de uma forma semelhante a declaração variáveis ​​DATA. Para cada parâmetro declarado, um campo de entrada aparece na tela de seleção correspondente. No lado esquerdo do campo de entrada, o nome do parâmetro é apresentado como texto. Os valores inseridos no campo de entrada pelo usuário são atribuídos à variável correspondente, enquanto o sistema processa a tela de seleção.

Sintaxe:

PARAMETERS variável TYPE tipo LENGTH tamanho DEFAULT valor.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZPARAMETROS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Parametros
*&---------------------------------------------------------------------*

REPORT  ZPARAMETROS.

PARAMETERS:  Nome   TYPE c LENGTH 50 DEFAULT 'Digite seu nome',
             Rua    TYPE c LENGTH 40 DEFAULT 'Digite sua Rua',
             Numero TYPE i,
             Bairro TYPE c LENGTH 30 DEFAULT 'Digite seu Bairro',
             CEP    TYPE c LENGTH 9 DEFAULT  'Cep',
             Cidade TYPE c LENGTH 40 DEFAULT 'Digite sua Cidade',
             Estado TYPE c LENGTH 2.

WRITE – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

A declaração ABAP básica para exibir dados na tela é WRITE.

Sintaxe:

WRITE <campo>.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZSAIDA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Saida de Tela
*&---------------------------------------------------------------------*

REPORT  ZSAIDA.

WRITE  10 'Saida1'.
*Saida começa na coluna 10.

WRITE (3) 'Saida2'.
*Saida tem apenas 3 caracteres.

WRITE (*) 'Saida3'.
*Saida é escrita em um tamanho suficiente sem espaços.

WRITE  10(3) 'Saida4'.
*Combinação das tecnicas acima.

WRITE / 'Saida5'.
*Saida é escrita na proxima linha.

WRITE /10(3) 'Saida6'.
*Combinação das tecnicas acima.

CONSTANTS – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

Constantes são chamados objetos de dados que você cria estaticamente usando uma instrução declarativa. Eles permitem que você armazene dados sob um nome específico dentro da área de memória de um programa. O valor de uma constante deve ser definida ao declará-lo. Ele não pode ser alterado posteriormente. O valor de uma constante, não pode ser alterado durante a execução do programa. Se você tentar alterar o valor de uma constante, um erro de sintaxe ou erro de execução ocorre.

Existe um número de constantes mantidas pelo sistema Por exemplo, SY-MANDT irá exibir o número de cliente atual.

A sintaxe da instrução constantes é exatamente a mesma que a da declaração DATA, mas com as seguintes exceções:

  • Você deve usar a adição de valor na declaração de constantes. O valor inicial especificado na adição de valor não pode ser alterado durante a execução do programa.
  • Você não pode definir constantes para XSTRINGS, referências, tabelas internas, ou estruturas que contêm as tabelas internas.

Sintaxe:

 CONSTANTS nome TYPE tipo VALUE valor

Exemplos:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCONSTANTES
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Constantes
*&---------------------------------------------------------------------*
REPORT  ZCONSTANTES.

CONSTANTS chave_alpha_numerica TYPE string VALUE 'AKFDF43SD098EWE2739AA003'.

WRITE : / 'O valor da Chave Alpha Numerica é fixo e não pode ser alterado', CHAVE_ALPHA_NUMERICA.

Tipos de Variáveis – GLOBAL – Abap Dictionary (SE11) – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

 Tipos de Dados Globais

Para declarar dados globais você precisa acessar o dicionário ABAP através da transação se11. Para mais informações sobre os tipos built-in do Abap Dictionary clique aqui.

Declarando uma variável global

  1. Abra o ABAP Dictionary pela transação SE11.
  2. Clique na opção “Data type”.
  3. Para evitar a colisão de nomes para a classe, começe os nomes de tipo com Z
  4. Nome: zchavevalidade.
  5. Clique no botão Create e escolha a classe Data element.
  6. Em Short Description escreva: Chave de validade do programa.
  7. Clique em Predefined Type.
  8. Em Data Type escolha INT4 e Length de 30.
  9. Clique em Activate.
  10. Clique em Local Object,
  11. Abra a transação SE38  e digite o programa abaixo.

ABAP


*&---------------------------------------------------------------------*
*& Report  ZGLOBAL
*&
*&---------------------------------------------------------------------*
*&  Desenvolvimento Aberto
*&  Tipos de Variáveis Globais
*&---------------------------------------------------------------------*

REPORT  ZGLOBAL.

DATA chave TYPE ZCHAVEVALIDADE.

chave = 152626113.

WRITE : / 'Chave de validade do programa:', chave.
Entradas mais Antigas
Entradas mais Recentes