Estilo de recuo - Indentation style

Para uma discussão geral sobre recuo, consulte Recuo (composição) .

Em programação de computador , um estilo de indentação é uma convenção que governa a indentação de blocos de código para transmitir a estrutura do programa. Este artigo aborda amplamente as linguagens de forma livre , como C e seus descendentes, mas pode ser (e freqüentemente é) aplicado à maioria das outras linguagens de programação (especialmente aquelas na família das chaves ), onde o espaço em branco é insignificante. O estilo de recuo é apenas um aspecto do estilo de programação .

O recuo não é um requisito da maioria das linguagens de programação, onde é usado como notação secundária . Em vez disso, o recuo ajuda a transmitir melhor a estrutura de um programa para leitores humanos. Especialmente, é usado para esclarecer a ligação entre construções de fluxo de controle , como condições ou loops, e o código contido dentro e fora deles. No entanto, algumas linguagens (como Python e occam ) usam indentação para determinar a estrutura em vez de usar colchetes ou palavras-chave; isso é denominado regra do impedimento . Nessas linguagens, o recuo é significativo para o compilador ou intérprete; é mais do que apenas uma questão de clareza ou estilo.

Este artigo usa o termo colchetes para se referir a parênteses e o termo colchetes para se referir a colchetes.

Colocação de chaves em declarações compostas

A principal diferença entre os estilos de recuo mentiras na colocação das chaves da instrução composta ( {...}) que muitas vezes segue uma instrução de controle ( if, while, for...). A tabela abaixo mostra esse posicionamento para o estilo de declarações discutido neste artigo; o estilo de declaração de função é outro caso. O estilo de colocação de chaves em instruções pode ser diferente do estilo de colocação de chaves de uma definição de função. Para consistência, a profundidade de indentação foi mantida constante em 4 espaços, independentemente da profundidade de indentação preferida de cada estilo.

Colocação da cinta Estilos 
while (x == y)
{
    something();
    somethingelse();
}
Allman 
while (x == y) {
    something();
    somethingelse();
}
K&R 
while (x == y)
  {
    something ();
    somethingelse ();
  }
GNU 
while (x == y)
    {
    something();
    somethingelse();
    }
Whitesmiths 
while (x == y)
{   something();
    somethingelse();
}
Horstmann 
while (x == y)
  { something()
  ; somethingelse()
  ;
  }
Haskell 
while (x == y)
{   something();
    somethingelse(); }
Pico 
while (x == y) {
    something();
    somethingelse();
    }
Ratliff 
while (x == y)
  { something();
    somethingelse(); }
Lisp

Tabulações, espaços e tamanho das indentações

A largura exibida para as guias pode ser definida para valores arbitrários na maioria dos editores de programação, incluindo Notepad ++ (MS-Windows), TextEdit (MacOS / X), Emacs (unix), vi (unix) e nano (unix). Além disso, esses editores podem ser configurados para gerar uma combinação de tabulações e espaços ou para converter entre tabulações e espaços, para corresponder a esquemas de recuo específicos. No Unix, a largura da tabulação também pode ser definida em pagers , como less , e convertida em tempo real por filtros, como expandir / não expandir .

Editores Unix padrão para posicionar guias em intervalos de oito colunas, enquanto ambientes Macintosh e MS-Windows padrão para quatro colunas. Essa diferença causa desalinhamento do código-fonte, quando o recuo que mistura tabulações e espaços é exibido em uma configuração que exibe tabulações de forma diferente da configuração do autor.

Há um debate contínuo entre os programadores sobre a escolha entre guias rígidas e espaços. Muitos dos primeiros programadores usavam caracteres de tabulação para recuar, para facilitar a digitação e economizar no tamanho do arquivo de origem. Alguns programadores, como Jamie Zawinski , afirmam que o uso de espaços em vez de guias aumenta a portabilidade entre plataformas . Outros, como os redatores dos padrões de codificação do WordPress , afirmam o contrário: que as guias rígidas aumentam a portabilidade. Uma pesquisa dos 400.000 principais repositórios no GitHub descobriu que os espaços são mais comuns.

O tamanho do recuo geralmente é independente do estilo. Um experimento realizado no código PASCAL em 1983, descobriu que o tamanho do recuo afetou significativamente a compreensibilidade. Tamanhos de recuo entre 2 e 4 caracteres mostraram-se ideais. Para Ruby , muitas linguagens de script de shell e algumas formas de formatação HTML , geralmente são usados ​​dois espaços por nível de indentação.

Ferramentas

Existem muitas ferramentas para converter entre estilos de indentação, como indentum programa incluído em muitos sistemas operacionais do tipo Unix .

No Emacs , vários comandos estão disponíveis para corrigir problemas de indentação automaticamente, incluindo acertar Tabem uma determinada linha (na configuração padrão). M-x indent-regionpode ser usado para indentar adequadamente grandes seções de código. Dependendo do modo, o Emacs também pode substituir espaços de recuo à esquerda com o número apropriado de tabulações seguidas por espaços, o que resulta em um número mínimo de caracteres para recuar cada linha de origem.

Elastic tabstops é um estilo de tabulação que requer suporte do editor de texto, onde blocos inteiros de texto são mantidos automaticamente alinhados quando o comprimento de uma linha no bloco muda.

Estilos

Estilo K&R

O estilo K&R (Kernighan & Ritchie Style), que também é chamado de "o verdadeiro estilo de chave" no jargão hacker (abreviado como 1TBS), é comumente usado em C, C ++ e outras linguagens de programação de chave . Foi o estilo usado no kernel Unix original, no livro de Kernighan e Ritchie, The C Programming Language , bem como no livro de Kernighan e Plauger , The Elements of Programming Style .

Ao seguir K&R, cada função tem sua chave de abertura na próxima linha no mesmo nível de recuo que seu cabeçalho, as declarações entre as chaves são recuadas e a chave de fechamento no final está no mesmo nível de recuo que o cabeçalho da função em uma linha própria.

Os blocos dentro de uma função, entretanto, têm suas chaves de abertura na mesma linha de suas respectivas instruções de controle; os colchetes de fechamento permanecem em uma linha própria, a menos que sejam seguidos por uma palavra-chave elseou while. Esses colchetes não alinhados são apelidados de "colchetes egípcios" (ou "colchetes egípcios") por sua semelhança com os braços em algumas poses fantasiosas dos antigos egípcios. 

int main(int argc, char *argv[])
{
    ...
    while (x == y) {
        something();
        somethingelse();

        if (some_error)
            do_correct();
        else
            continue_as_usual();
    }

    finalthing();
    ...
}

A linguagem de programação C não especifica explicitamente esse estilo, embora seja seguido de forma consistente ao longo do livro. Do livro:

A posição do aparelho é menos importante, embora as pessoas tenham crenças apaixonadas. Escolhemos um dos vários estilos populares. Escolha um estilo que se adapte a você e, em seguida, use-o de forma consistente.

Em versões antigas da linguagem C, os tipos de argumento precisavam ser declarados na linha subsequente (ou seja, logo após o cabeçalho da função): 

/* Original pre-ISO C style without function prototypes */
int main(argc, argv)
    int   argc;
    char  *argv[];
{
    ...
}

Variante: 1TBS (OTBS)

Os defensores desse estilo às vezes se referem a ele como "o verdadeiro estilo de chave" (abreviado como 1TBS ou OTBS). As duas principais diferenças do estilo K&R são que as funções têm seus colchetes de abertura na mesma linha separados por um espaço e que os colchetes não são omitidos para uma instrução de controle com apenas uma única instrução em seu escopo.

Neste estilo, as construções que permitem inserções de novas linhas de código estão em linhas separadas e as construções que proíbem inserções estão em uma linha. Este princípio é amplificado por contraventamento cada if, else, while, etc., incluindo condicionais de linha única, de modo que a inserção de uma nova linha de código em qualquer lugar é sempre segura (ou seja, tal inserção não fará com que o fluxo de execução discorde recuo do código-fonte).

As vantagens sugeridas deste estilo são que a chave inicial não precisa de uma linha extra sozinha; e a chave final se alinha com a instrução a que conceitualmente pertence. Um custo desse estilo é que a chave final de um bloco precisa de uma linha inteira sozinha, que pode ser parcialmente resolvida nos blocos if / else e blocos do / while: 

void checknegative(x) {
    if (x < 0) {
        puts("Negative");
    } else {
        nonnegative(x);
    }
}

Há muitas menções ao estilo The One True Brace por aí, mas há alguma confusão quanto à sua forma verdadeira. Algumas fontes dizem que é a variação especificada acima, enquanto outras a consideram apenas mais um termo do "jargão hacker" para K&R.

Variante: kernel Linux

Uma variante secundária do estilo K&R é o estilo do kernel do Linux, que é conhecido por seu uso extensivo na árvore de código do kernel do Linux . Linus Torvalds aconselha fortemente todos os contribuidores a segui-lo. O estilo empresta muitos elementos de K&R:

O estilo do kernel usa paradas de tabulação (com as paradas de tabulação definidas a cada 8 caracteres) para recuo. Abrir as chaves de uma função vai para o início da linha após o cabeçalho da função. Quaisquer outras chaves de abertura vão na mesma linha da instrução correspondente, separadas por um espaço. Os rótulos em uma switchinstrução são alinhados com o bloco delimitador (há apenas um nível de recuos). Um corpo de instrução única de uma instrução composta (como if, while e do-while) não precisa ser cercado por chaves. Se, no entanto, uma ou mais subinstruções em uma if-elseinstrução exigirem colchetes, então ambas as subinstruções devem ser colocadas entre colchetes. O comprimento da linha foi limitado por muito tempo a 80 caracteres, mas agora aumentou para 100, mas o limite original ainda é o preferido.

O estilo do kernel Linux especifica que "se apenas uma ramificação de uma instrução condicional for uma única declaração ... use colchetes em ambas as ramificações": 

int power(int x, int y)
{
	int result;

	if (y < 0) {
		result = 0;
	} else {
		result = 1;
		while (y-- > 0)
			result *= x;
	}
	return result;
}

Variante: colchetes obrigatórios

Alguns defendem chaves obrigatórias para instruções de controle com apenas uma única instrução em seu escopo, ou seja, todas as chaves if, else, while, etc., incluindo condicionais de linha única, de modo que a inserção de uma nova linha de código em qualquer lugar seja sempre segura (ou seja, , tal inserção não fará com que o fluxo de execução discorde do recuo do código-fonte).

O custo desse estilo é que uma linha completa extra é necessária para o último bloco (exceto para blocos intermediários em construções if / else if / else e blocos do / while).

Variante: Java

Embora Java às vezes seja escrito em outros estilos, um corpo significativo de código Java usa uma variante secundária do estilo K&R em que a chave de abertura está na mesma linha não apenas para os blocos dentro de uma função, mas também para declarações de classe ou método. Esse estilo é amplamente difundido porque os guias de estilo original da Sun Microsystems usavam essa variante K&R e, como resultado, a maior parte do código-fonte padrão para a API Java é escrita neste estilo. É também um estilo de recuo popular para ActionScript e JavaScript , junto com o estilo Allman .

Variante: Stroustrup

O estilo Stroustrup é a adaptação de Bjarne Stroustrup do estilo K&R para C ++, conforme usado em seus livros, como Programação: Princípios e Prática usando C ++ e A Linguagem de Programação C ++ .

Ao contrário das variantes acima, Stroustrup não usa um “outro aninhado”. Assim, Stroustrup escreveria 

    if (x < 0) {
        puts("Negative");
        negative(x);
    }
    else {
        puts("Non-negative");
        nonnegative(x);
    }

Stroustrup estende o estilo K&R para as aulas, escrevendo-as da seguinte maneira: 

    class Vector {
    public:
        Vector(int s) :elem(new double[s]), sz(s) { }   // construct a Vector
        double& operator[](int i) { return elem[i]; }   // element access: subscripting
        int size() { return sz; }
    private:
        double * elem;    // pointer to the elements
        int sz;           // number of elements
    };

Stroustrup não recua os rótulos public:e private:. Além disso, neste estilo, enquanto a chave de abertura de uma função começa em uma nova linha, a chave de abertura de uma classe está na mesma linha que o nome da classe.

Stroustrup permite escrever funções curtas todas em uma linha. O estilo Stroustrup é um estilo de indentação nomeado disponível no editor Emacs . Stroustrup incentiva um layout de estilo derivado de K&R com C ++ conforme declarado em suas modernas Diretrizes Básicas de C ++ .

Variante: BSD KNF

Também denominado Kernel Normal Form , é o formato da maior parte do código usado nos sistemas operacionais Berkeley Software Distribution (BSD). Embora principalmente destinado ao código do kernel, também é amplamente usado no código do ambiente do usuário . É essencialmente uma variante completamente documentada do estilo K&R como usado no código-fonte do Unix Bell Labs Versão 6 e 7 .

O kernel SunOS e a área de usuário usam um estilo de indentação semelhante. Como o KNF, isso também foi baseado em documentos do estilo da AT&T e às vezes é denominado Forma Normal de Bill Joy. A diretriz SunOS foi publicada em 1996; ANSI C é discutido brevemente. A correção da indentação de uma lista de arquivos de origem pode ser verificada pelo programa cstyle escrito por Bill Shannon.

Nesse estilo, o tabulador rígido (ts em vi ) é mantido em oito colunas, enquanto um tabulador flexível também é frequentemente definido como um auxiliar (sw em vi) e definido em quatro. Os tabuladores rígidos são usados ​​para indentar blocos de código, enquanto um tabulador flexível (quatro espaços) de indentação adicional é usado para todas as linhas contínuas que devem ser divididas em várias linhas.

Além disso, chamadas de função não use um espaço antes do parêntese, embora declarações nativas linguagem C, como if, while, do, switche returnfazer (no caso em que returné utilizado com parênteses). As funções que não declaram nenhuma variável local em seu bloco de nível superior também devem deixar uma linha em branco após a chave de abertura do bloco.

Aqui estão alguns exemplos: 

while (x == y) {
        something();
        somethingelse();
}
finalthing();

  

if (data != NULL && res > 0) {
        if (JS_DefineProperty(cx, o, "data",
            STRING_TO_JSVAL(JS_NewStringCopyN(cx, data, res)),
            NULL, NULL, JSPROP_ENUMERATE) != 0) {
                QUEUE_EXCEPTION("Internal error!");
                goto err;
        }
        PQfreemem(data);
} else {
        if (JS_DefineProperty(cx, o, "data", OBJECT_TO_JSVAL(NULL),
            NULL, NULL, JSPROP_ENUMERATE) != 0) {
                QUEUE_EXCEPTION("Internal error!");
                goto err;
        }
}

  

static JSBool
pgresult_constructor(JSContext *cx, JSObject *obj, uintN argc,
    jsval *argv, jsval *rval)
{

        QUEUE_EXCEPTION("PGresult class not user-instantiable");

        return (JS_FALSE);
}

Estilo Allman

O estilo Allman tem o nome de Eric Allman . Também é algumas vezes denominado estilo BSD, uma vez que Allman escreveu muitos dos utilitários para BSD Unix (embora isso não deva ser confundido com o diferente "estilo BSD KNF"; veja acima).

Este estilo coloca a chave associada a uma instrução de controle na próxima linha, recuada no mesmo nível da instrução de controle. As declarações entre colchetes são recuadas para o próximo nível. 

while (x == y)
{
    something();
    somethingelse();
}

finalthing();

Este estilo é semelhante ao recuo padrão usado pelas linguagens Pascal e Transact-SQL , onde as chaves são equivalentes às palavras begin- chave e end. 

(* Example Allman code indentation style in Pascal *)
procedure dosomething(x, y: Integer);
begin
    while x = y do
    begin
        something();
        somethingelse();
    end;
end;

As consequências desse estilo são que o código recuado é claramente separado da instrução contida por linhas que são quase todas espaços em branco e a chave de fechamento se alinha na mesma coluna da chave de abertura. Algumas pessoas acham que isso facilita a localização de aparelhos correspondentes. O estilo de bloqueio também delineia o bloco de código da instrução de controle associada. Comentar ou remover uma instrução de controle ou bloco de código, ou refatoração de código , são menos propensos a introduzir erros de sintaxe por meio de chaves pendentes ou ausentes. Além disso, é consistente com a colocação da chave para o bloco de função externa.

Por exemplo, o seguinte ainda está correto sintaticamente: 

// while (x == y)
{
    something();
    somethingelse();
}

Como é isso: 

// for (int i=0; i < x; i++)
// while (x == y)
if (x == y)
{
    something();
    somethingelse();
}

Mesmo assim, com compilação condicional: 

    int c;
#ifdef HAS_GETCH
    while ((c = getch()) != EOF)
#else
    while ((c = getchar()) != EOF)
#endif
    {
        do_something(c);
    }

Variante: Allman-8

Uma variante popular para uso na educação, Allman-8 usa as guias de recuo de 8 espaços e o limite de 80 colunas da variante do kernel do Linux de K&R. O estilo supostamente ajuda a melhorar a legibilidade em projetores. Além disso, o tamanho do recuo e a restrição da coluna ajudam a criar uma dica visual para identificar aninhamento excessivo de blocos de código. Essas vantagens se combinam para ajudar a fornecer aos desenvolvedores e alunos orientação implícita para gerenciar a complexidade do código.

Estilo whitesmiths

O estilo Whitesmiths, às vezes também denominado de estilo Wishart, foi originalmente usado na documentação do primeiro compilador C comercial, o Compilador Whitesmiths . Também foi popular nos primeiros dias do Windows, uma vez que foi usado em três livros influentes de programação do Windows, Programmer's Guide to Windows de Durant , Carlson & Yao , Programming Windows de Petzold e Windows 3.0 Power Programming Techniques de Norton & Yao.

Whitesmiths, junto com Allman , têm sido os estilos de órtese mais comuns com igual popularidade de acordo com o Jargon File .

Este estilo coloca a chave associada a uma instrução de controle na próxima linha, recuada. As declarações entre colchetes são recuadas no mesmo nível que os colchetes. 

while (x == y)
    {
    something();
    somethingelse();
    }

finalthing();

As vantagens deste estilo são semelhantes às do estilo Allman . Os blocos são claramente separados das instruções de controle. O alinhamento das chaves com o bloco enfatiza que o bloco completo é conceitual e programaticamente, uma instrução composta. O recuo das chaves enfatiza que elas estão subordinadas à instrução de controle. A chave de fechamento não se alinha mais com a declaração, mas sim com a chave de abertura.

Um exemplo: 

if (data != NULL && res > 0)
    {
    if (!JS_DefineProperty(cx, o, "data", STRING_TO_JSVAL(JS_NewStringCopyN(cx, data, res)), NULL, NULL, JSPROP_ENUMERATE))
        {
        QUEUE_EXCEPTION("Internal error!");
        goto err;
        }
    PQfreemem(data);
    }
else if (!JS_DefineProperty(cx, o, "data", OBJECT_TO_JSVAL(NULL), NULL, NULL, JSPROP_ENUMERATE))
    {
    QUEUE_EXCEPTION("Internal error!");
    goto err;
    }

else ifsão tratados como instruções, bem como as #elifinstruções do pré - processador.

Estilo GNU

Artigo principal: padrões de codificação GNU

Como os estilos Allman e Whitesmiths , o estilo GNU coloca colchetes em uma linha por si só, recuados por dois espaços, exceto ao abrir uma definição de função, onde eles não são recuados. Em ambos os casos, o código contido é recuado por dois espaços entre colchetes.

Popularizado por Richard Stallman , o layout pode ser influenciado por seu histórico de escrita de código Lisp . Em Lisp, o equivalente a um bloco (um progn) é uma entidade de dados de primeira classe, e dar a ela seu próprio nível de indentação ajuda a enfatizar que, enquanto em C, um bloco é apenas sintaxe. Este estilo também pode ser encontrado em alguns livros de linguagem de programação ALGOL e XPL das décadas de 1960 e 1970. Embora não esteja diretamente relacionado à indentação, o estilo de codificação GNU também inclui um espaço antes da lista de argumentos entre colchetes para uma função. 

static char *
concat (char *s1, char *s2)
{
  while (x == y)
    {
      something ();
      somethingelse ();
    }
  finalthing ();
}

Este estilo combina as vantagens de Allman e Whitesmiths , eliminando assim a possível desvantagem de Whitesmiths de chaves não se destacando do bloco. Uma desvantagem é que a chave final não se alinha mais com a instrução a que conceitualmente pertence. Outra possível desvantagem é que pode desperdiçar espaço usando dois níveis visuais de indentação para um nível conceitual, mas na realidade isso é improvável porque, em sistemas com indentação de nível único, cada nível geralmente tem pelo menos 4 espaços, o mesmo que 2 * 2 espaços em estilo GNU.

Os padrões de codificação GNU recomendam este estilo, e quase todos os mantenedores do software de projeto GNU o usam.

O editor de texto GNU Emacs e o comando indent dos sistemas GNU irão reformatar o código de acordo com este estilo por padrão. Aqueles que não usam GNU Emacs, ou editores similarmente extensíveis / personalizáveis, podem achar que as configurações de indentação automática de seu editor são inúteis para este estilo. No entanto, muitos editores que adotam o estilo KNF como padrão lidam bem com o estilo GNU quando a largura da tabulação é definida para dois espaços; da mesma forma, o GNU Emacs se adapta bem ao estilo KNF simplesmente definindo a largura da guia para oito espaços. Em ambos os casos, a reformatação automática destrói o espaçamento original, mas o recuo automático de linha funcionará corretamente.

Steve McConnell , em seu livro Code Complete , desaconselha o uso desse estilo: ele marca um exemplo de código que o usa com um ícone "Coding Horror", simbolizando um código especialmente perigoso, e afirma que isso impede a legibilidade. A documentação do estilo de codificação do kernel do Linux também recomenda fortemente contra este estilo, incitando os leitores a gravar uma cópia dos padrões de codificação GNU como um "grande gesto simbólico".

Estilo Horstmann

A edição de 1997 de Computing Concepts with C ++ Essentials de Cay S. Horstmann adapta Allman colocando a primeira declaração de um bloco na mesma linha da chave de abertura. Este estilo também é usado em exemplos no Manual e Relatório do Usuário Pascal de Jensen e Wirth . 

while (x == y)
{   something();
    somethingelse();
    //...
    if (x < 0)
    {   printf("Negative");
        negative(x);
    }
    else
    {   printf("Non-negative");
        nonnegative(x);
    }
}
finalthing();

Este estilo combina as vantagens de Allman ao manter o alinhamento vertical dos colchetes para facilitar a leitura e identificar blocos facilmente, com o salvamento de uma linha do estilo K&R. No entanto, a edição de 2003 agora usa todo o estilo Allman.

Estilo pico

Este é o estilo mais utilizado na linguagem Pico pelos seus designers. O Pico não tem instruções de retorno e usa ponto-e-vírgula como separadores de instrução em vez de terminadores. Ele produz esta sintaxe: 

stuff(n):
{ x: 3 * n;
  y: doStuff(x);
  y + x }

As vantagens e desvantagens são semelhantes às de salvar o espaço da tela com o estilo K&R. Uma vantagem adicional é que as chaves de início e de fechamento são consistentes no aplicativo (ambas compartilham espaço com uma linha de código), em relação ao estilo K&R, onde uma chave compartilha espaço com uma linha de código e uma chave tem uma linha sozinha.

Estilo Ratliff

No livro Programmers at Work , C. Wayne Ratliff discutiu o uso do estilo abaixo. O estilo começa muito como 1TBS, mas a chave de fechamento se alinha com o recuo do bloco aninhado. Ratliff foi o programador original por trás das populares linguagens de programação de quarta geração dBase -II e -III . Ele indicou que foi originalmente documentado em material da Digital Research Inc. Esse estilo às vezes foi denominado estilo de banner , possivelmente pela semelhança com um banner pendurado em um mastro. Nesse estilo, que é para Whitesmiths como K&R para Allman, o controle de fechamento é recuado como o último item da lista (e, portanto, perde adequadamente a saliência). O estilo pode tornar a varredura visual mais fácil para alguns, uma vez que os cabeçalhos de qualquer bloco são a única coisa exdentada naquele nível (a teoria é que o controle de fechamento do bloco anterior interfere com o fluxo visual do próximo cabeçalho do bloco no K&R e Estilos Allman). Kernighan e Plauger usam este estilo no código Ratfor em Ferramentas de Software . 

 // In C
 for (i = 0; i < 10; i++) {
     if (i % 2 == 0) {
         doSomething(i);
         }
     else {
         doSomethingElse(i);
         }
     }

ou, em uma linguagem de marcação ... 

{|
|-
| lots of stuff...
      more stuff
      || alternative for short lines || etc. 
|}

{|
|-
... etc
|}

Estilo Lisp

Um programador pode ir tão longe a ponto de inserir colchetes de fechamento na última linha de um bloco. Esse estilo torna o recuo a única maneira de distinguir blocos de código, mas tem a vantagem de não conter linhas não informativas. Isso poderia ser facilmente chamado de estilo Lisp (porque esse estilo é muito comum no código Lisp) ou estilo Python (Python não tem colchetes, mas o layout é muito semelhante, conforme mostrado nos blocos de código abaixo). Em Python, o layout é uma parte da linguagem, chamada de regra externa . 

// In C
for (i = 0; i < 10; i++)
    {if (i % 2 == 0)
        {doSomething(i);}
     else
        {doSomethingElse(i);
         doThirdThing(i);}}

  

# In Python
for i in range(10):
    if i % 2 == 0:
        do_something(i)
    else:
        do_something_else(i)
        do_third_thing(i)

  

;; In Lisp
(dotimes (i 10)
    (if (= (rem i 2) 0)
        (do-something i)
        (progn
            (do-something-else i)
            (do-third-thing i))))

Estilo Haskell

O layout Haskell pode tornar opcional a colocação de colchetes, embora colchetes e pontos-e-vírgulas sejam permitidos no idioma. Os dois segmentos abaixo são igualmente aceitáveis ​​para o compilador: 

braceless = do
  text <- getContents
  let
    firstWord = head $ words text
    bigWord = map toUpper firstWord
  putStrLn bigWord

braceful = do
  { text <- getContents
  ; let
      { firstWord = head $ words text
      ; bigWord = map toUpper firstWord
      }
  ; putStrLn bigWord
  }

Em Haskell, o layout pode substituir os colchetes. Normalmente, as chaves e pontos-e-vírgulas são omitidos para seções procedurais do e o texto do programa em geral, mas o estilo é comumente usado para listas, registros e outros elementos sintáticos compostos de algum par de parênteses ou chaves, que são separados por vírgulas ou ponto-e-vírgulas. Se o código após as palavras-chave where, letou ofomitir colchetes e pontos-e-vírgulas, o recuo é significativo.

Outras considerações

Perdendo o controle de blocos

Em algumas situações, existe o risco de perder o controle dos limites do bloco. Isso geralmente é visto em grandes seções de código que contêm muitas instruções compostas aninhadas em vários níveis de indentações. No momento em que o programador rola até o final de um grande conjunto de instruções aninhadas, ele pode ter perdido o controle de quais instruções de controle vão para onde. No entanto, um código muito longo pode ter outras causas, como ser muito complexo , e um programador que enfrente esse problema pode, em vez disso, considerar se a refatoração de código ajudaria a longo prazo.

Os programadores que contam com a contagem das chaves de abertura podem ter dificuldade com estilos de indentação, como K&R, em que a chave de início não está visualmente separada de sua instrução de controle . Os programadores que confiam mais em indentações ganharão mais com estilos verticalmente compactos, como K&R, porque os blocos são mais curtos.

Para evitar perder o controle de instruções de controle, como for, um grande recuo pode ser usado, como uma guia rígida de 8 unidades de largura, junto com a divisão de funções grandes em funções menores e mais legíveis. O Linux é feito desta forma, usando o estilo K&R.

Nos editores de texto da família vi , um meio de rastrear os limites do bloco é posicionar o cursor do texto sobre um dos colchetes e pressionar a %tecla. O cursor então salta para a chave oposta. Uma vez que a nexttecla do cursor de texto (a saber, a ntecla) retém as informações de posicionamento direcional (se a tecla upou downfoi pressionada anteriormente), a macro de ponto (a .tecla) pode então ser usada para colocar o cursor de texto na próxima chave, dado um adequado estilo de codificação. Em vez disso, a inspeção dos limites do bloco usando a %chave pode ser usada para impor um padrão de codificação.

Outra maneira é usar comentários embutidos adicionados após a chave de fechamento: 

for (int i = 0; i < total; i++) {
    foo(bar);
} //for (i)

if (x < 0) {
   bar(foo);
} //if (x < 0)

A principal desvantagem desse método é manter o código duplicado em vários locais.

Outra solução é implementada em um editor dobrável , que pode ocultar ou revelar blocos de código por meio de seu nível de indentação ou estrutura de instrução composta. Muitos editores também destacam os colchetes ou colchetes correspondentes quando o cursor é posicionado próximo a um deles.

Inserção de extrato

O estilo K&R evita outro erro comum sofrido ao usar o editor de linha Unix padrão , ed . Uma instrução inserida por engano entre a instrução de controle e a chave de abertura do bloco de loop transforma o corpo do loop em uma única viagem. 

for (int i = 0; i < 10; i++)
    whoops(bar);   /* repeated 10 times, with i from 0 to 9 */
{
    only_once();   /* Programmer intended this to be done 10 times */
} //for (i) ← This comment is no longer valid, and is very misleading!

O estilo K&R evita esse problema, mantendo a instrução de controle e a chave de abertura na mesma linha.

Veja também

Referências

links externos

Tabulações e espaços