Tutorial: Instruções e loops 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 da compilação e execução dele. O tutorial contém uma série de lições que exploram as construções de ramificação e looping em C#. Essas lições ensinam os conceitos básicos da linguagem C#.

Neste tutorial, você:

Inicie um Codespace do GitHub com um ambiente de desenvolvimento em C#.
Explorar if e else instruções.
Utilize loops para repetir operações.
Trabalhe com loops aninhados.
Combine interseções e loops.

Pré-requisitos

Você deve ter uma das seguintes opções:

Uma conta do GitHub para usar os Codespaces do GitHub. Se você ainda não tiver uma, poderá criar uma conta gratuita em GitHub.com.
Um computador com as seguintes ferramentas instaladas:
- O SDK do .NET 10.
- Visual Studio Code.
- O Kit de Desenvolvimento do C#.

Usar instruções if

Para iniciar um Codespace do GitHub com o ambiente do tutorial, abra uma janela do navegador para o repositório do codespace do tutorial. Selecione o botão código verde e a guia Codespaces . Em seguida, selecione o + sinal para criar um novo Codespace usando esse ambiente. Se você concluiu outros tutoriais nesta série, poderá abrir esse codespace em vez de criar um novo.

Quando o codespace for carregado, crie um novo arquivo na pasta de tutoriais chamada branches-loops.cs.
Abra seu novo arquivo.

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.");

Experimente este código digitando o seguinte comando no terminal integrado:
```
cd tutorials
dotnet branches-loops.cs
```
Você deverá ver a mensagem "A resposta é maior que 10" impressa no console.
Modifique a declaração de b para que a soma seja menor que 10:
```
int b = 3;
```
Digite dotnet branches-loops.cs novamente na janela do terminal.

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

Dica

Ao explorar C# (ou qualquer linguagem de programação), você pode cometer erros ao escrever código. O compilador localiza e relata os erros. Examine atentamente a saída do erro e o código que gerou o erro. Você também pode pedir a Copilot para encontrar diferenças ou detectar erros. O erro do compilador geralmente pode ajudá-lo a encontrar o problema.

Este primeiro exemplo mostra o poder dos if e tipos Booleanos. Um booliano é uma variável que pode ter um dos dois valores: true ou false. O C# define um tipo especial para bool variáveis boolianas. A instrução if verifica o valor de um bool. Quando o valor é true, a instrução após o if é executada. Caso contrário, ela é ignorada. Esse processo de verificação de condições e execução de instruções com base nessas condições é eficiente. Vamos explorar mais.

Fazer com que "if" e "else" trabalhem juntos

Para executar código diferente nas ramificações verdadeiras e falsas, crie uma ramificação else que seja executada quando a condição for falsa. Experimente uma ramificação else .

Adicione as duas últimas linhas no snippet de código a seguir (você já deve ter as quatro primeiras):
```
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 após a palavra-chave else é executada somente quando a condição que está sendo testada é false. A combinação de if e else com condições booleanas fornece todo o poder necessário para lidar com as condições true e false.

Importante

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

Já que a indentação não é significativa, é necessário usar { e } para indicar quando você deseja que mais de uma instrução faça parte do bloco que é executado condicionalmente. Os programadores em C# normalmente usam essas chaves em todas as cláusulas if e else.
O exemplo a seguir é o mesmo que você criou no exemplo anterior, com a adição de { e }. Modifique 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.
Você pode testar condições mais complicadas. Adicione o seguinte código após o código que você 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. Usar == distingue o teste de igualdade de atribuição, que você viu em a = 5.

O && representa "e". Isso significa que as duas condições devem ser verdadeiras para executar a instrução no branch verdadeiro. Estes exemplos também mostram que você pode ter várias instruções em cada branch condicional, desde que você coloque-as entre { e }.
Você também pode usar || para representar "ou". Adicione o seguinte código após o que você escreveu até agora:
```
if ((a + b + c > 10) || (a == b))
```
Modifique os valores de a, be c e alterne entre && e || para explorar. Você obtém mais compreensão de como os operadores && e || funcionam.

Você terminou a primeira etapa. Antes de iniciar a próxima seção, vamos mover o código atual para um método separado. Isso facilita o início do trabalho com um novo exemplo. Coloque o código existente em um método chamado ExploreIf(). Chame-o da parte superior do seu programa. Quando você terminou essas alterações, seu código deverá se parecer com o seguinte código:

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");
    }
}

Comente a chamada para ExploreIf(). Isso faz com que a saída fique menos desordenada enquanto você trabalha nesta seção:
```
//ExploreIf();
```

O elemento // inicia um comentário em C#. Os comentários são qualquer texto que você deseja manter no código-fonte, mas não são executados como código. O compilador não gera nenhum código executável a partir de comentários.

Use loops para repetir operações

Outro conceito importante para criar programas maiores são loops. Use loops para repetir instruções que você deseja executar mais de uma vez.

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 após a while. Ela repete a verificação da condição e a execução dessas instruções até que a condição seja false.

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

Importante

Verifique se a condição de while loop é alterada para false à medida que você executa o código. Caso contrário, você criará um loop infinito em que seu programa nunca terminará. Esse comportamento não é demonstrado neste exemplo, pois você precisa forçar seu programa a desistir usando CTRL-C ou outros meios.

O loop while testa a condição antes de executar o código após o while.
O loop do... while executa o código primeiro e, em seguida, verifica a condição. O loop do while é mostrado no seguinte código:
```
int counter = 0;
do
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
} while (counter < 10);
```
Esse do loop e o loop anterior while produzem a mesma saída.

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

Trabalhar com o loop for

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

Experimente 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 de 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 é a do inicializador: int counter = 0; declara que counter é a variável de loop e define seu valor inicial como 0.
- A parte intermediária é a condição for: counter < 10 declara que esse for loop continua sendo executado desde que o valor seja counter menor que 10.
- A parte final é a do iterador: counter++ especifica como modificar a variável de loop depois de executar o bloco após a instrução for. Aqui, ela especifica que counter é incrementado com 1 sempre que o bloco for executado.
Experimente essas condições por conta própria. Experimente cada uma das seguintes alterações:
- Altere o inicializador para iniciar com um valor diferente.
- Altere a condição para parar em um valor diferente.

Quando terminar, vá para a próxima seção para escrever algum código por conta própria e usar o que aprendeu.

Há uma outra instrução de loop que não está abordada neste tutorial: a instrução foreach. A instrução foreach repete sua instrução para cada item em uma sequência de itens. Geralmente, você o usa com coleções. Ele é abordado no próximo tutorial.

Loops aninhados criados

Você pode aninhar um while, do ou for loop dentro de outro loop para criar uma matriz combinando cada item no loop externo com cada item no loop interno. Vamos criar um conjunto de pares alfanuméricos para representar linhas e colunas.

Adicione o seguinte for loop que gera as linhas:

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

Adicione outro loop para gerar as colunas:

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

Por fim, aninhar o loop de colunas 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 loop externo incrementa uma vez para cada execução completa do loop interno. Inverta o aninhamento de linha e da coluna e confira as alterações. Quando terminar, coloque o código desta seção em um método chamado ExploreLoops().

Combinar branches e loops

Agora que você usou a if instrução e os constructos de loop na linguagem C#, veja se você pode escrever código C# para encontrar a soma de todos os inteiros de 1 a 20 que são divisível por 3. Aqui estão algumas dicas:

O operador % retorna o restante de uma operação de divisão.
A instrução if especifica a condição para determinar se um número deve fazer parte da soma.
O loop for pode ajudá-lo a repetir uma série de etapas para todos os números de 1 a 20.

Experimente você mesmo. Em seguida, verifique como você fez. Como dica, você deve obter 63 como resposta.

Você pensou em 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}");

Você concluiu o tutorial "ramificações e laços". Você pode saber mais sobre esses conceitos nestes artigos:

Recursos de limpeza

O GitHub exclui automaticamente o Codespace após 30 dias de inatividade. Se você planeja explorar mais tutoriais nesta série, pode deixar o seu Codespace provisionado. Se você estiver pronto para visitar o site do .NET para baixar o SDK do .NET, poderá excluir seu Codespace. Para excluir seu Codespace, abra uma janela do navegador e navegue até seus Codespaces. Você deve ver uma lista de seus codespaces na janela. Selecione os três pontos (...) na entrada para o codespace do tutorial de aprendizado e selecione excluir.

Próxima etapa

Saiba mais sobre coleções

Comentários

Esta página foi útil?

Last updated on 2025-12-11