Ruby do Zero: Tipos Primitivos, Nil e Conversões de Tipo

Tipos primitivos mais usados em Ruby

Em Ruby, quase tudo é um objeto. Isso inclui números, textos e valores lógicos. Entender os tipos mais comuns ajuda a escolher a representação certa para cada dado e a evitar conversões inesperadas.

Integer

Integer representa números inteiros (sem casas decimais). Use quando você trabalha com contagens, índices, quantidades discretas e operações que não precisam de frações.

idade = 28        # Integer
itens = 3 + 2     # 5
negativo = -10

Operações comuns: +, -, *, /, % (resto), ** (potência).

10 / 3    # 3 (divisão inteira quando ambos são Integer)
10 % 3    # 1

Float

Float representa números com casas decimais. Use para medidas, valores monetários aproximados, médias e cálculos que exigem frações.

altura = 1.75
media = (7.5 + 8.0) / 2

Armadilha comum: Float pode ter imprecisão por representar números em ponto flutuante.

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

0.1 + 0.2  # 0.30000000000000004

Quando precisão exata é necessária (por exemplo, dinheiro), costuma-se usar inteiros (centavos) ou tipos específicos (como BigDecimal), mas aqui o foco é entender o comportamento do Float.

String

String representa texto. Use para nomes, mensagens, entradas do usuário e qualquer dado textual.

nome = "Ana"
mensagem = "Olá, #{nome}!"

Strings podem ser concatenadas e manipuladas:

"Ruby" + " " + "Zero"   # "Ruby Zero"
"abc".upcase             # "ABC"
"  oi  ".strip           # "oi"

Symbol

Symbol é um identificador imutável, muito usado como chave em hashes, nomes de opções e “rótulos” internos. Diferente de String, símbolos não são pensados para texto exibido ao usuário.

status = :ativo
config = { tema: :escuro, idioma: :pt }

Quando usar:

• Chaves de Hash quando você controla os nomes e quer consistência.
• Valores de enumeração (ex.: :asc, :desc, :admin, :guest).

TrueClass e FalseClass (booleanos)

Em Ruby, true e false são objetos de classes diferentes: TrueClass e FalseClass. Use para representar condições e resultados lógicos.

maior_de_idade = idade >= 18
ativo = true
bloqueado = false

Regra importante: em Ruby, apenas false e nil são “falsos” em condições. Todo o resto é “verdadeiro”, inclusive 0 e "" (string vazia).

if 0
  "0 é considerado verdadeiro"
end
if ""
  "string vazia é considerada verdadeira"
end

NilClass

nil representa “ausência de valor”. Ele aparece quando algo não existe, não foi encontrado ou ainda não foi definido de forma útil.

valor = nil

Exemplos comuns:

• Busca que não encontra resultado.
• Variável inicializada sem valor útil.
• Campos opcionais.

Armadilha: tentar usar nil em operações numéricas ou chamar métodos que não existem para nil pode gerar erro.

nil + 1          # TypeError
nil.downcase     # NoMethodError

Conversões explícitas de tipo

Conversões explícitas são quando você decide transformar um valor em outro tipo usando métodos como to_i, to_f, to_s e to_sym. Isso é essencial ao lidar com entrada do usuário (normalmente texto) e ao preparar dados para cálculos.

to_i (para Integer)

to_i tenta extrair um inteiro do começo da string. Se não houver um número válido no início, o resultado é 0, o que pode mascarar erros.

"42".to_i        # 42
"42abc".to_i     # 42
"abc42".to_i     # 0
"".to_i          # 0
nil.to_i         # NoMethodError (nil não tem to_i)

Armadilha principal: "abc".to_i virar 0 pode fazer você aceitar uma entrada inválida como se fosse “zero”.

to_f (para Float)

to_f funciona de forma parecida, retornando 0.0 quando não encontra número no início.

"3.14".to_f      # 3.14
"3.14abc".to_f   # 3.14
"abc".to_f       # 0.0

to_s (para String)

to_s converte valores para texto. É útil para exibir dados e concatenar mensagens.

10.to_s          # "10"
true.to_s        # "true"
nil.to_s         # "" (string vazia)

Armadilha: nil.to_s vira "". Isso pode esconder a ausência de valor em relatórios ou logs se você não tratar nil antes.

to_sym (para Symbol)

to_sym converte uma string em símbolo. Útil quando você recebe uma opção em texto e quer comparar com símbolos padronizados.

"ativo".to_sym   # :ativo
"tema".to_sym    # :tema

Armadilha: nil.to_sym gera erro, e converter entradas livres do usuário para símbolo sem controle pode criar muitos símbolos diferentes (em geral, prefira validar e limitar o conjunto de valores aceitos).

Conversões seguras e previsíveis (validação antes de converter)

Como to_i e to_f podem “aceitar” strings inválidas retornando zero, uma prática comum é validar o formato antes de converter. A seguir, exemplos simples usando regex.

Validando Integer antes de converter

Uma validação básica para inteiro (com sinal opcional):

def inteiro_valido?(texto)
  !!(texto =~ /\A[+-]?\d+\z/)
end

inteiro_valido?("10")     # true
inteiro_valido?("-3")     # true
inteiro_valido?("3.2")    # false
inteiro_valido?("abc")    # false
inteiro_valido?("10abc")  # false

Se for válido, converta com to_i com mais confiança.

Validando Float antes de converter

Uma validação simples para decimal com ponto (não cobre todos os formatos possíveis, mas é suficiente para exercícios iniciais):

def float_valido?(texto)
  !!(texto =~ /\A[+-]?\d+(\.\d+)?\z/)
end

float_valido?("10")      # true
float_valido?("10.5")    # true
float_valido?("10.")     # false
float_valido?(".5")      # false
float_valido?("abc")     # false

Tratando nil em operações

Quando um valor pode ser nil, você precisa decidir um comportamento: recusar, substituir por padrão, ou pular a operação.

• Substituir por padrão com ||:

desconto = nil
valor_desconto = desconto || 0
# valor_desconto = 0

• Evitar chamar método em nil com navegação segura &.:

nome = nil
nome_minusculo = nome&.downcase  # nil (não dá erro)

Use &. quando “não ter valor” é aceitável e você quer propagar nil. Se for obrigatório, valide e mostre erro.

Passo a passo prático: entrada simulada e conversões

Nos exemplos abaixo, vamos simular entradas do usuário como strings (como se viessem de um formulário ou do teclado). O objetivo é praticar conversões com validação.

Exercício guiado 1: Somar dois inteiros com validação

Objetivo: receber duas entradas (strings), validar se são inteiros e somar.

Passo 1: crie a função de validação.

def inteiro_valido?(texto)
  !!(texto =~ /\A[+-]?\d+\z/)
end

Passo 2: simule entradas e valide.

entrada_a = "12"
entrada_b = "7"

if inteiro_valido?(entrada_a) && inteiro_valido?(entrada_b)
  a = entrada_a.to_i
  b = entrada_b.to_i
  puts a + b
else
  puts "Entrada inválida: digite apenas inteiros."
end

Teste de armadilha: troque entrada_b para "7x". Sem validação, "7x".to_i viraria 7 e você somaria como se estivesse correto. Com validação, você detecta o erro.

Exercício guiado 2: Calcular média com Float e validação

Objetivo: receber duas notas (podem ter decimais) e calcular a média.

Passo 1: função de validação de float.

def float_valido?(texto)
  !!(texto =~ /\A[+-]?\d+(\.\d+)?\z/)
end

Passo 2: simule entradas e converta com to_f apenas se forem válidas.

nota1_txt = "7.5"
nota2_txt = "8"

if float_valido?(nota1_txt) && float_valido?(nota2_txt)
  n1 = nota1_txt.to_f
  n2 = nota2_txt.to_f
  media = (n1 + n2) / 2
  puts media
else
  puts "Notas inválidas: use números como 8 ou 7.5"
end

Teste de armadilha: use nota1_txt = "abc". Sem validação, "abc".to_f vira 0.0 e a média fica errada sem aviso.

Exercício guiado 3: Opções com Symbol (menu simples)

Objetivo: receber uma opção textual e transformar em símbolo para comparar com um conjunto permitido.

Passo 1: defina as opções aceitas como símbolos.

opcoes_validas = [:criar, :listar, :sair]

Passo 2: simule a entrada e normalize.

entrada = "listar"

opcao = entrada.strip.downcase.to_sym

if opcoes_validas.include?(opcao)
  puts "Opção ok: #{opcao}"
else
  puts "Opção inválida. Use: criar, listar, sair"
end

Observação: aqui a conversão para símbolo é segura porque você limita o conjunto com opcoes_validas. Se a entrada fosse livre e sem limite, você preferiria comparar como string normalizada.

Exercício guiado 4: Lidando com nil em dados opcionais

Objetivo: simular um campo opcional (por exemplo, cupom de desconto) que pode vir como nil ou string vazia, e aplicar um padrão.

Passo 1: simule entradas possíveis.

cupom_txt = nil  # poderia ser "" ou "10"

Passo 2: normalize para string e valide.

def inteiro_valido?(texto)
  !!(texto =~ /\A\d+\z/)
end

cupom_normalizado = cupom_txt.to_s.strip

if cupom_normalizado == ""
  desconto = 0
elsif inteiro_valido?(cupom_normalizado)
  desconto = cupom_normalizado.to_i
else
  puts "Cupom inválido"
  desconto = 0
end

puts "Desconto aplicado: #{desconto}"

Ponto-chave: nil.to_s vira "", então você consegue tratar nil e string vazia de forma uniforme. Ao mesmo tempo, você valida para não aceitar "abc" como 0.

Tabela rápida: quando usar e como converter