<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>boaspracticas on Abapinho</title><link>https://abapinho.com/categories/boaspracticas/</link><description>Recent content in boaspracticas on Abapinho</description><generator>Hugo -- gohugo.io</generator><language>pt</language><copyright>&amp;copy;2009-2026 Nuno Godinho</copyright><lastBuildDate>Mon, 06 Jul 2015 09:00:46 +0000</lastBuildDate><atom:link href="https://abapinho.com/categories/boaspracticas/index.xml" rel="self" type="application/rss+xml"/><item><title>Tenta converter WRITEs para ALVs</title><link>https://abapinho.com/2015/07/tenta-converter-writes-para-alvs/</link><pubDate>Mon, 06 Jul 2015 09:00:46 +0000</pubDate><guid>https://abapinho.com/2015/07/tenta-converter-writes-para-alvs/</guid><description>Relatórios que ainda escrevem directamente no ecrã são muito difíceis de manter quando é necessário alterá-los. Se o tiveres de fazer revê o código e, se o esforço não for demasiado, considera convertê-lo para ALV. Se tiveres dúvidas quanto às consequências disto, envolve um funcional nesta decisão.</description></item><item><title>Encapsularás, encapsularás, encapsularás</title><link>https://abapinho.com/2015/05/encapsularas-encapsularas-encapsularas/</link><pubDate>Mon, 11 May 2015 11:40:10 +0000</pubDate><guid>https://abapinho.com/2015/05/encapsularas-encapsularas-encapsularas/</guid><description>Historicamente os programas ABAP tendem a ser muito loooongos. Todas as boas prácticas de programação ensinam que não há uma única vantagem nisso. Se uma rotina, seja ela um programa, um método, uma função ou outra coisa, tiver mais do que 200-300 linhas, desconfia e considera seriamente modularizá-la em várias sub-rotinas. Esta abordagem tem a vantagem adicional de potenciar a reutilização de código. Mas a maior vantagem é o encapsulamento, isolando variáveis no seu contexto local, em vez de as ter todas juntas, tendo como resultado código mais seguro e mais claro.</description></item><item><title>Reutilizarás, não reescreverás</title><link>https://abapinho.com/2015/05/reutilizaras-nao-reescreveras/</link><pubDate>Mon, 04 May 2015 09:00:28 +0000</pubDate><guid>https://abapinho.com/2015/05/reutilizaras-nao-reescreveras/</guid><description>Se o mesmo pedaço de código estiver repetido mais do que uma vez, pergunta-te porquê e tenta evitá-lo, criando uma rotina reutilizável. Se, num programa, existir mais do que um SELECT para a mesma tabela, tenta fundi-los num único. Por vezes a utilização inteligente de RANGES para unificar parâmetros pode evitar a necessidade de múltiplos SELECTs a uma mesma tabela. Se o mesmo código for usado em dois programas diferentes tenta, ao invés, mover esse código para uma classe que possa ser partilhada pelos dois.</description></item><item><title>Evitarás variáveis globais</title><link>https://abapinho.com/2015/04/evitaras-variaveis-globais/</link><pubDate>Mon, 13 Apr 2015 09:00:36 +0000</pubDate><guid>https://abapinho.com/2015/04/evitaras-variaveis-globais/</guid><description>Quanto mais variáveis globais existirem num programa, mais obscuro ele se tornará. Evita-as. Esta é uma das regras mais básicas da boa programação e deve ser seguida o mais possível. Mesmo se muitas variáveis tiverem de ser passadas entre rotinas. O esforço é um pouco maior, mas daí resultará código muito mais claro e seguro. Excepções podem ser feitas no caso de relatórios muito simples que revolvam à volta de uma única tabela interna, tabela esta que poderá ser declarada globalmente sem comprometer a clareza do código.</description></item><item><title>Usarás sempre uma estrutura pré-definida nas ALVs</title><link>https://abapinho.com/2015/03/usaras-sempre-uma-estrutura-pre-definida-nas-alvs/</link><pubDate>Mon, 16 Mar 2015 09:00:30 +0000</pubDate><guid>https://abapinho.com/2015/03/usaras-sempre-uma-estrutura-pre-definida-nas-alvs/</guid><description>É comum encontrar as estruturas de dados das ALVs declaradas explicitamente no código. Quando isto é feito, o catálogo de campos tem de ser criado manualmente. Se em vez disso se usar uma estrutura pré-definida (do DDIC ou como TYPE), o catálogo de campos pode ser criado automaticamente. Esta abordagem é sempre melhor resultando em menos código, mesmo que o catálogo de campos tenha de ser reajustado aqui e ali. https://abapinho.</description></item><item><title>Usarás TRANSPORTING NO FIELDS</title><link>https://abapinho.com/2015/03/usaras-transporting-no-fields/</link><pubDate>Mon, 09 Mar 2015 09:00:02 +0000</pubDate><guid>https://abapinho.com/2015/03/usaras-transporting-no-fields/</guid><description>Muitas vezes fazes READ TABLE itbl ou LOOP AT itbl apenas para verificar se um registo existe (CHECK SY-SUBRC = 0). Ora para isso, os dados do registo não são realmente necessários. Nestes casos usa sempre TRANSPORTING NO FIELDS. Assim evitas ter de declarar uma estrutura destino e o programa fica mais rápido porque não tem de perder tempo a copiar dados.</description></item><item><title>Usarás classes de excepção</title><link>https://abapinho.com/2015/01/usaras-classes-de-excepcao/</link><pubDate>Thu, 22 Jan 2015 09:00:28 +0000</pubDate><guid>https://abapinho.com/2015/01/usaras-classes-de-excepcao/</guid><description>Nas classes, considera usar classes de excepção tipificadas em vez das excepções antigas. As novas têm imensas vantagens e, uma vez compreendidas, permitem produzir um código mais simples e robusto.
https://zevolving.com/2011/12/class-based-exception/</description></item><item><title>Usarás literais prontos a traduzir nos programas</title><link>https://abapinho.com/2015/01/usaras-literais-prontos-a-traduzir-nos-programas/</link><pubDate>Tue, 13 Jan 2015 10:13:48 +0000</pubDate><guid>https://abapinho.com/2015/01/usaras-literais-prontos-a-traduzir-nos-programas/</guid><description>Em programas, em vez de WRITE TEXT-001, usa WRITE ‘bla bla bla’(001). Assim, terás sempre um texto por defeito e além disso o programa será mais legível. https://abapinho.com/en/2011/11/programas-poliglotas/</description></item><item><title>Usarás a SALV em vez das antigas funções de ALV</title><link>https://abapinho.com/2015/01/usaras-a-salv-em-vez-das-antigas-funcoes-de-alv/</link><pubDate>Thu, 08 Jan 2015 09:00:37 +0000</pubDate><guid>https://abapinho.com/2015/01/usaras-a-salv-em-vez-das-antigas-funcoes-de-alv/</guid><description>As classes SALV são mais versáteis e sofisticadas do que os antigos módulos de função. Portanto, para ALVs novas, usa sempre a SALV. Excepção feita para ALVs que precisem de editar os dados pois nesse caso as SALV ainda são muito pouco capazes. https://scn.sap.com/docs/DOC-10365 https://scn.sap.com/docs/DOC-10366</description></item><item><title>INNER JOIN vs FOR ALL ENTRIES vs RANGES artificiais</title><link>https://abapinho.com/2014/11/inner-join-vs-for-all-entries-vs-ranges-artificiais/</link><pubDate>Tue, 25 Nov 2014 09:00:13 +0000</pubDate><guid>https://abapinho.com/2014/11/inner-join-vs-for-all-entries-vs-ranges-artificiais/</guid><description>Uma vez que as operações de dados estão muito mais optimizadas no servidor de base de dados do que no ABAP, é sempre preferível o primeiro. FOR ALL ENTRIES só deve ser usado quando não se conseguir fazer INNER JOIN (como com a BSEG por exemplo). Quando possível, usar RANGES artificiais é preferível a usar FOR ALL ENTRIES mas é preciso cuidado para não ultrapassar o limite do parser de SQL.</description></item><item><title>Não usarás CHECKs directamente em user-exits</title><link>https://abapinho.com/2014/11/nao-usaras-checks-directamente-em-user-exits/</link><pubDate>Mon, 10 Nov 2014 09:00:51 +0000</pubDate><guid>https://abapinho.com/2014/11/nao-usaras-checks-directamente-em-user-exits/</guid><description>É comum encontrar o comando CHECK em user-exits. A trágica consequência disto é que, se o CHECK falha, nenhum do código que se segue a esse CHECK será alcançado. Como é comum (ainda que má prática) que num user-exit sejam tratados vários assuntos diferentes, um CHECK relacionado com um assunto pode inibir o acesso aos assuntos seguintes. Uma forma simples de evitar este risco é, como sempre aconselho, encapsular o código em rotinas.</description></item><item><title>Usarás LIKE LINE OF itbl</title><link>https://abapinho.com/2014/10/usaras-like-line-of-itbl/</link><pubDate>Mon, 20 Oct 2014 10:25:10 +0000</pubDate><guid>https://abapinho.com/2014/10/usaras-like-line-of-itbl/</guid><description>Ao declarar uma estrutura que vai receber dados de uma tabela interna, em vez de a declarares directamente com o seu tipo, usa LIKE LINE OF. Assim, não só ficará claro que estão relacionadas como, se mudares o tipo da tabela interna, não terás de te preocupar em mudar também o tipo da estrutura.</description></item><item><title>Não farás COMMIT em user-exits</title><link>https://abapinho.com/2014/09/nao-faras-commit-em-user-exits/</link><pubDate>Mon, 29 Sep 2014 09:00:25 +0000</pubDate><guid>https://abapinho.com/2014/09/nao-faras-commit-em-user-exits/</guid><description>Não faças COMMIT dentro de user-exits. E garante também que rotinas que possas chamar a partir de user-exits não o fazem.</description></item><item><title>Considerarás usar clusters SM34</title><link>https://abapinho.com/2014/09/consideraras-usar-clusters-sm34/</link><pubDate>Thu, 11 Sep 2014 09:00:14 +0000</pubDate><guid>https://abapinho.com/2014/09/consideraras-usar-clusters-sm34/</guid><description>Se um desenvolvimento necessitar de mais do que uma tabela de parametrização, considera agrupar as tuas vistas de manutenção num “cluster”. Assim será mais intuitivo mantê-las. Isto fará ainda mais sentido se umas dependerem de outras uma vez que na definição do “cluster” estas relações podem ser explicitadas.
Exemplo: Como encavalitar tabelas</description></item><item><title>Não farás SELECT *</title><link>https://abapinho.com/2014/09/nao-facas-select-asterisco/</link><pubDate>Thu, 04 Sep 2014 11:25:03 +0000</pubDate><guid>https://abapinho.com/2014/09/nao-facas-select-asterisco/</guid><description>Tenta seleccionar sempre apenas os campos que vais realmente usar. Escolher todos é um desperdício de recursos. Excepção feita ao uso das FM *_SINGLE_READ que, embora leiam os campos todos, fazem cache dos dados, sendo por isso ainda assim mais rápidos de usar quando usados múltiplas vezes com a mesma chave. Se queres apenas verificar que um registo existe, selecciona apenas um campo, e se possível aquele que estás a usar como critério, evitando assim declarares uma variável extra.</description></item><item><title>Usarás uma tabela de constantes</title><link>https://abapinho.com/2014/08/usa-uma-tabela-de-constantes/</link><pubDate>Thu, 28 Aug 2014 09:00:45 +0000</pubDate><guid>https://abapinho.com/2014/08/usa-uma-tabela-de-constantes/</guid><description>Sempre que achares que um valor que estás a usar num programa pode mudar e não o puderes tornar um parâmetro de entrada ou do ecrã de seleccção, guarda-o numa tabela de constantes (ex: ZCONSTS). Esta tabela nunca deverá ser usada directamente. Em vez disso, cria uma classe ZCL_CONSTS que aceda a ela e usa sempre esta classe para obter as tuas constantes. Como é mostrado neste artigo: Não caias na tentação de usar a T900 ou outras tabelas do género para este propósito.</description></item><item><title>Criarás e adoptarás bibliotecas de ferramentas comuns</title><link>https://abapinho.com/2014/08/cria-e-adopta-bibliotecas-de-ferramentas-comuns/</link><pubDate>Thu, 21 Aug 2014 09:00:04 +0000</pubDate><guid>https://abapinho.com/2014/08/cria-e-adopta-bibliotecas-de-ferramentas-comuns/</guid><description>Código que seja usado comummente deve estar disponível centralmente, se possível guardado em pacotes bem identificados (ex: ZFERRAMENTAS) para que seja facilmente encontrados e transportados.
Há muito código já disponível na Internet que permite executar várias funções comummente necessárias (ex: ABAP2XLSX). Adopta-o;
Para as tuas tarefas mais comuns, desenvolve ferramentas que possas reutilizar, juntando-as à biblioteca central;
Divulga a biblioteca entre os colegas do teu projecto para evitar que venham a perder tempo a criar código duplicado;</description></item><item><title>Não substituirás simplesmente ‘.’ por ‘,’</title><link>https://abapinho.com/2014/08/nao-substituiras-simplesmente-por/</link><pubDate>Fri, 08 Aug 2014 09:00:08 +0000</pubDate><guid>https://abapinho.com/2014/08/nao-substituiras-simplesmente-por/</guid><description>Se precisas de adaptar o conteúdo de um ficheiro com valores (CURR) tem sempre em consideração a parametrização do utilizador (USR01-DSCFM). Se precisares de converter um alfa-numérico num número, usa o FM MOVE_CHAR_TO_NUM. Se precisares de converter um número num alfa-numérico, usa WRITE curr TO str [CURRENCY waers].</description></item><item><title>Usarás o comando TABLES só quando inevitável</title><link>https://abapinho.com/2014/07/usaras-o-comando-tables-so-quando-inevitavel/</link><pubDate>Thu, 31 Jul 2014 09:00:20 +0000</pubDate><guid>https://abapinho.com/2014/07/usaras-o-comando-tables-so-quando-inevitavel/</guid><description>Uma das únicas situações onde é inevitável é com SELECT-OPTIONS. Em todos os outros casos, declara explicitamente uma variável local com uma estrutura equivalente. Basicamente o comando TABLES cria variáveis globais obscuras que aumentam a ambiguidade do código. E variáveis globais devem ser evitadas na maior parte dos casos.</description></item><item><title>Usarás FIELD-SYMBOLs em vez de variáveis de estrutura</title><link>https://abapinho.com/2014/07/usaras-field-symbols-em-vez-de-variaveis-de-estrutura/</link><pubDate>Thu, 24 Jul 2014 09:00:50 +0000</pubDate><guid>https://abapinho.com/2014/07/usaras-field-symbols-em-vez-de-variaveis-de-estrutura/</guid><description>READ TABLE itbl ASSIGNING é sempre mais rápido que READ TABLE itbl INTO wa. Além disso, quando precisares de alterar dados em registos de uma tabela interna, assim não precisas de usar o comando MODIFY nem da variável auxiliar que às vezes usas para guardar o SY-TABIX. A única situação em que uma variável de estrutura é aconselhada é quando queres adicionar linhas novas a uma tabela interna. Algumas pessoas defendem que as variáveis de estrutura devem ser usadas sempre que não se quiser alterar os dados da tabela interna.</description></item><item><title>Agruparás partes que estejam relacionadas</title><link>https://abapinho.com/2014/07/agruparas-partes-que-estejam-relacionadas/</link><pubDate>Thu, 17 Jul 2014 09:00:16 +0000</pubDate><guid>https://abapinho.com/2014/07/agruparas-partes-que-estejam-relacionadas/</guid><description>Às vezes encontras um IMPORT no código mas não fazes ideia onde está o EXPORT correspondente. Quando for necessário comunicar entre programas distintos, isto deverá ser feito através de um par de métodos de uma mesma classe. Assim, quando nos cruzarmos com um, conseguimos facilmente saber qual é o outro. Para implementar esta comunicação, evita utilizar EXPORT/IMPORT sempre que possível. Ao invés, usa um atributo estático da classe.</description></item><item><title>Evitarás mensagens dinâmicas</title><link>https://abapinho.com/2014/07/evitaras-mensagens-dinamicas/</link><pubDate>Thu, 10 Jul 2014 08:30:17 +0000</pubDate><guid>https://abapinho.com/2014/07/evitaras-mensagens-dinamicas/</guid><description>Quando precisares de enviar uma mensagem dinâmica por parâmetro, garante que ainda assim usas o comando MESSAGE de forma a que o “where-used” não lhe perca o rasto. Ao fazeres MESSAGE E001 INTO V_DUMMY, os detalhes da mensagem ficam disponível nas variáveis de sistema SY-MSGNO, SY-MSGTY, etc. Além disso, os textos das mensagens nunca devem ficar explicitamente definidos no programa mas sim definidos através da transacção SE91. https://abapinho.com/2009/09/evitar-mensagens-dinamicas/</description></item><item><title>Não implementarás código em user-exits</title><link>https://abapinho.com/2014/06/nao-implementaras-codigo-em-user-exits-badis-enhancements-etc/</link><pubDate>Thu, 26 Jun 2014 09:00:47 +0000</pubDate><guid>https://abapinho.com/2014/06/nao-implementaras-codigo-em-user-exits-badis-enhancements-etc/</guid><description>Todo o código que colocares em user-exits (BADIs, enhancements, SMOD, etc.) deverá ser encapsulado.
É comum incluir num user-exit múltiplas partes independentes. Cada uma destas partes deverá ser encapsulada no seu próprio método. Mesmo que seja constituída por apenas uma linha de código;
Isto deve ser aplicado tanto a implementações novas como a alterações a código existente;
A necessidade de alteração de código existente deverá ser vista sempre como uma oportunidade para reorganizar em métodos código clássico existente, uma vez que este terá necessariamente de ser testado de novo;</description></item><item><title>Não implementarás blocos de processamento clássico</title><link>https://abapinho.com/2014/06/nao-implementaras-blocos-de-processamento-classico/</link><pubDate>Thu, 19 Jun 2014 09:00:32 +0000</pubDate><guid>https://abapinho.com/2014/06/nao-implementaras-blocos-de-processamento-classico/</guid><description>Official ABAP Programming Guidelines (page 34): [Quando um bloco de processamento clássico for necessário], deves imediatamente delegar a execução para um método apropriado (ver a regra 6.37, Não implementes código dentro de Módulos de Função nem dentro de Subrotinas, e a regra 6.44, Não implementes código dentro de Módulos de Diálogo nem de Blocos de Evento).</description></item><item><title>Usarás ABAP OO sempre que possível</title><link>https://abapinho.com/2014/06/usa-abap-oo-sempre-que-possivel/</link><pubDate>Tue, 10 Jun 2014 13:14:29 +0000</pubDate><guid>https://abapinho.com/2014/06/usa-abap-oo-sempre-que-possivel/</guid><description>Deverás implementar todos os novos desenvolvimentos usando ABAP Objects excepto quando isso se reveler impossível (RFC, IN UPDATE TASK, ecrãs, etc). Quando tiverem de ser alterados, deverás também tentar converter em OO os desenvolvimentos existentes, se isso se mostrar realista. Official ABAP Programming Guidelines (página 32) regra 3.1: Usa ABAP Objects sempre que possível para desenvolvimentos novos ou existentes. Blocos de processamento clássicos podem ser criados só em casos excepcionais.</description></item></channel></rss>