Operadores em JavaScript

JavaScript oferece diversos conjuntos de operadores para manipular dados e realizar avaliações lógicas.

// Operadores Aritméticos
// + (soma), - (subtração), * (multiplicação), / (divisão), % (módulo), ++ (incremento), -- (decremento)

// Operadores Lógicos
// && (E lógico), || (OU lógico), ! (NÃO lógico)

// Operadores de Comparação
// == (igualdade de valor), != (diferença de valor)
// === (igualdade estrita: valor e tipo), !== (diferença estrita)
// > (maior), < (menor), >= (maior ou igual), <= (menor ou igual)

// Operadores de Atribuição
// = (atribuição simples), +=, -=, *=, /= (atribuições compostas)

Estruturas de Controle de Fluxo

As estruturas de contrloe permitem ditar o caminho que a execução do código deve seguir com base em condições ou repetições.

// 1. Condicional If...Else
let pontuacao = 85;
if (pontuacao >= 90) {
    console.log('Excelente');
} else if (pontuacao >= 70) {
    console.log('Aprovado');
} else {
    console.log('Reprovado');
}

// 2. Estrutura Switch
let categoria = 'admin';
switch (categoria) {
    case 'usuario':
        console.log('Acesso limitado');
        break;
    case 'admin':
        console.log('Acesso total');
        break;
    default:
        console.log('Visitante');
}

// 3. Loops: For e For...in
let frutas = ['maçã', 'banana', 'uva'];

// Iteração clássica
for (let i = 0; i < frutas.length; i++) {
    console.log(i, frutas[i]);
}

// Iteração em propriedades/índices
for (let index in frutas) {
    console.log(index, frutas[index]);
}

// 4. Loop While
let contador = 0;
while (contador < 5) {
    console.log('Contagem:', contador);
    contador++;
}

// 5. Operador Ternário
let idade = 20;
let status = (idade >= 18) ? 'Maior de idade' : 'Menor de idade';

Trabalhando com Funções

Funções são blocos de construção fundamentais que encapsulam lógica reutilizável.

// Função Declarativa
function calcularSoma(a, b) {
    return a + b;
}

// Função Anônima (atribuída a uma variável)
const multiplicar = function(x, y) {
    return x * y;
};

// IIFE (Immediately Invoked Function Expression)
(function(mensagem) {
    console.log('Execução imediata:', mensagem);
})('Olá Mundo');

// Arrow Function (Sintaxe reduzida)
const dobrarValor = n => n * 2;
const subtrair = (a, b) => a - b;

Escopo e Closures

O JavaScript gerencia o acesso a variáveis através de escopos léxicos e suporta closures, onde uma função interna mantém acesso ao ambiente da função externa.

// Exemplo de Closure
function criarSaudacao(saudacao) {
    return function(nome) {
        console.log(saudacao + ', ' + nome);
    };
}
const saudarOi = criarSaudacao('Oi');
saudarOi('Carlos'); // Exibe: "Oi, Carlos"

// Análise Léxica (Hoisting de Variáveis com 'var')
var local = 'Global';
function testarEscopo() {
    console.log(local); // undefined devido ao hoisting da declaração interna
    var local = 'Local';
    console.log(local); // 'Local'
}

Criação e Manipulação de Objetos

Além de objetos literais, JavaScript permite criar objetos via construtores e gerenciar herança via protótipos.

// Objeto via construtor Object
let carro = new Object();
carro.marca = 'Toyota';
carro.ano = 2022;

// Função Construtora e Protótipo
function Animal(especie) {
    this.especie = especie;
}

Animal.prototype.emitirSom = function() {
    console.log(this.especie, 'fazendo som...');
};

let cachorro = new Animal('Cão');
cachorro.emitirSom();

Objetos Nativos do JavaScript

Map

O objeto Map permite armazenar pares chave-valor, onde a chave pode ser de qualquer tipo.

let dicionario = new Map();
dicionario.set('id', 101);
dicionario.set(true, 'booleano');

console.log(dicionario.get('id')); // 101
console.log(dicionario.has(true)); // true
dicionario.delete('id');

Date

Para manipulação de datas e horários.

let agora = new Date();
console.log(agora.getFullYear()); // Ano atual
console.log(agora.getMonth());    // Mês (0-11)
console.log(agora.getTime());     // Timestamp em milissegundos

let dataEspecifica = new Date(2023, 11, 25, 10, 30); // 25 de Dezembro de 2023

JSON

Utilizado para converter objetos em strings (serialização) e vice-versa.

let usuario = { nome: 'Ana', idade: 25 };
let jsonString = JSON.stringify(usuario); // Objeto para String
let objetoNovo = JSON.parse(jsonString);  // String para Objeto

RegExp (Expressões Regulares)

Utilizado para busca e substituição de padrões em textos.

let padrao = /javascript/i; // 'i' para case-insensitive
let frase = 'Amo JavaScript';
console.log(padrao.test(frase)); // true

// Métodos de String com Regex
let texto = 'Café com leite e café com açúcar';
let resultado = texto.replace(/café/gi, 'Chá'); // Substituição global

Math

Provê propriedades e métodos para funções matemáticas.

Math.abs(-5);       // 5
Math.random();      // Número entre 0 e 1
Math.floor(4.9);    // 4 (arredonda para baixo)
Math.round(4.5);    // 5 (arredonda para o mais próximo)
Math.max(10, 20);   // 20
Math.pow(2, 3);     // 8 (2 elevado a 3)