Ruby do Zero: Entrada e Saída no Terminal com Ruby

Saída no terminal: puts, print e p

Em programas de terminal, você normalmente precisa mostrar mensagens (perguntas, instruções, resultados) e ler o que a pessoa digitou. Em Ruby, as formas mais comuns de saída são puts, print e p. Cada uma tem um comportamento útil em situações diferentes.

puts: imprime e quebra linha

puts é a opção mais usada para mensagens ao usuário. Ela imprime o conteúdo e, ao final, adiciona uma quebra de linha. Se você passar um array, ela imprime cada item em uma linha.

puts "Olá!"        # mostra Olá! e vai para a próxima linha
puts 10             # imprime 10
puts ["a", "b"]    # imprime a e b em linhas separadas

print: imprime sem quebrar linha

print não adiciona quebra de linha automaticamente. É útil para prompts (perguntas) em que você quer que o cursor fique na mesma linha da pergunta.

print "Qual é seu nome? "
nome = gets

Nesse caso, a pessoa digita na mesma linha do prompt.

p: saída “de inspeção” (útil para depurar)

p imprime uma representação mais “crua” do objeto (similar ao que você veria ao inspecionar valores). É muito útil para entender exatamente o que foi lido ou gerado, especialmente com strings contendo espaços e quebras de linha.

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

entrada = gets
p entrada

Se a pessoa digitar Ana e apertar Enter, p tende a mostrar algo como "Ana\n", deixando claro que existe um \n no final.

Leitura no terminal: gets e o problema do \n

gets lê uma linha do terminal e retorna uma string. Quando a pessoa pressiona Enter, essa quebra de linha normalmente vem junto no final do texto lido.

print "Digite algo: "
texto = gets
p texto

Para trabalhar com o valor “limpo”, use chomp, que remove a quebra de linha final.

print "Digite algo: "
texto = gets.chomp
p texto

Quando gets pode retornar nil

Em algumas situações (por exemplo, fim de entrada/EOF), gets pode retornar nil. Em scripts simples no terminal, isso é menos comum, mas é bom saber. Se você chamar chomp em nil, ocorrerá erro. Uma forma segura é:

linha = gets
linha = linha ? linha.chomp : ""

Em fluxos interativos comuns, você pode assumir que haverá entrada, mas ao criar funções reutilizáveis, essa proteção pode ser útil.

Conversão de tipos após leitura

Como gets retorna string, você quase sempre precisará converter para o tipo desejado (por exemplo, número). A conversão deve acontecer depois do chomp.

Inteiros com to_i

print "Idade: "
idade = gets.chomp.to_i
puts "Você tem #{idade} anos."

Observação importante: to_i é permissivo. Se a pessoa digitar algo não numérico, o resultado pode virar 0 (por exemplo, "abc".to_i vira 0). Por isso, quando você precisa de validação mínima, vale checar se a entrada parece um número antes de converter.

Decimais com to_f

print "Altura (ex: 1.75): "
altura = gets.chomp.to_f
puts "Altura: #{altura}"

Booleans (sim/não) via normalização

Ruby não tem uma conversão direta de string para boolean. Um padrão é normalizar a entrada (tirar espaços e padronizar letras) e comparar com opções aceitas.

print "Deseja continuar? (s/n): "
resp = gets.chomp.strip.downcase
continuar = (resp == "s" || resp == "sim")
puts continuar

Passo a passo: primeiro fluxo interativo (perguntas e respostas)

Vamos montar um mini programa que pergunta nome e idade e responde com uma mensagem. O foco aqui é: usar print para o prompt, gets.chomp para ler e converter a idade.

1) Perguntar o nome

print "Nome: "
nome = gets.chomp

2) Perguntar a idade e converter

print "Idade: "
idade = gets.chomp.to_i

3) Exibir resultado

puts "Olá, #{nome}. Você tem #{idade} anos."

Programa completo

print "Nome: "
nome = gets.chomp
print "Idade: "
idade = gets.chomp.to_i
puts "Olá, #{nome}. Você tem #{idade} anos."

Validação mínima: evitando entradas vazias

Em terminal, é comum a pessoa apertar Enter sem digitar nada. Isso gera uma string vazia ("") após o chomp. Uma validação mínima é repetir a pergunta enquanto a entrada estiver vazia (ou só com espaços).

Validando texto obrigatório

nome = ""
while nome.strip.empty?
  print "Nome (obrigatório): "
  nome = gets.chomp
end
puts "Nome registrado: #{nome}"

Aqui, strip remove espaços das pontas, então entradas como " " também são tratadas como vazias.

Validando número inteiro (mínimo)

Como to_i pode mascarar erros, uma validação mínima é verificar se a entrada contém apenas dígitos antes de converter.

idade_str = ""
while idade_str.strip.empty? || idade_str !~ /\A\d+\z/
  print "Idade (apenas números): "
  idade_str = gets.chomp
end
idade = idade_str.to_i
puts "Idade registrada: #{idade}"

\A\d+\z significa: do começo ao fim, apenas dígitos (um ou mais). Isso evita que "12abc" passe.

Lidando com entradas vazias sem loop infinito

Às vezes você quer dar um valor padrão quando a entrada vier vazia, em vez de insistir. Isso é útil para perguntas opcionais.

print "Apelido (opcional): "
apelido = gets.chomp
apelido = "(sem apelido)" if apelido.strip.empty?
puts "Apelido: #{apelido}"

Estruturando várias perguntas com clareza

Quando o programa cresce e você tem muitas perguntas, repetir print/gets/chomp/strip em todo lugar deixa o código confuso. Uma forma simples de manter clareza é criar pequenas funções para cada tipo de pergunta: texto obrigatório, texto opcional com padrão, inteiro validado, escolha sim/não.

Função para texto obrigatório

def perguntar_texto_obrigatorio(rotulo)
  valor = ""
  while valor.strip.empty?
    print "#{rotulo}: "
    valor = gets.chomp
  end
  valor
end

Função para inteiro com validação mínima

def perguntar_inteiro(rotulo)
  entrada = ""
  while entrada.strip.empty? || entrada !~ /\A\d+\z/
    print "#{rotulo}: "
    entrada = gets.chomp
  end
  entrada.to_i
end

Função para sim/não

def perguntar_sim_nao(rotulo)
  resp = ""
  while resp != "s" && resp != "n"
    print "#{rotulo} (s/n): "
    resp = gets.chomp.strip.downcase
  end
  resp == "s"
end

Usando as funções para montar um fluxo maior

Agora o “roteiro” do programa fica mais fácil de ler: primeiro coletamos dados, depois usamos os dados.

nome = perguntar_texto_obrigatorio("Nome")
idade = perguntar_inteiro("Idade")
aceita_termos = perguntar_sim_nao("Aceita os termos?")
puts "Resumo:"
puts "Nome: #{nome}"
puts "Idade: #{idade}"
puts "Aceitou termos: #{aceita_termos}"

Organizando perguntas em uma sequência (mantendo o código limpo)

Quando há muitas perguntas, você pode separar em etapas e agrupar por assunto. Mesmo sem entrar em estruturas avançadas, uma organização simples já ajuda: criar funções de “coleta” e retornar um conjunto de respostas.

Coletando dados em uma função

def coletar_dados_cadastro
  nome = perguntar_texto_obrigatorio("Nome")
  idade = perguntar_inteiro("Idade")
  newsletter = perguntar_sim_nao("Deseja receber newsletter?")
  { nome: nome, idade: idade, newsletter: newsletter }
end

dados = coletar_dados_cadastro
puts "Cadastro recebido:"
puts "Nome: #{dados[:nome]}"
puts "Idade: #{dados[:idade]}"
puts "Newsletter: #{dados[:newsletter]}"

Note que a função de coleta deixa o fluxo principal mais curto e legível. Você consegue bater o olho e entender o que o programa faz, sem se perder nos detalhes de validação.

Tabela rápida: quando usar cada comando