A Matemática na Programação

Imagine que você está organizando suas finanças pessoais. Você precisa somar suas receitas, subtrair as despesas, calcular percentuais de desconto em compras e determinar quantos meses levará para atingir uma meta de economia. Todas essas tarefas envolvem operações matemáticas que, na programação, são realizadas através dos operadores.

Os operadores são os símbolos especiais que instruem o computador a realizar operações específicas sobre valores, funcionando como as ferramentas matemáticas que já conhecemos, mas adaptadas para o mundo digital. Dominar esses operadores é fundamental para qualquer programador, pois eles formam a base de praticamente todos os cálculos e manipulações de dados que realizamos em nossos programas.

Fundamentos dos Operadores Aritméticos

O que são Operadores Aritméticos?

Operadores aritméticos são símbolos especiais que realizam cálculos matemáticos com números. Assim como você usa +, -, × e ÷ na matemática tradicional, JavaScript possui operadores equivalentes que permitem executar essas operações em seus programas.

Os Seis Operadores Fundamentais

JavaScript oferece seis operadores aritméticos essenciais:

Adição (+)

O mais familiar de todos, usado para somar valores:

let receita1 = 2500;
let receita2 = 1800;
let receitaTotal = receita1 + receita2;

console.log("Receita total: R$ ", receitaTotal);
// Receita total: R$ 4300

Subtração (-)

Usado para calcular diferenças:

let saldoInicial = 5000;
let gasto = 1200;
let saldoFinal = saldoInicial - gasto;
console.log("Saldo restante: R$ ", saldoFinal); 
// Saldo restante: R$ 3800

Multiplicação (*)

Fundamental para cálculos de quantidades:

let precoUnitario = 45;
let quantidade = 12;
let precoTotal = precoUnitario * quantidade;
console.log("Preço total: R$ ", precoTotal); 
// Preço total: R$ 540

Divisão (/)

Essencial para calcular médias e proporções:

let pontuacaoTotal = 450;
let numeroProvas = 5;
let media = pontuacaoTotal / numeroProvas;
console.log("Média: ", media); 
// Média: 90

Módulo/Resto (%)

Retorna o resto de uma divisão, útil para verificar divisibilidade:

let numero = 17;
let resto = numero % 5;
console.log("17 dividido por 5, resto: ", resto); 
// 17 dividido por 5, resto: 2

// Aplicação prática: verificar se um número é par
let valor = 8;
let ehPar = valor % 2 === 0;
console.log("8 é par? ", ehPar); 
// 8 é par? true

Exponenciação (**)

Calcula potências, introduzido recentemente no JavaScript:

let base = 3;
let expoente = 4;
let resultado = base ** expoente;
console.log("3 elevado a 4: ", resultado); 
// 3 elevado a 4: 81

// Aplicação: calcular juros compostos
let capital = 1000;
let taxa = 1.05; // 5% de juros
let tempo = 3;
let montante = capital * (taxa ** tempo);
console.log("Montante após 3 anos: R$ ", montante.toFixed(2)); 
// Montante após 3 anos: R$ 1157.63

A Importância da Precedência

Como JavaScript Resolve Expressões Complexas

Assim como na matemática tradicional, JavaScript segue regras específicas para determinar a ordem das operações. Esta ordem é chamada de precedência de operadores.

let resultado1 = 10 + 5 * 2;
console.log(resultado1); 
// 20 (não 30!)

let resultado2 = (10 + 5) * 2;
console.log(resultado2); 
// 30

Ordem de Precedência (da maior para a menor)

  1. Exponenciação (**)
  2. Multiplicação (*), Divisão (/), Módulo (%)
  3. Adição (+), Subtração (-)

Exemplo Prático: Calculando o Preço Final com Desconto

// Cenário: Produto de R$ 200, desconto de 15%, mais frete de R$ 25
let precoOriginal = 200;
let percentualDesconto = 15;
let frete = 25;

// Forma incorreta (sem parênteses)
let precoErrado = precoOriginal - percentualDesconto / 100 * precoOriginal + frete;
console.log("Preço calculado incorretamente: R$ ", precoErrado); 
// Resultado inesperado

// Forma correta (com parênteses para controlar precedência)
let desconto = (percentualDesconto / 100) * precoOriginal;
let precoFinal = precoOriginal - desconto + frete;
console.log("Preço final correto: R$ ", precoFinal); 
// Preço final correto: R$ 195

// Forma alternativa mais clara
let precoComDesconto = precoOriginal * (1 - percentualDesconto / 100);
let precoFinalAlternativo = precoComDesconto + frete;
console.log("Preço final (método alternativo): R$ ", precoFinalAlternativo); 
// Preço final (método alternativo): R$ 195

Conversão Numérica com Operador + Unário

O operador + pode ser usado de forma unária (com apenas um operando) para converter strings em números:

// Convertendo strings em números
let idadeTexto = "25";
let alturaTexto = "1.75";

let idadeNumero = +idadeTexto;
let alturaNumero = +alturaTexto;

console.log("Idade em dobro: ", idadeNumero * 2); 
// Idade em dobro: 50
console.log("Altura em cm: ", alturaNumero * 100); 
// Altura em cm: 175

// Aplicação prática: somando valores de formulário
let valor1 = "150"; // vindo de um input
let valor2 = "200"; // vindo de outro input
let somaIncorreta = valor1 + valor2; // "150200" (concatenação!)
let somaCorreta = +valor1 + +valor2; // 350 (soma matemática!)

console.log("Soma incorreta: ", somaIncorreta);
 // Soma incorreta: 150200
console.log("Soma correta: ", somaCorreta); 
// Soma correta: 350

Operadores de Atribuição

Atribuição Simples (=)

O operador mais básico e fundamental, usado para armazenar valores em variáveis:

let saldo = 1000;
let nome = "Maria Silva";
let ativo = true;

Operadores de Atribuição Composta

Estes operadores combinam uma operação aritmética com atribuição, tornando o código mais conciso:

Adição e Atribuição (+=)

let pontuacao = 100;
pontuacao += 50; // equivale a: pontuacao = pontuacao + 50
console.log(pontuacao); 
// 150

// Aplicação prática: acumulando vendas diárias
let vendasSemana = 0;
vendasSemana += 850; // Segunda-feira
vendasSemana += 920; // Terça-feira
vendasSemana += 780; // Quarta-feira
console.log("Vendas acumuladas: R$ ", vendasSemana); 
// Vendas acumuladas: R$ 2550

Subtração e Atribuição (-=)

let estoque = 100;
estoque -= 15; // equivale a: estoque = estoque - 15
console.log("Estoque restante: ", estoque); 
// Estoque restante: 85

// Aplicação prática: controle de inventário
let produtosDisponiveis = 500;
produtosDisponiveis -= 25; // Venda manhã
produtosDisponiveis -= 18; // Venda tarde
console.log("Produtos disponíveis: ", produtosDisponiveis); 
// Produtos disponíveis: 457

Multiplicação e Atribuição (*=)

let salario = 3000;
salario *= 1.1; // aumento de 10%
console.log("Novo salário: R$ ", salario);// Novo salário: R$ 3300

// Aplicação prática: juros compostos simples
let investimento = 5000;
investimento *= 1.08; // 8% ao ano
investimento *= 1.08; // segundo ano
console.log("Valor após 2 anos: R$ ", investimento.toFixed(2)); 
// Valor após 2 anos: R$ 5832.00

Divisão e Atribuição (/=)

let total = 1200;
total /= 4; // dividir por 4 pessoas
console.log("Valor por pessoa: R$ ", total); 
// Valor por pessoa: R$ 300

// Aplicação prática: média móvel simples
let somaNotas = 450;
let numeroProvas = 5;
somaNotas /= numeroProvas;
console.log("Média geral: ", somaNotas); 
// Média geral: 90

Módulo e Atribuição (%=)

let numero = 17;
numero %= 5; // resto da divisão por 5
console.log("Resto: ", numero); 
// Resto: 2

// Aplicação prática: sistema de turnos
let funcionarioId = 1247;
funcionarioId %= 3; // determinar turno (0, 1, ou 2)
let turnos = ["Manhã", "Tarde", "Noite"];
console.log("Turno: ", turnos[funcionarioId]); 
// Resultado baseado no resto

Incremento e Decremento

Operadores de Incremento (++) e Decremento (--)

Estes operadores são extremamente úteis para aumentar ou diminuir valores em 1 unidade:

let contador = 5;

// Pós-incremento: usa o valor atual, depois incrementa
console.log("Valor atual: ", contador++); 
// Valor atual: 5
console.log("Após incremento: ", contador); 
// Após incremento: 6

// Pré-incremento: incrementa primeiro, depois usa o valor
contador = 5;
console.log("Pré-incremento: ", ++contador); 
// Pré-incremento: 6
console.log("Valor final: ", contador); 
// Valor final: 6

Aplicações Práticas

Sistema de Curtidas

let curtidas = 127;
console.log("Curtidas antes: ", curtidas); 
// Curtidas antes: 127
curtidas++;
console.log("Curtidas após like: ", curtidas); 
// Curtidas após like: 128

Controle de Estoque

let produtosVendidos = 0;
let metaDiaria = 50;

// Simulando vendas ao longo do dia
produtosVendidos++; // primeira venda
produtosVendidos++; // segunda venda
produtosVendidos += 5; // venda em lote
produtosVendidos++; // mais uma venda

console.log("Vendas do dia: ", produtosVendidos); 
// Vendas do dia: 8
console.log("Restam ", (metaDiaria - produtosVendidos), " para atingir a meta"); 
// Restam 42 para atingir a meta

Valores Especiais em JavaScript

Infinity e -Infinity

JavaScript possui valores especiais para representar infinito:

console.log(1 / 0); 
// Infinity
console.log(-1 / 0); 
// -Infinity
console.log(Infinity > 1000000); 
// true

// Aplicação prática: verificação de limites
let limite = 1000;
let valor = 1 / 0;
if (valor === Infinity) {
    console.log("Valor excede todos os limites possíveis");
}

NaN (Not a Number)

Resultado de operações matemáticas inválidas:

console.log(0 / 0); 
// NaN
console.log("texto" * 2); 
// NaN
console.log(Math.sqrt(-1)); 
// NaN

// Verificando se um valor é NaN
let resultado = "abc" / 2;
if (isNaN(resultado)) {
    console.log("Operação resultou em valor inválido");
}

// Aplicação prática: validação de entrada
let idadeUsuario = "25 anos"; // entrada inválida do usuário
let idadeNumerica = +idadeUsuario;
if (isNaN(idadeNumerica)) {
    console.log("Por favor, digite apenas números para a idade");
} else {
    console.log("Idade válida: ", idadeNumerica);
}

Exemplos Práticos

Calculadora de Orçamento Familiar

// Dados do orçamento
let salario = 4500;
let salarioConjuge = 3200;
let rendaExtra = 800;

// Receitas
let receitaTotal = salario + salarioConjuge + rendaExtra;
console.log("Receita total: R$ ", receitaTotal);

// Despesas fixas
let aluguel = 1200;
let alimentacao = 800;
let transporte = 400;
let lazer = 300;

let despesasFixas = aluguel + alimentacao + transporte + lazer;
console.log("Despesas fixas: R$ ", despesasFixas);

// Cálculo da sobra
let sobra = receitaTotal - despesasFixas;
console.log("Sobra mensal: R$ ", sobra);

// Meta de economia (30% da sobra)
let percentualEconomia = 30;
let metaEconomia = sobra * (percentualEconomia / 100);
console.log("Meta de economia (30%): R$ ", metaEconomia.toFixed(2));

// Valor disponível para gastos extras
let gastosExtras = sobra - metaEconomia;
console.log("Disponível para gastos extras: R$ ", gastosExtras.toFixed(2));

Sistema de Pontuação de Jogo

// Sistema de pontuação
let pontuacaoBase = 0;
let multiplicador = 1;
let bonus = 0;

// Primeira fase
pontuacaoBase += 150; // coletou 3 itens (50 cada)
multiplicador *= 2; // power-up de multiplicador
console.log("Pontos após fase 1: ", pontuacaoBase * multiplicador);

// Segunda fase
pontuacaoBase += 200; // derrotou chefe (200 pontos)
bonus = pontuacaoBase * 0.1; // bônus de 10%
pontuacaoBase += bonus;
console.log("Pontos com bônus: ", pontuacaoBase.toFixed(0));

// Aplicando multiplicador final
let pontuacaoFinal = pontuacaoBase * multiplicador;
console.log("Pontuação final: ", pontuacaoFinal.toFixed(0));

Calculadora de Conversão de Temperatura

// Convertendo temperaturas
let celsius = 25;

// Fórmulas de conversão
let fahrenheit = celsius * 9 / 5 + 32;
let kelvin = celsius + 273.15;
let rankine = fahrenheit + 459.67;

console.log("Temperatura em Celsius: ", celsius, "°C");
console.log("Temperatura em Fahrenheit: ", fahrenheit, "°F");
console.log("Temperatura em Kelvin: ", kelvin.toFixed(2), "K");
console.log("Temperatura em Rankine: ", rankine.toFixed(2), "°R");

Boas Práticas e Dicas Importantes

Clareza e Legibilidade

Sempre prefira clareza à concisão:

// Menos claro
let r = p * (1 + t/100) ** n;

// Mais claro
let precoInicial = 1000;
let taxaJuros = 8; // 8% ao ano
let anos = 3;
let montanteFinal = precoInicial * (1 + taxaJuros/100) ** anos;

Uso de Parênteses

Use parênteses para deixar suas intenções claras:

// Ambíguo
let resultado = a + b * c - d / e;

// Claro
let resultado = a + (b * c) - (d / e);

8.3 Validação de Entrada

Precisão com Números Decimais

Cuidado com a precisão de números decimais:

// Problema de precisão
let resultado1 = 0.1 + 0.2;
console.log(resultado1); 
// 0.30000000000000004

// Solução: arredondar quando necessário
let resultado2 = Math.round((0.1 + 0.2) * 100) / 100;
console.log(resultado2); 
// 0.3

// Ou usar toFixed() para exibição
let resultado3 = (0.1 + 0.2).toFixed(2);
console.log(resultado3); 
// "0.30"

Próximos passos

Na próxima aula, conheceremos novos operadores que possibilitarão realizar tomadas de decisões no código. Você aprenderá:

  • Como realizar comparações entre dois valores
  • Como criar expreções lógicas que resultam em verdadeiro e falso
  • Como usar essas duas ferramentas para tomar decisões

A matemática, que talvez parecesse distante da programação, revela-se como uma aliada poderosa na construção de soluções digitais elegantes e eficazes.

Up next

Interviews

Explore interviews with industry experts and thought leaders.