Uma visão geral das estruturas de decisão, loop e controle de exceção
Tags: braziliandevs, javascript, webdev, beginners
Published: 2023-03-04 23:20:37

O controle de fluxo se refere à forma como o código é executado, levando em consideração condições ou eventos específicos. Esse recurso permite que o desenvolvedor controle a execução do código de acordo com diferentes condições.

Existem três tipos principais de controle de fluxo no JavaScript:

## Estruturas de Decisão:

As estruturas de decisão permitem que o desenvolvedor execute diferentes blocos de código com base em uma condição. Existem duas estruturas de decisão principais no JavaScript: a declaração _if_ e a declaração _switch_. A instrução _if_ executa um bloco de código se a condição especificada for verdadeira. Já a declaração _switch_ executa diferentes blocos de código com base em diferentes valores.

- _if...else_:

```javascript
const age = 18;

if (age >= 18) {
  console.log("you are of legal age.");
} else {
  console.log("you are a minor.");
}
```

- _switch_:

```javascript
const color = 'green';

switch (color) {
  case 'red':
    console.log('the color is red.');
    break;
  case 'blue':
    console.log('the color is blue.');
    break;
  case 'green':
    console.log('the color is green.');
    break;
  default:
    console.log('the color is unknown.');
    break;
}
```

## Estruturas de Loop:

As estruturas de loop permitem que o desenvolvedor execute um bloco de código várias vezes com base em uma condição específica. Existem três estruturas de loop principais no JavaScript: a declaração _for_, a declaração _while_ e a declaração _do-while_. A instrução _for_ executa um bloco de código várias vezes com base em uma condição específica. A instrução _while_ executa um bloco de código enquanto a condição especificada for verdadeira. A instrução _do-while_ executa um bloco de código pelo menos uma vez e, em seguida, continua a executá-lo enquanto a condição especificada for verdadeira.

- _for_:

```javascript
for (let i = 0; i < 5; i++) {
  console.log(i);
}
```

- _while_:

```javascript
let i = 0;

while (i < 5) {
  console.log(i);
  i++;
}
```

- _do...while_:

```javascript
let i = 0;

do {
  console.log(i);
  i++;
} while (i < 5);
```

## Estruturas de Controle de Exceção:

Por fim, as estruturas de controle de exceção permitem que o desenvolvedor manipule erros no código. Existem dois tipos principais de estruturas de controle de exceção em JavaScript: a declaração _try-catch_ e a declaração _throw_. A instrução _try-catch_ tenta executar um bloco de código e, se ocorrer um erro, captura o erro e executa um bloco de código diferente. A instrução _throw_ é usada para gerar um erro manualmente.

- _try-catch_ + _throw_:

```javascript
function divide(a, b) {
  if (b === 0) {
    throw new Error('cannot divide by zero.');
  }

  return a / b;
}

try {
  const result = divide(10, 0);
  console.log(result);
} catch (error) {
  console.log(error.message);
}
```

Em resumo, o controle de fluxo é uma ferramenta fundamental para o desenvolvimento de software em JavaScript. Por meio de estruturas de decisão, loop e controle de exceção, os desenvolvedores podem controlar a execução do código de acordo com diferentes condições, tornando o código mais eficiente e fácil de manter. É importante que os desenvolvedores tenham um bom conhecimento dessas estruturas para escrever código limpo e eficiente.