Padrões de Nomenclatura e
Codificação de Software
v.1.0
Índice
Introdução.............................................................................................................................. 3
1. Estilos de Capitalização...................................................................................................... 4
1.1. Pascal Case.................................................................................................................. 4
1.2. Camel Case.................................................................................................................. 4
1.3. Upper Case................................................................................................................... 4
2. Padrão de Nomenclatura.................................................................................................... 4
2.1. Classes......................................................................................................................... 5
2.2. Objeto de Classes......................................................................................................... 5
2.3. Interfaces..................................................................................................................... 5
2.4. Objeto de Interfaces..................................................................................................... 5
2.5. Parâmetros................................................................................................................... 6
2.6. Constantes................................................................................................................... 6
2.7. Numeradores................................................................................................................ 6
2.8. Variáveis....................................................................................................................... 6
2.9. Propriedades................................................................................................................ 7
2.10. Métodos...................................................................................................................... 7
2.11. Nome para Arquivos (Units)........................................................................................ 7
2.12. Nome para Objetos de Interface................................................................................. 7
3. Endentação......................................................................................................................... 8
3.1. Quebras de Linha......................................................................................................... 8
3.2. Espaços em Branco...................................................................................................... 9
3.3. Expressão if................................................................................................................ 10
3.4. Expressão for.............................................................................................................. 10
3.5. Expressão while.......................................................................................................... 11
3.6. Expressão repeat........................................................................................................ 11
3.7. Expressão with........................................................................................................... 11
3.8. Expressão case........................................................................................................... 12
3.9. Expressão try.............................................................................................................. 13
3.10. Expressões Simples.................................................................................................. 13
4. Comentários..................................................................................................................... 14
4.1. Cabeçalho de Arquivos............................................................................................... 14
4.2. Cabeçalho de Métodos............................................................................................... 14
5. Referência Bibliográfica.................................................................................................... 15
2
Introdução
A organização do código fonte facilita os processos de desenvolvimento, retirada de bugs e
erros, atividades de validação e manutenção. O uso de um padrão de codificação também
aumenta a produtividade num projeto, uma vez que a comunicação dentro da equipe de
desenvolvimento fica mais fácil, mas vale ressaltar que partes desses padrões são vistar,
algumas vezes, como sugestões por empresas que adotam seus próprios padrões.
Este manual tem por finalidade definir padrões de desenvolvimento, no que diz respeito a
nomenclatura e melhores práticas, aos elementos a serem utilizados nos projetos que
utilizarem linguagem Delphi e Object Pascal.
3
1. Estilos de Capitalização
Existem três tipos de convenções de nomenclatura: Pascal Case, Camel Case e Upper
Case. Em todas as convenções se refere ao uso de maiúsculas ou minúsculas nos nomes.
1.1. Pascal Case
A primeira letra do identificador e as primeiras letras das palavras subsequentes são
maiúsculas.
Exemplo:
BackColor
1.2. Camel Case
A primeira letra da primeira palavra é em minúscula, e as demais palavras subsequentes
iniciam com maiúscula.
Exemplo:
backColor
1.3. Upper Case
Todas as letras são maiúsculas. Usada somente para constantes.
Exemplo:
CHAVE_CRIPTOGRAFIA = String(‘#F$%a&DH’);
2. Padrão de Nomenclatura
Nomear corretamente objetos, componentes, arquivos, pastas, enfim, elementos em geral
é muito importante para um bom entendimento do projeto como um todo. Um simples
arquivo nomeado errado, ou sem um padrão definido, pode confundir e prejudicar uma
futura manutenção. Portanto, questões importantes devem ser consideradas na
nomenclatura do projeto:
• Não utilize notação húngara. A notação é útil somente para nomear
componentes e, mesmo assim, quando existe a necessidade de
identificação facilitada do mesmo;
• Coloque nomes da forma mais clara possível, visando facilitar a compreensão da
finalidade;
• Em nomes compostos, faça combinações entre caracteres maiúsculos e minúsculos
para Pascal Case;
• Utilize abreviações com responsabilidade, e conforme a necessidade;
• Utilize nomes em português;
• Não utilize espaços, acentos, cedilhas, sublinhas ou caracteres especiais, mesmo que
o contexto do que está sendo nomeado permita.
4
2.1. Classes
• Nomeie com nomes substantivos que descrevem o seu comportamento;
• O nome da classe deve ser iniciada pela letra T (t) maiúscula acompanhada pelo
nome da classe no singular seguindo o padrão Pascal Case.
• Não use o caractere de sublinha (_).
Exemplo:
TPessoa
TPessoaFisica
TProduto
2.2. Objeto de Classes
• Nomeie com nomes substantivos dando preferencia a utilizar o mesmo nome da
classe;
• Não use o caractere de sublinha (_).
Exemplo:
Pessoa
PessoaFisica
Produto
2.3. Interfaces
• Nomeie com nomes substantivos ou adjetivos que descrevem o seu comportamento;
• O nome da interface deve ser iniciada pela letra I (i) maiúscula acompanhada pelo
nome da interface no singular seguindo o padrão Pascal Case;
• Nomeie interfaces com substantivos ou adjetivos que descrevem o seu
comportamento;
• Não use o caractere de sublinha (_).
Exemplo:
IPessoa
IProduto
• Use nomes similares quando definir pares de classes/interfaces, onde a classe é uma
implementação padrão das interfaces. O nome deve diferir apenas com a letra I e T,
que é o prefixo do nome da interface e da classe respectivamente.
Exemplo:
IPessoa = Interface
TPessoa = class(TInterfaceObject, IPessoa)
2.4. Objeto de Interfaces
• Nomeie com nomes substantivos ou adjetivos dando preferencia a utilizar o mesmo
nome da classe;
• Não use o caractere de sublinha (_).
Exemplo:
Pessoa
Produto
5
2.5. Parâmetros
• O nome de um parâmetro deve ser iniciada pela letra A (a) maiúscula acompanhada
pelo nome do parâmetro seguindo o padrão Pascal Case;
• Use nomes descritivos para que se possa, baseado no nome do parâmetro e seu tipo,
determinar o que o parâmetro significa;
• Use nomes baseados no significado do parâmetro e não no seu tipo.
• Não use o caractere de sublinha (_).
Exemplo:
procedure Form1.FormataNumero(AValor: Integer);
2.6. Constantes
• Utilizar nomes que descrevam claramente sua funcionalidade seguindo o padrão
Upper Case;
• Use o caractere de sublinha (_) para melhorar a interpretação de sua função.
Exemplo:
CHAVE_CRIPTOGRAFIA = String(‘#F$%a&DH’);
2.7. Numeradores
Utilizar nome que descreva sua funcionalidade ou ação com um prefixo de dois caracteres
que identifique o tipo enumerado seguindo o padrão Camel Case.
Exemplo:
TStatus = (stAberto, stFechado);
2.8. Variáveis
• Nomeie com nomes substantivos que descrevem o seu comportamento seguindo o
padrão Pascal Case;
• Quando for variável declarada na classe ou interface (fields) deve ser iniciada pela
letra F (f) maiúscula acompanhada pelo nome da variável;
• Não use o caractere de sublinha (_).
Exemplo:
No escopo de uma classe ou interface
FNomeUsuario: String;
FSenhaUsuario: String;
Em um método
NomeUsuario: String;
SenhaUsuario: String;
2.9. Propriedades
• O nome da propriedade deve ter o mesmo nome da variável que ela representará
seguindo o padrão Pascal Case;
• Não use o caractere de sublinha (_).
6
Exemplo:
property NomeUsuario: String read FNomeUsuario write FNomeUsuario;
2.10.Métodos
Os métodos devem ter nomes de verbos no imperativo e seguir o padrão Pascal Case;
Não use o caractere de sublinha (_).
Exemplo:
procedure GravarUsuario();
function CalcularSalario(): Currency;
2.11.Nome para Arquivos (Units)
• Para formatar nome dos arquivos deve seguir o padrão Pascal Case, utilize o nome
do projeto ou módulo, o nome da camada, o nome da funcionalidade e o tipo da
funcionalidade;
• Utilize o caractere ponto (.) para separar os nomes e funcionalidades.
Exemplo:
Financeiro.Model.Categoria.pas
Financeiro.View.Categoria.Cadastro.pas
Financeiro.view.Categoria.Consulta.pas
Financeiro.Controller.Categoria.pas
2.12.Nome para Objetos de Interface
•Deve ser utilizado abreviações que possam identificar o objeto como um prefixo com
três caracteres do alfabeto mais o nome do objeto seguindo o padrão Camel Case;
Exemplos:
FrmCategoriaCadastro No caso de um Formulário
FrmCategoriaConsulta No caso de um Formulário
DmdPrincipal No caso de um DataModule
DmdCategoria No caso de um DataModule
QryCategoriaCadastro No caso de um TQuery
BtnGravar No caso de um TButton
LblDescricao No caso de um TLabel
AclMenu No caso de um TActionList
ActSair No caso de um TAction
7
3. Endentação
A endentação citada é sobre o número de espaços entre os níveis de tabulação. Utilize
como padrão 2 espaços. Este padrão normalmente pode ser configurado na própria IDE.
Evite escrever linhas com mais de 80 posições entre espaços e caracteres. A ideia é
facilitar a compreensão do código e, se possível, visualizar a linha inteira em seu editor de
código.
Observação:
As palavras reservadas program, unit, interface, uses, type, var, implementation,
initialization, finalization e end não podem ser indentadas.
3.1. Quebras de Linha
Caso alguns trechos de código fiquem muito extensos, poderá ser feita a quebra de linha,
entretanto é necessário seguir os seguintes princípios:
• Quebrar a linha após uma vírgula;
• Quebrar a linha após um operador;
• Alinhar a nova linha no subnível do nível da expressão para que a expressão receba
maior destaque.
Exemplo:
//CORRETO
function CreateWindowEx(dwExStyle: DWORD; lpClassName: Pchar;
lbWindowName: Pchar; dwStyle:DWORD; X, Y, nWidth, nHeight: Integer;
hwndParent: HWND; hMenu: HMENU; hInstance: HINST;
LpParam: Pointer): HWND; stdcall;
if ((X = Y) or (Y = X) or
(Z = P) or (F = J)) then
begin
S := J;
end;
8
3.2. Espaços em Branco
Os espaços em branco, assim como as linhas, ajudam na legibilidade do código, mas
existem as exceções:
procedure CalcularSalario(IdFuncionario: Integer); //CORRETO
procedure CalcularSalario (IdFuncionario: Integer); //INCORRETO
procedure CalcularSalario( IdFuncionario: Integer); //INCORRETO
procedure CalcularSalario(IdFuncionario: Integer ); //INCORRETO
procedure CalcularSalario( IdFuncionario: Integer ); //INCORRETO
• Após um colchete de abertura ou antes de um colchete de fechamento
Valor := Matriz[I]; //CORRETO
Valor := Matriz[ I]; //INCORRETO
Valor := Matriz[I ]; //INCORRETO
Valor := Matriz[ I ]; //INCORRETO
• Entre um operador unário (+ ou -) e o seu operando:
Valor := -1; //CORRETO
Valor := - 1; //INCORRETO
• Antes ou depois de um operador ponto (.)
btnGravar.Caption := ‘Gravar’; //CORRETO
btnGravar. Caption := ‘Gravar’; //INCORRETO
btnGravar .Caption := ‘Gravar’; //INCORRETO
btnGravar . Caption := ‘Gravar’; //INCORRETO
• Antes de uma vírgula
Variavel1, Variavel2: Integer; //CORRETO
Variavel1 , Variavel2: Integer; //INCORRETO
• Antes de dois pontos
Variavel1, Variavel2: Integer; //CORRETO
Variavel1, Variavel2 : Integer; //INCORRETO
• Antes de ponto e vírgula
Variavel1, Variavel2: Integer; //CORRETO
Variavel1, Variavel2: Integer ; //INCORRETO
9
3.3. Expressão if
As expressões if devem aparecer em pelo menos duas linhas.
Exemplo:
//CORRETO //CORRETO
if Teste then if Teste then
Valor := 10; begin
Valor := 10;
//CORRETO end
if not Teste then eles
begin begin
Valor1 := 10; Valor := 20;
Valor2 := 20; end;
end;
//INCORRETO
//CORRETO if Teste then Valor := 10;
if Teste then
Valor := 10 //INCORRETO
else if not Teste then begin
Valor := 20; Valor1 := 10;
Valor2 := 20;
//CORRETO end;
if Teste then
begin //INCORRETO
Valor := 10; if Teste then
end Valor := 10
else else Valor := 20;
Valor := 20;
3.4. Expressão for
//INCORRETO //CORRETO
for I := 0 to 10 do begin for I := 0 to 10 do
DoSomething; begin
DoSomethingElse; DoSomething;
end; DoSomethingElse;
end;
10
3.5. Expressão while
//INCORRETO //CORRETO
for I := 0 to 10 do begin for I := 0 to 10 do
DoSomething; begin
DoSomethingElse; DoSomething;
end; DoSomethingElse;
end;
3.6. Expressão repeat
//CORRETO
repeat
X := J;
J := UpdateValue;
until J > 25;
3.7. Expressão with
//CORRETO
With Tabela do
begin
Append;
FieldByName(‘Nome’).AsString := ‘Jóse’;
Post;
end;
11
3.8. Expressão case
//CORRETO
case Control.Align of
alLeft, alNone: NewRange := Max(NewRange, Position);
AlRight: Inc(AlignMargin, Control.Width);
end;
//CORRETO
case Status of
stStart:
begin
J := UpdateValue;
end;
stBegin: X := J;
stTimeOut:
begin
J := X;
X := UpdateValue;
end;
//CORRETO
case ScrollCode of
0..5:
begin
Valor := Controle * 3;
Inc(Count);
end;
6..9:
begin
Valor := Controle * 2;
Inc(Count);
end;
10: Inc(Count);
else
Count := 0;
Valor := 0;
end;
12
3.9. Expressão try
//CORRECT
try
try
EnumThreadWindows(CurrentThreadID, @Disable, 0);
Result := TaskWindowList;
except
EnableTaskWindows(TaskWindowList);
raise;
end;
finally
TaskWindowList := SaveWindowList;
TaskActiveWindow := SalveActiveWindow;
end;
3.10.Expressões Simples
Utilize uma expressão por linha.
Exemplo:
A := B + C; Inc(Count); //INCORRETO
A := B + C; //CORRETO
Inc(Count); //CORRETO
13
4. Comentários
Os comentários são muito importantes, tanto para relembrar você como para orientar outra
pessoa sobre a manutenção do código fonte. Mas precisa ter o cuidado de não exagerar o
que pode tornar a legibilidade do código extensa e tediosa.
Lembrando que um código bem feito utilizando as boas práticas, praticamente não será
necessário a utilização de comentários. Mas se for utilizar, utilize da seguinte forma:
Utilize as duas barras “//” para comentar apenas uma linha;
Utilize “{}” somente para comentar blocos;
Utilize “(**)” para comentar blocos onde seu conteúdo já contenha algum comentário.
4.1. Cabeçalho de Arquivos
Comentários de cabeçalho são importantes para saber quem foi o responsável pelo
desenvolvimento e as alterações aplicadas na unit. Portanto:
• Descreva o propósito da unit;
• Coloque o nome do programador responsável pelo desenvolvimento inicial da unit;
• Coloque o nome do analista responsável;
• O item Revisões será utilizado quando for feita uma manutenção na unit;
Exemplo:
{**************************************************************************
Propósito: Biblioteca de funções para String
Programador: Fulano de Tal Data: 00/00/0000
Analista: Beltrano Note
Revisão:
Data: 00/00/0000
Programador: Exemplório Ali
Descrição: Correção de bug no método anti-bug
**************************************************************************}
4.2. Cabeçalho de Métodos
Ao descrever o cabeçalho de um método, não seja detalhista, tente ser objetivo em seu
comentário e comente sobre os parâmetros, caso hajam.
Exemplo:
{**************************************************************************
Propósito: Exibindo uma mensagem de pergunta utilizando o MessageBox
Parâmetros:
ATitulo = Título da mensagem (Caption)
AMensagem = Mensagem que irá aparecer no corpo do MessageBox
Result = Retorna True ou False
Autor: Fulano de Tal
**************************************************************************}
class function TForm1.Pergunta(const ATilulo, AMensagem: String): Boolean;
14
5. Referência Bibliográfica
Links:
http://edn.embarcadero.com/article/10280#6.1
http://www.planetadelphi.com.br/artigo/123/ciclo-metodol%C3%B3gico-para-
desenvolvimento-delphi-for-win-32-parte-1
https://www.devmedia.com.br/padroes-de-codificacao/16529
15
