Do Zero à API: Curso de JavaScript e TypeScript - JS/TS

Estruturas de Condição

As estruturas de condição permitem que o programa tome decisões com base em diferentes situações. Pense nelas como um "caminho de escolha" em uma receita de culinária. Dependendo dos ingredientes disponíveis, você escolhe diferentes passos. Na programação, essas "escolhas" são feitas com base em condições que o programa verifica.

Operadores Relacionais

Os operadores relacionais são usados para comparar dois valores. O resultado dessas comparações sempre será verdadeiro ou falso. É como perguntar: "Este número é maior que aquele?" ou "Esses dois valores são iguais?"

Os operadores relacionais mais comuns e seus significados:

• == : Igual a (compara se dois valores são iguais, sem considerar o tipo)

• === : Estritamente igual a (compara se dois valores e tipos são iguais)

• != : Diferente de (compara se dois valores são diferentes)

• !== : Estritamente diferente de (compara se dois valores ou tipos são diferentes)

• > : Maior que

• < : Menor que

• >= : Maior ou igual a

• <= : Menor ou igual a

Exemplos:

```

5 == "5"; // true

5 === "5"; // false

5 === 5; // true

10 != 5; // true

10 !== "10"; // true

10 > 5; // true

5 < 10; // true

10 >= 10; // true

5 <= 10; // true

```

Operadores Lógicos

Os operadores lógicos permitem que você combine várias condições para tomar decisões mais complexas. Eles são úteis quando você quer que múltiplas comparações sejam verdadeiras ou falsas ao mesmo tempo.

Aqui estão os principais operadores lógicos:

• && (E): Todas as condições devem ser verdadeiras.

• || (OU): Pelo menos uma condição deve ser verdadeira.

• ! (NÃO): Inverte o valor de uma condição.

Exemplos:

```

true && true;  // true

true && false; // false

!true;  // false

!false; // true

```

Estruturas Condicionais

As estruturas condicionais permitem que você faça escolhas no seu código com base em condições. As mais comuns em JavaScript e Node.js são if...else e switch...case.

1. if e else

A estrutura if...else funciona como uma "pergunta" no seu código. Se a condição dentro do if for verdadeira, o programa executa um bloco de código. Caso contrário, ele executa o bloco que está dentro do else.

Exemplo:

```

let nota = 85;

if (nota >= 90) {

  console.log("A");

} else if (nota >= 80) {

  console.log("B");

} else if (nota >= 70) {

  console.log("C");

} else {

  console.log("F");

}

```

2. switch...case

O switch...case é usado quando você precisa comparar um valor com diferentes casos possíveis. Ele funciona como uma série de if...else, mas pode ser mais organizado quando há muitas opções a serem verificadas.

Exemplo:

```

let cor = "vermelho";

switch (cor) {

  case "vermelho":

    console.log("A cor é vermelha");

    break;

  case "azul":

    console.log("A cor é azul");

    break;

  default:

    console.log("Cor desconhecida");

}

```

Estruturas de Repetição

As estruturas de repetição permitem que um bloco de código seja executado várias vezes, com base em uma condição. Elas são úteis quando você precisa repetir uma ação até que algo aconteça, como contar de 1 a 10 ou somar todos os números de uma lista.

1. for

O for é usado quando você sabe quantas vezes o loop deve ser executado. Ele segue um padrão simples:

• Início: Onde a contagem começa.

• Condição: O loop continua enquanto a condição for verdadeira.

• Incremento: O que acontece ao final de cada repetição.

Exemplo: Contar de 1 a 5

```

for (let i = 1; i <= 5; i++) {

  console.log(i);

}

```

2. while

O while é usado quando você não sabe quantas vezes o loop deve ser executado. Ele vai continuar repetindo enquanto a condição for verdadeira.

Exemplo:

```

let contador = 1;

while (contador <= 5) {

  console.log(contador);

  contador++;

}

```

3. do...while

O do...while é semelhante ao while, mas garante que o bloco de código seja executado pelo menos uma vez, mesmo que a condição seja falsa desde o início.

Exemplo:

```

let contador = 6;

do {

  console.log(contador);

  contador++;

} while (contador <= 5);

```

Nesse exemplo, o valor de contador é 6, mas o código dentro do do ainda será executado uma vez antes de verificar a condição.

Resumo

• Estruturas de Condição permitem tomar decisões com base em comparações (if...else, switch...case).

• Operadores Relacionais comparam valores e sempre retornam verdadeiro ou falso.

• Operadores Lógicos combinam múltiplas condições para criar expressões mais complexas.

• Estruturas de Repetição permitem repetir ações várias vezes (for, while, do...while).

Essas são ferramentas essenciais para criar programas que tomam decisões e executam tarefas repetidamente, como contar, verificar condições, e realizar ações de acordo com os resultados de comparações.