Tutorial: Instruções e ciclos em C# if - lógica condicional

Este tutorial ensina como escrever código C# que examina variáveis e altera o caminho de execução com base nessas variáveis. Você escreve código C# e vê os resultados de compilá-lo e executá-lo. O tutorial contém uma série de lições que exploram construções de ramificação e looping em C#. Estas lições ensinam os fundamentos da linguagem C#.

Neste tutorial, você:

Pré-requisitos

É necessário ter uma das seguintes opções:

• Uma conta GitHub para usar Codespaces GitHub. Se ainda não tiver uma, pode criar uma conta gratuita no GitHub.com.
• Um computador com as seguintes ferramentas instaladas:
  • O SDK .NET 10.
  • Código do Visual Studio.
  • O C# DevKit.

Utilizar instruções if

Para iniciar um GitHub Codespace com o ambiente de tutorial, abra uma janela do navegador para o repositório tutorial codespace. Selecione o botão verde de Código e o separador Codespaces . Depois seleciona o + sinal para criar um novo Codespace usando este ambiente. Se completaste outros tutoriais desta série, podes abrir esse espaço de código em vez de criares um novo.

1. Quando o seu espaço de código carregar, crie um novo ficheiro na pasta tutoriais chamado branches-loops.cs.

2. Abra o seu novo ficheiro.

3. Digite ou copie o seguinte código para branches-loops.cs:

   int a = 5;
   int b = 6;
   if (a + b > 10)
       Console.WriteLine("The answer is greater than 10.");
   

4. Experimente este código escrevendo o seguinte comando no terminal integrado:

   cd tutorials
   dotnet branches-loops.cs
   

   Deverias ver a mensagem "A resposta é maior que 10." impressa na tua consola.

5. Modificar a declaração de b para que a soma seja inferior a 10:

   int b = 3;
   

6. Escreve dotnet branches-loops.cs novamente na janela do terminal.

   Como a resposta é inferior a 10, nada é impresso. A condição que você está a testar é falsa. Você não tem nenhum código para executar porque escreveu apenas uma das ramificações possíveis para uma instrução if: a ramificação verdadeira.

Esta primeira amostra mostra a capacidade dos tipos if e booleanos. Uma booleana é uma variável que pode ter um de dois valores: true ou false. C# define um tipo especial, bool para variáveis booleanas. A instrução if verifica o valor de um bool. Quando o valor é true, a instrução seguinte ao if é executada. Caso contrário, é ignorado. Este processo de verificação de condições e execução de declarações com base nessas condições é poderoso. Vamos explorar mais.

Faça com que if e else funcionem juntos

Para executar código diferente nas ramificações true e false, crie uma ramificação else que é executada quando a condição é false. Experimenta um else ramo.

1. Adicione as duas últimas linhas no seguinte excerto de código (já deve ter as primeiras quatro):

   int a = 5;
   int b = 3;
   if (a + b > 10)
       Console.WriteLine("The answer is greater than 10");
   else
       Console.WriteLine("The answer is not greater than 10");
   

   A instrução que segue a palavra-chave else é executada somente quando a condição que está sendo testada é false. Combinar if e else com condições booleanas fornece toda a potência necessária para lidar tanto com uma true como com uma false condição.

   Importante

   O recuo sob as if e else declarações é para leitores humanos. A linguagem C# não trata o recuo ou o espaço em branco como sendo significativos. A instrução que segue a palavra-chave if ou else é executada com base na condição. Todos os exemplos neste tutorial seguem uma prática comum para indentar linhas com base no fluxo de controle de declarações.

   Como a indentação não é significativa, precisas usar { e } para indicar quando desejas que mais de uma instrução faça parte do bloco que se executa condicionalmente. Os programadores de C# usam normalmente colchetes em todas as cláusulas if e else.

2. O exemplo seguinte é igual ao que criaste no exemplo anterior, com a adição de { e }. Modifique o seu código para corresponder ao seguinte código:

   int a = 5;
   int b = 3;
   if (a + b > 10)
   {
       Console.WriteLine("The answer is greater than 10");
   }
   else
   {
       Console.WriteLine("The answer is not greater than 10");
   }
   

   Dica

   No restante deste tutorial, todos os exemplos de código incluem as chaves, seguindo as práticas aceitas.

3. Pode testar condições mais complicadas. Adicione o seguinte código após o que escreveu até agora:

   int a = 5;
   int b = 3;
   int c = 4;
   if ((a + b + c > 10) && (a == b))
   {
       Console.WriteLine("The answer is greater than 10");
       Console.WriteLine("And the first number is equal to the second");
   }
   else
   {
       Console.WriteLine("The answer is not greater than 10");
       Console.WriteLine("Or the first number is not equal to the second");
   }
   

   O símbolo == testa a igualdade de . Ao usares ==, distingues o teste de igualdade da atribuição, que já tinhas visto em a = 5.

   O && representa "e". Isso significa que ambas as condições devem ser verdadeiras para executar a instrução no ramo verdadeiro. Esses exemplos também mostram que pode ter várias declarações em cada ramificação condicional, desde que as inclua em { e }.

4. Também podes usar || para representar "ou". Adicione o seguinte código após o que escreveu até agora:

   if ((a + b + c > 10) || (a == b))
   

5. Modifique os valores de a, be c e alterne entre && e || para explorar. Você ganha mais compreensão de como os operadores de && e || funcionam.

6. Terminaste o primeiro passo. Antes de começares a próxima secção, vamos mover o código atual para um método separado. Isso torna mais fácil começar a trabalhar com um novo exemplo. Coloque o código existente num método chamado ExploreIf(). Chama isso do início do teu programa. Quando terminares essas alterações, o teu código deverá parecer o seguinte:

   ExploreIf();
   
   void ExploreIf()
   {
       int a = 5;
       int b = 3;
       if (a + b > 10)
       {
           Console.WriteLine("The answer is greater than 10");
       }
       else
       {
           Console.WriteLine("The answer is not greater than 10");
       }
   
       int c = 4;
       if ((a + b + c > 10) && (a > b))
       {
           Console.WriteLine("The answer is greater than 10");
           Console.WriteLine("And the first number is greater than the second");
       }
       else
       {
           Console.WriteLine("The answer is not greater than 10");
           Console.WriteLine("Or the first number is not greater than the second");
       }
   
       if ((a + b + c > 10) || (a > b))
       {
           Console.WriteLine("The answer is greater than 10");
           Console.WriteLine("Or the first number is greater than the second");
       }
       else
       {
           Console.WriteLine("The answer is not greater than 10");
           Console.WriteLine("And the first number is not greater than the second");
       }
   }
   

7. Comente a chamada para ExploreIf(). Isto torna a saída menos desordenada enquanto trabalhas nesta parte:

   //ExploreIf();
   

Em C#, o // inicia um comentário. Comentários são qualquer texto que queiras manter no teu código-fonte, mas não executar como código. O compilador não gera qualquer código executável a partir dos comentários.

Usar ciclos para repetir operações

Outro conceito importante para criar programas maiores são os ciclos. Use loops para repetir instruções que queira executar mais do que uma vez.

1. Adicione este código após a chamada para ExploreIf:

   int counter = 0;
   while (counter < 10)
   {
       Console.WriteLine($"Hello World! The counter is {counter}");
       counter++;
   }
   

   A instrução while verifica uma condição e executa a instrução seguindo o while. Repete a verificação da condição e a execução dessas instruções até que a condição seja falsa.

   Há um outro novo operador neste exemplo. O ++ após a variável counter é o operador de incremento . Adiciona 1 ao valor de counter e armazena esse valor na counter variável.

   Importante

   Certifica-te de que a while condição do loop muda para falsa à medida que executas o código. Caso contrário, você cria um loop infinito onde seu programa nunca termina. Esse comportamento não é demonstrado neste exemplo, porque tens de forçar o teu programa a sair usando CTRL-C ou outros meios.

   O loop while testa a condição antes de executar o código após o while.

2. O loop do ... while executa o código primeiro e, em seguida, verifica a condição. O ciclo do while é mostrado no seguinte código:

   int counter = 0;
   do
   {
       Console.WriteLine($"Hello World! The counter is {counter}");
       counter++;
   } while (counter < 10);
   

   Este do loop e o loop anterior while produzem a mesma saída.

Vamos passar para uma última instrução de loop.

Trabalhar com o ciclo for

Outra instrução de loop comum que você vê no código C# é o loop for.

1. Experimenta este código:

   for (int counter = 0; counter < 10; counter++)
   {
       Console.WriteLine($"Hello World! The counter is {counter}");
   }
   

   O loop for anterior faz o mesmo trabalho que o loop while e o loop do que você já usou. A instrução for tem três partes que controlam como ela funciona:

   • A primeira parte é o para inicializador: int counter = 0; declara que counter é a variável de loop e define seu valor inicial como 0.
   • A parte do meio é a condição do for: counter < 10 declara que este for ciclo continua a executar enquanto o valor de counter for inferior a 10.
   • A parte final é o para iterador: counter++ especifica como modificar a variável de loop depois de executar o bloco após a instrução for. Aqui, ele especifica que counter incrementa em 1 cada vez que o bloco é executado.

2. Experimente essas condições você mesmo. Tente cada uma das seguintes alterações:

   • Altere o inicializador para começar com um valor diferente.
   • Altere a condição para parar em um valor diferente.

Quando terminares, passa para a próxima secção para escreveres algum código tu próprio e usa o que aprendeste.

Há uma outra instrução de looping que não é abordada neste tutorial: a instrução foreach. A instrução foreach repete sua instrução para cada item em uma sequência de itens. Na maioria das vezes, usa-se com coleções. É abordado no próximo tutorial.

Loops aninhados criados

Podes aninhar um ciclo while, do ou for dentro de outro ciclo para criar uma matriz, combinando cada item no ciclo exterior com cada item no ciclo interior. Vamos construir um conjunto de pares alfanuméricos para representar linhas e colunas.

1. Adicione o seguinte for ciclo que gera as linhas:

   for (int row = 1; row < 11; row++)
   {
       Console.WriteLine($"The row is {row}");
   }
   

2. Adicione outro ciclo para gerar as colunas:

   for (char column = 'a'; column < 'k'; column++)
   {
       Console.WriteLine($"The column is {column}");
   }
   

3. Finalmente, aninha-se as colunas em laço dentro das linhas para formar pares:

   for (int row = 1; row < 11; row++)
   {
       for (char column = 'a'; column < 'k'; column++)
       {
           Console.WriteLine($"The cell is ({row}, {column})");
       }
   }
   

   O laço exterior incrementa uma vez para cada percurso completo do laço interior. Inverta o aninhamento de linhas e colunas e veja as alterações você mesmo. Quando terminares, coloca o código desta secção num método chamado ExploreLoops().

Combinar ramificações e ciclos

Agora que usaste a if instrução e os construtos de looping na linguagem C#, vê se consegues escrever código C# para encontrar a soma de todos os inteiros de 1 a 20 que são divisíveis por 3. Aqui estão algumas dicas:

• O operador % fornece o restante de uma operação de divisão.
• A declaração if dá-lhe a condição para ver se um número deve fazer parte da soma.
• O loop for pode ajudá-lo a repetir uma série de passos para todos os números de 1 a 20.

Experimente você mesmo. Em seguida, verifique como você fez. Como sugestão, a resposta deverá ser 63.

Inventou algo assim?

int sum = 0;
for (int number = 1; number < 21; number++)
{
    if (number % 3 == 0)
    {
        sum = sum + number;
    }
}
Console.WriteLine($"The sum is {sum}");

Completaste o tutorial de "ramificações e ciclos". Você pode aprender mais sobre esses conceitos nestes artigos:

• Declarações de seleção
• Instruções de iteração

Recursos de limpeza

O GitHub apaga automaticamente o seu Codespace após 30 dias de inatividade. Se planeia explorar mais tutoriais nesta série, pode deixar o seu Codespace provisionado. Se estiver pronto para visitar o site .NET para descarregar o SDK .NET, pode eliminar o seu Codespace. Para eliminar o seu Codespace, abra uma janela do navegador e navegue até aos seus Codespaces. Deves ver uma lista dos teus codespaces na janela. Selecione os três pontos (...) na entrada para o espaço de código do tutorial de aprendizado e selecione apagar.

Próximo passo