Ruby do Zero: Operadores, Comparações e Expressões Booleanas

Operadores aritméticos

Operadores aritméticos produzem valores numéricos a partir de outros valores numéricos. Em Ruby, eles funcionam de forma direta e costumam ser lidos como “expressões” (um resultado), não como “comandos”.

Divisão inteira vs divisão com decimais

Um ponto importante: quando ambos os operandos são inteiros, a divisão / pode resultar em inteiro (truncando a parte decimal).

5 / 2     # => 2 (inteiro, parte decimal descartada)

Para obter resultado decimal, garanta que pelo menos um lado seja decimal.

5.0 / 2   # => 2.5

Precedência e parênteses

Ruby segue a precedência matemática comum: multiplicação/divisão antes de soma/subtração. Use parênteses para deixar a intenção explícita.

10 + 2 * 3     # => 16 (2*3 primeiro)  (10 + 2) * 3 # => 36

Operadores de comparação

Operadores de comparação retornam um valor booleano (true ou false) e são a base para condicionais e validações.

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

O operador <=> (spaceship)

O <=> retorna -1 se o lado esquerdo for menor, 0 se for igual e 1 se for maior. Ele é muito usado internamente em ordenações e comparações mais avançadas.

3 <=> 3  # => 0 10 <=> 7 # => 1

Expressões booleanas e operadores lógicos

Operadores lógicos combinam condições e retornam um valor que, em contextos condicionais, é interpretado como verdadeiro ou falso.

&& (E), || (OU), ! (NÃO)

• a && b: verdadeiro quando a e b são verdadeiros.
• a || b: verdadeiro quando a ou b é verdadeiro.
• !a: inverte o valor lógico (negação).

idade = 20 tem_cnh = true pode_dirigir = (idade >= 18) && tem_cnh  # => true

Curto-circuito (short-circuit) e retorno do próprio valor

Em Ruby, && e || fazem curto-circuito: podem nem avaliar a segunda parte se a primeira já determina o resultado. Além disso, eles retornam o próprio valor avaliado, não necessariamente true/false.

nil || "padrão"     # => "padrão" "ok" || "padrão"    # => "ok" false && "x"       # => false true && "x"        # => "x"

Isso é útil para definir valores padrão e para escrever validações de forma natural.

Truthy e falsy em Ruby

Ruby tem uma regra simples: apenas false e nil são falsy. Todo o resto é truthy (incluindo 0, strings vazias "", arrays vazios [] etc.).

if 0   # entra aqui, porque 0 é truthy end if ""  # entra aqui, porque string vazia é truthy end

Essa regra influencia diretamente como você escreve condicionais: em vez de comparar com == true ou != nil, geralmente basta usar a própria expressão.

Evitando redundâncias comuns

Evite comparações desnecessárias que deixam o código mais verboso e menos idiomático.

# Redundante if ativo == true   # ... end # Melhor if ativo   # ... end # Redundante if usuario != nil   # ... end # Melhor if usuario   # ... end

Operador idiomático ||= (atribuição condicional)

O operador ||= atribui um valor apenas se a variável atual for falsy (nil ou false). É uma forma comum de definir “padrões” ou inicializar algo uma única vez.

nome = nil nome ||= "Visitante"  # => agora nome é "Visitante" nome ||= "Outro"      # => continua "Visitante"

Como "" é truthy, ||= não substitui string vazia. Se você quer tratar string vazia como “ausente”, precisa de outra regra (por exemplo, checar empty?), mas isso já é uma decisão de negócio, não uma regra do Ruby.

Passo a passo prático: validação de dados com condições combinadas

A seguir, um passo a passo para validar dados de entrada usando comparações e operadores lógicos, priorizando leitura natural e evitando redundâncias.

Exemplo 1: validação de faixa e formato (idade)

Objetivo: aceitar uma idade somente se estiver em um intervalo permitido.

Passo 1: defina os limites como constantes/variáveis para facilitar leitura.

min = 18 max = 65

Passo 2: escreva a condição como uma frase: “idade é maior/igual a min e menor/igual a max”.

idade = 20 idade_valida = (idade >= min) && (idade <= max) # => true

Passo 3: use a expressão diretamente em uma condicional (sem == true).

if idade_valida   # processa cadastro end

Exemplo 2: validação de login com múltiplas regras

Objetivo: permitir login se (tem email) e (tem senha) e (não está bloqueado).

Passo 1: modele as variáveis (simulando dados).

email = "ana@exemplo.com" senha = "secreta" bloqueado = false

Passo 2: combine condições com leitura natural. Note como a negação fica clara com !.

pode_logar = email && senha && !bloqueado

Passo 3: use curto-circuito a seu favor. Se email for nil, Ruby nem avalia o resto, e pode_logar vira nil (falsy), o que já serve para a condicional.

if pode_logar   # autentica end

Observação importante: como && retorna o último valor avaliado, pode_logar pode ser uma string (por exemplo, a senha) em vez de true. Isso é normal em Ruby. Se você precisa de um booleano explícito, use dupla negação.

pode_logar_bool = !!(email && senha && !bloqueado) # => true/false

Exemplo 3: regras alternativas com || (OU) e agrupamento

Objetivo: permitir acesso se for admin ou se (for membro e estiver ativo).

Passo 1: defina os estados.

admin = false membro = true ativo = true

Passo 2: use parênteses para deixar a intenção inequívoca.

pode_acessar = admin || (membro && ativo) # => true

Passo 3: evite redundâncias como admin == true e prefira nomes de variáveis que já expressem booleanos.

Padrões úteis para escrever condições mais legíveis

1) Prefira variáveis com nomes booleanos

Quando uma variável representa uma condição, nomeie como pergunta/estado. Isso reduz necessidade de comentários e torna a expressão autoexplicativa.

maior_de_idade = idade >= 18 tem_permissao = admin || (membro && ativo) if maior_de_idade && tem_permissao   # ... end

2) Use || para fallback e ||= para inicialização

tema = nil tema ||= "claro" # inicializa uma vez idioma = nil idioma = idioma || "pt-BR" # fallback explícito (equivalente, mais verboso)

3) Negação com cuidado para não “embaralhar” a leitura

Negar expressões longas pode dificultar. Sempre que possível, prefira escrever a condição positiva.

# Mais difícil de ler if !(membro && ativo)   # ... end # Mais natural (condição positiva) if !membro || !ativo   # ... end

Nem sempre a forma “positiva” é menor, mas costuma ser mais clara quando você está descrevendo regras de negócio.