Conceitos e características do controle de fluxo no JavaScript

Controle de Fluxo / Tutorial JavaScript

O Controle de Fluxo na programação é a capacidade que temos de direcionar a execução do código criando condições específicas. Através de instruções e operadores, podemos tomar decisões no código, como executar trechos apenas se uma condição for verdadeira ou repetir ações enquanto uma condição for verdadeira.

O Controle de Fluxo é fundamental para a programação, pois nos permite codar com uma lógica dinâmica, tomando decisões com base em condições e repetindo ações conforme necessário.

Sobre o uso de `;` para separar instruções

O ponto-e-vírgula ; é usado para separar instruções, mas seu uso é opcional no JavaScript. Omitir o ponto-e-vírgula pode deixar o código mais limpo e legível. Seu uso é uma preferência pessoal ou de equipe, sem impacto na performance do programa.

Exemplo 1 - Com ;:

let a = 5;
let b = 10;

console.log(a + b);

Exemplo 2 - Sem ;:

let a = 5
let b = 10

console.log(a + b)

O uso de ; já foi um tópico polêmico entre devs. Alguns defendem seu uso por hábito de outras linguagens como Java e C++, onde ele é obrigatório. No entanto, o JavaScript possui o mecanismo ASI (Automatic Semicolon Insertion), que insere automaticamente os ; necessários.

Neste tutorial, adotaremos o código sem o uso de ponto-e-vírgula, pelos seguintes motivos:

Clareza de leitura: Para iniciantes, a remoção do ; torna o código mais limpo e fácil de entender.
Foco nos fundamentos: Evita confusões sobre onde e quando usar ;, permitindo maior foco nos conceitos da linguagem.
Linguagem inteligente: O ASI cuida da inserção automática dos ;, tornando seu uso desnecessário na maioria dos casos.
Consistência: Promove um código mais conciso e evita práticas ruins, como múltiplas instruções na mesma linha.

Blocos de código com `{}`

Um bloco de código é um conjunto de instruções delimitado por chaves {}. Ele agrupa instruções em um escopo único, permitindo que sejam executadas de forma independente.

Sintaxe:

{
  // Código
}

Blocos de código criam um novo escopo local, onde variáveis declaradas dentro do bloco são visíveis apenas dentro dele.

Exemplo 1:

let x = 10
{
  let x = 20
  console.log(x) // imprime 20
}
console.log(x) // imprime 10

Exemplo 2:

let x = 10
{
  let x = 20
  let y = 30
  console.log(x + y) // imprime 50
}
console.log(x) // imprime 10
console.log(y) // gera um erro

Blocos de código são úteis para isolar contextos, melhorando a legibilidade e performance do código. Apesar disso, são mais comuns quando associados a instruções como if, else, for, function, entre outras.

Blocos de código com instruções

No JavaScript, blocos de código são frequentemente usados com instruções, onde o escopo pertence ao bloco da instrução.

Exemplo:

let x = 10
if (x > 9) {
  console.log('x é maior que nove')
}

Neste exemplo, o bloco de código associado ao if é executado apenas se a condição for verdadeira.

Estruturas condicionais

As estruturas condicionais permitem que o programa tome decisões com base em condições, executando diferentes trechos de código dependendo se uma expressão resulta em true ou false.

Instruções de estruturas condicionais:

Instrução	Descrição
`if`	Executa um bloco de código se uma condição for verdadeira.
`else`	Executa um bloco de código quando a condição do `if` for falsa.
`else if`	Testa múltiplas condições em sequência após um `if`.
`switch`	Compara o resultado de uma expressão para executar diferentes blocos de código.

Essas instruções são fundamentais para criar uma lógica condicional no JavaScript.

Estruturas de repetição

As estruturas de repetição, também conhecidas como laços ou loops, permitem repetir um bloco de código conforme uma condição ou um número específico de vezes. Elas são usadas para automatizar tarefas repetitivas e percorrer listas como arrays.

Estruturas de repetição:

Instrução	Descrição
`while`	Repete a execução de um bloco enquanto a condição for verdadeira.
`do...while`	Executa o bloco pelo menos uma vez e repete enquanto a condição for verdadeira.
`for`	Executa o bloco com base em um contador.
`for...of`	Itera sobre cada item de uma lista.
`for...in`	Itera sobre cada propriedade de um objeto.

Instruções auxiliares:

Instrução	Descrição
`break`	Interrompe e sai do loop.
`continue`	Interrompe a iteração atual e pula para a próxima.

As estruturas de repetição são poderosas, mas devem ser usadas com cuidado para evitar loops infinitos e garantir eficiência.

Tratamento de erros

O tratamento de erros no JavaScript é uma forma de lidar com problemas que podem ocorrer durante a execução do código. Esses problemas podem ser causados por erros de lógica, dados inesperados ou falhas externas, como a indisponibilidade de um servidor.

Para tratar erros, usamos as instruções try, catch e finally:

Sintaxe básica:

try {
  // Código que pode gerar um erro
} 
catch (erro) {
  // Código para lidar com o erro
} 
finally {
  // Código que será executado sempre, com ou sem erro (opcional)
}

Exemplo simples:

try {
  let resultado = 10 / 0
  console.log(resultado)
} 
catch (erro) {
  console.log('Ocorreu um erro:', erro.message)
}

Neste exemplo, o bloco try contém o código que pode gerar um erro. Se ocorrer um erro, o bloco catch será executado, permitindo que você lide com o problema de forma controlada.

O tratamento de erros é útil para evitar que o programa pare de funcionar inesperadamente e para fornecer mensagens claras sobre o que deu errado.

Sobre o uso de ; para separar instruções