Exercício – Usar espaços em branco para facilitar a leitura do código

10 minutos

Os designers de impressão e da Web entendem que colocar muitas informações em um espaço pequeno sobrecarrega o visualizador. Portanto, eles usam estrategicamente o espaço em branco, ou espaços negativos, para dividir as informações a fim de maximizar a capacidade do visualizador de consumir a mensagem principal do próprio trabalho.

Os desenvolvedores podem usar uma estratégia semelhante ao escrever código em um editor. Ao usar o espaço em branco para transmitir significado, os desenvolvedores podem aumentar a clareza da intenção do código que escrevem.

O que é espaço em branco?

O termo "espaço em branco" refere-se a espaços individuais produzidos pelo space bar, guias produzidas pela tecla tab e novas linhas produzidas pela tecla enter.

O compilador C# ignora o espaço em branco. Para entender que os espaços em branco são ignorados e como podem melhorar a clareza do código, faça o exercício a seguir.

Adicionar código para ilustrar como o espaço em branco é ignorado pelo compilador do C#

Verifique se você tem o arquivo Program.cs vazio aberto no Visual Studio Code.

Se necessário, abra o Visual Studio Code e conclua as seguintes etapas para preparar o arquivo Program.cs no Editor:
1. No menu Arquivo , selecione Abrir Pasta.
2. Use a caixa de diálogo Abrir Pasta para navegar e, em seguida, abrir a pasta CsharpProjects .
3. No modo de exibição explorador do Visual Studio Code, selecione Program.cs.
4. No menu Seleção do Visual Studio Code, selecione Selecionar Tudo e pressione a tecla Delete.

Insira o seguinte código:

// Example 1:
Console
.
WriteLine
(
"Hello Example 1!"
)
;

// Example 2:
string firstWord="Hello";string lastWord="Example 2";Console.WriteLine(firstWord+" "+lastWord+"!");

No menu Arquivo do Visual Studio Code, selecione Salvar.
No modo de exibição EXPLORER, para abrir um Terminal no local da pasta TestProject, clique com o botão direito do mouse em TestProject e selecione Abrir no Terminal Integrado.
No prompt de comando do Terminal, digite dotnet run e pressione Enter.

A seguinte saída deve ser exibida:
```
Hello Example 1!
Hello Example 2!
```
Reserve um minuto para considerar o que esse resultado indica sobre o uso de espaços em branco no seu código.

Esses dois exemplos de código ilustram duas ideias vitais:
- O espaço em branco não importa para o compilador. No entanto,...
- O espaço em branco, quando usado corretamente, pode aumentar sua capacidade de ler e compreender o código.
Você provavelmente escreve o código uma vez, mas precisa lê-lo várias vezes. Portanto, você deve se concentrar na legibilidade do código que escreve. Com o tempo, você saberá quando usar espaços em branco, assim como caracteres de espaço, tabulações e novas linhas.

Diretrizes iniciais:
- Cada comando completo (uma instrução) pertence a uma linha separada.
- Se uma única linha de código se tornar longa, você poderá dividi-la. No entanto, você deve evitar dividir uma única instrução arbitrariamente em várias linhas até ter um bom motivo para fazer isso.
- Use um espaço à esquerda e à direita do operador de atribuição.
Substitua seu código existente pelo seguinte:
```
Random dice = new Random();
int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);
int total = roll1 + roll2 + roll3;
Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");
if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3)) {
    if ((roll1 == roll2) && (roll2 == roll3)) {
        Console.WriteLine("You rolled triples!  +6 bonus to total!");
        total += 6; 
    } else {
        Console.WriteLine("You rolled doubles!  +2 bonus to total!");
        total += 2;
    }
}
```
Observe que esse código não inclui muitos espaços em branco. Esse código será usado para ilustrar uma abordagem para adicionar espaços em branco aos seus aplicativos. O uso eficaz de espaços em branco deve facilitar a compreensão das funções do seu código.

Observação

O código usa a classe Random para ajudar a desenvolver uma simulação de jogo de dados, em que o valor total de três jogadas é usado para calcular a pontuação "vencedora". O código concede pontos extras para jogadas que acertam dois ou três números iguais. Você não precisa entender esse código por completo para notar o benefício dos espaços em branco.
Reserve um minuto para considerar como você usaria espaços em branco para melhorar a legibilidade desse código.

Há dois recursos deste código que devem ser observados:
- Não há espaço em branco vertical neste exemplo de código. Em outras palavras, não há linhas vazias separando as linhas de código. Tudo isso é executado conjuntamente, em uma listagem de código densa.
- Os blocos de código, conforme definidos pelos símbolos de chave de abertura e fechamento { }, são compactados próximos entre si, tornando seus limites difíceis de distinguir visualmente.
Em termos gerais, para melhorar a legibilidade, você introduz uma linha em branco a cada duas, três ou quatro linhas de código que fazem coisas semelhantes ou relacionadas.

Formular seu código usando espaço em branco vertical é algo subjetivo. É possível que dois desenvolvedores discordem sobre o que é mais legível ou quando adicionar espaços em branco. Use o bom senso.
Para adicionar espaços em branco verticais que melhoram a legibilidade, atualize o código da seguinte maneira:
```
Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;
Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3)) {
    if ((roll1 == roll2) && (roll2 == roll3)) {
        Console.WriteLine("You rolled triples!  +6 bonus to total!");
        total += 6; 
    } else {
        Console.WriteLine("You rolled doubles!  +2 bonus to total!");
        total += 2;
    }
}
```
Sua primeira linha de espaço em branco é usada para separar a declaração da variável dice das linhas de código usadas para atribuir valores às variáveis de lançamento de dados. Essa separação facilita a visualização de como dice está sendo usado em seu código.

A próxima linha de espaço em branco separa a declaração das variáveis de lançamento de dados da declaração de total. Agrupar a declaração das suas três variáveis de lançamento de dados é útil de duas maneiras. Primeiro, isso cria um grupo de linhas de código com as variáveis relacionadas. Em segundo lugar, os nomes das variáveis são tão semelhantes, e a declaração segue o mesmo padrão. Portanto, agrupá-las chama a atenção para as semelhanças e ajuda a expor as diferenças entre elas.

Por fim, a terceira linha de espaço em branco separa outro grupo de instruções relacionadas das instruções if aninhadas. O grupo de instruções que inclui a declaração de total e o método Console.WriteLine() está relacionado pela finalidade e não pela aparência. Seu código se concentra no valor total obtido pelos três dados e se o lançamento de dados incluiu dois ou três valores iguais. Essas linhas estão relacionadas porque você precisa calcular total e relatar os resultados do lançamento de dados ao usuário.

Alguns desenvolvedores podem argumentar que você deve adicionar uma linha vazia entre a declaração de total e Console.WriteLine(). Mais uma vez, a escolha dos espaços em branco fica a seu critério. Você deve decidir o que lhe parece mais legível e usar esse estilo de modo consistente.

Tudo o que lhe resta é a instrução if. Você pode examinar isso agora.

Concentrando-se nas linhas de código abaixo da palavra-chave if, modifique seu código da seguinte maneira:

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;
Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3)) 
{
    if ((roll1 == roll2) && (roll2 == roll3)) 
    {
        Console.WriteLine("You rolled triples!  +6 bonus to total!");
        total += 6; 
    } 
    else 
    {
        Console.WriteLine("You rolled doubles!  +2 bonus to total!");
        total += 2;
    }
}

Observe que você moveu as chaves para sua própria linha de código a fim de melhorar o espaçamento.

Os símbolos { e } criam blocos de código. Muitos constructos de C# exigem blocos de código. Esses símbolos devem ser colocados em uma linha separada para os seus deles fiquem claramente visíveis e legíveis.

Além disso, é importante usar a chave tab para alinhar os símbolos de bloco de código sob a palavra-chave à qual eles pertencem. Por exemplo, observe a linha de código que começa com a palavra-chave if. Abaixo dessa linha está o símbolo {. Esse alinhamento facilita a compreensão de que { "pertence" à instrução if. Além disso, o último símbolo } também se alinha à instrução if. A combinação de alinhamento e recuo facilita a compreensão de onde o bloco de código começa e termina.

As linhas de código inseridas nesse bloco de código estão recuadas, indicando que elas "pertencem" a ele.

Você segue um padrão semelhante com a instrução if interna e a instrução else, e o código dentro desses blocos de código.

Nem todos concordam com essa diretriz de estilo para incluir espaços em branco. No entanto, você deve considerar o uso dessas diretrizes como um ponto de partida ao escrever seus códigos. No futuro, você pode optar conscientemente por não seguir mais essa diretriz.

Recapitulação

Os principais aprendizados deste exercício:

Use espaço em branco criteriosamente para ajudar a melhorar a legibilidade do código.
Use alimentações de linha para criar linhas vazias a fim de separar frases de código. Uma frase é composta por linhas de código semelhantes ou que funcionam em conjunto.
Use alimentações de linha para separar símbolos de bloco de código para que cada símbolo fique na sua própria linha de código.
Use a chave tab para alinhar um bloco de código com a palavra-chave com a qual ele está associado.
Recue o código dentro de um bloco de código para mostrar a propriedade.

Comentários

Esta página foi útil?