Ruby do Zero: Sintaxe Essencial, Comentários e Convenções de Código

Estrutura de um arquivo Ruby (.rb)

Um arquivo Ruby é uma sequência de instruções (statements) executadas de cima para baixo. Você pode escrever código “solto” no topo do arquivo ou organizar em métodos, classes e módulos. Mesmo em scripts simples, vale manter uma estrutura previsível: configurações no topo, definições (métodos/classes) no meio e execução no final.

Exemplo mínimo e legível

# arquivo: saudacao.rb

def saudacao(nome)
  "Olá, #{nome}!"
end

puts saudacao("Ana")

Observe a separação por linhas em branco: ela não é obrigatória para o Ruby funcionar, mas ajuda a leitura ao agrupar ideias.

Instruções, expressões e retorno implícito

Em Ruby, quase tudo é uma expressão: ela “produz” um valor. Um ponto importante do estilo idiomático é o retorno implícito: o valor da última expressão avaliada em um método (ou bloco) é retornado automaticamente, sem precisar escrever return.

Retorno implícito (preferido quando simples)

def dobro(n)
  n * 2
end

puts dobro(10) # 20

Quando usar return

Use return quando precisar sair mais cedo (early return) ou deixar a intenção explícita em fluxos mais complexos.

def preco_final(preco, cupom)
  return preco if cupom.nil?

  preco - cupom
end

Nesse exemplo, o return melhora a clareza: “se não há cupom, devolva o preço agora”.

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

Indentação e legibilidade

Ruby não exige indentação para funcionar, mas a comunidade segue convenções fortes: 2 espaços por nível, sem tabs. A indentação comunica estrutura (o que está dentro de quê) e reduz erros de leitura.

Comparando: ruim vs. bom

def status(nota)
if nota >= 7
"aprovado"
else
"reprovado"
end
end

def status(nota)
  if nota >= 7
    "aprovado"
  else
    "reprovado"
  end
end

O código faz a mesma coisa, mas o segundo é mais fácil de manter: você enxerga o bloco do if e do else imediatamente.

Comentários: quando e como usar

Comentários devem explicar “por quê” (intenção, regra de negócio, restrição), não “o quê” (o código já mostra). Comentários demais podem virar ruído; comentários bons evitam mal-entendidos.

Comentário de linha

Começa com # e vai até o fim da linha.

# Calcula o total com taxa fixa (regra do contrato 2024-01)
TAXA = 0.1

def total_com_taxa(valor)
  valor + (valor * TAXA)
end

Comentário de bloco (multilinha)

Você pode usar várias linhas com # (muito comum) ou o bloco =begin/=end (menos comum em projetos). Prefira múltiplas linhas com # por ser mais flexível e aceito em qualquer posição.

# Regras:
# - Frete grátis acima de 200
# - Caso contrário, frete fixo de 20

def frete(valor_compra)
  if valor_compra > 200
    0
  else
    20
  end
end

=begin
Este formato existe, mas é menos usado no dia a dia.
Ele precisa começar no início da linha.
=end

Passo a passo: melhorando um comentário

1) Evite comentar o óbvio:

# soma 1 ao contador
contador = contador + 1

2) Prefira nomear bem e remover o comentário:

contador += 1

3) Se houver regra, comente a regra:

# Incrementa a cada item processado; usado para auditoria
contador += 1

Convenções de nomes: variáveis, métodos, constantes

Convenções consistentes tornam o código previsível. Em Ruby, o padrão é:

• variáveis e métodos: snake_case
• constantes: SCREAMING_SNAKE_CASE
• classes e módulos: CamelCase
• métodos booleanos: terminam com ? (ex.: ativo?)
• métodos “perigosos” (mutam o objeto): podem terminar com ! (ex.: sort!)

Variáveis em snake_case

nome_completo = "Ana Silva"
idade_em_anos = 30

Evite abreviações obscuras. Compare:

# menos claro
qtd_it = 3

# mais claro
quantidade_itens = 3

Constantes

Constantes são usadas para valores que não devem mudar durante a execução. Em Ruby, é possível reatribuir uma constante, mas isso gera aviso e é considerado má prática.

TAXA_DE_SERVICO = 0.1
LIMITE_FRETE_GRATIS = 200

Classes e módulos (CamelCase)

class CalculadoraDeFrete
  def initialize(limite)
    @limite = limite
  end
end

Strings, números e interpolação: escrita clara

Escolhas pequenas de escrita afetam a clareza. Um exemplo comum é preferir interpolação a concatenação quando há variáveis.

Concatenação vs. interpolação

nome = "Ana"

# menos legível
mensagem = "Olá, " + nome + "!"

# mais legível
mensagem = "Olá, #{nome}!"

Organizando pequenas decisões de estilo

Estilo idiomático é um conjunto de decisões consistentes. Abaixo, alguns pontos que melhoram manutenção sem mudar a lógica.

Preferir guard clauses (early return) para reduzir aninhamento

# mais aninhado
def pode_comprar?(idade, autorizado)
  if autorizado
    if idade >= 18
      true
    else
      false
    end
  else
    false
  end
end

# mais direto
def pode_comprar?(idade, autorizado)
  return false unless autorizado
  idade >= 18
end

Note como o retorno implícito deixa a última linha expressiva: a condição já é um booleano.

Usar nomes que eliminam comentários

# ruim: comentário tenta compensar nome fraco
# verifica se o usuário pode acessar
def check(u)
  u[:role] == "admin"
end

# melhor: intenção no nome
def admin?(usuario)
  usuario[:role] == "admin"
end

Passo a passo prático: refatorando um script para ficar idiomático

Vamos partir de um script funcional, porém difícil de ler, e melhorar em etapas.

Versão inicial (funciona, mas confusa)

def calc(v,c)
if c==nil
return v
else
return v-(v*c)
end
end

v=100
c=0.1
puts calc(v,c)

Passo 1: nomes claros e indentação

def calcular_total(valor, cupom)
  if cupom == nil
    return valor
  else
    return valor - (valor * cupom)
  end
end

valor = 100
cupom = 0.1
puts calcular_total(valor, cupom)

Passo 2: usar nil? e reduzir return desnecessário

def calcular_total(valor, cupom)
  if cupom.nil?
    valor
  else
    valor - (valor * cupom)
  end
end

Passo 3: aplicar guard clause para simplificar

def calcular_total(valor, cupom)
  return valor if cupom.nil?

  valor - (valor * cupom)
end

Passo 4: constantes para regras fixas (quando fizer sentido)

DESCONTO_PADRAO = 0.1

def calcular_total(valor, cupom = DESCONTO_PADRAO)
  valor - (valor * cupom)
end

Perceba como cada passo melhora um aspecto: nomes, estrutura visual, uso de métodos idiomáticos (nil?), retorno implícito e redução de ramificações.

Erros comuns de sintaxe e como evitá-los

Esquecer end

Estruturas como def, if, class e module precisam de end. Uma boa indentação ajuda a “contar” os blocos.

def exemplo(x)
  if x > 0
    "positivo"
  end
end

Confundir = com ==

= atribui valor; == compara.

valor = 10
puts valor == 10 # true

Usar nomes inconsistentes

Se você começa com valor_total, não alterne para totalValor. Consistência reduz carga mental.