Aprenda Ruby em 10 minutos

8 October 2025 — Linguagem De Programação

Ruby é uma linguagem de programação dinâmica e orientada a objetos conhecida por sua sintaxe elegante e recursos amigáveis ao desenvolvedor. Este tutorial aborda os conceitos fundamentais do Ruby para ajudá-lo a aprender a linguagem rapidamente.

1. Escrevendo Seu Primeiro Programa em Ruby

Vamos começar com um programa simples. Crie um arquivo chamado hello.rb e insira o seguinte código:

puts "Hello, World!"

Salve o arquivo e execute o seguinte comando no terminal:

ruby hello.rb

A saída será:

Hello, World!

Este programa simples demonstra a funcionalidade básica de saída do Ruby. O método puts é usado para exibir informações de texto no console.

2. Sintaxe Básica

A sintaxe do Ruby é limpa e legível, projetada para ser natural e intuitiva.

# Este é um comentário
puts "Hello, World!"

Regras básicas de sintaxe no Ruby:

Comentários: Comentários de uma linha começam com #, enquanto comentários de várias linhas usam =begin e =end.
Declarações: Normalmente uma declaração por linha, não é necessário ponto e vírgula ; no final.
Blocos de Código: Definidos por do...end ou chaves {}.
Chamadas de Método: Parênteses são opcionais para chamadas de método sem argumentos.

Exemplo com comentários de várias linhas:

=begin
Este é um comentário de várias linhas,
que abrange múltiplas linhas.
=end

3. Variáveis e Tipos de Dados

No Ruby, as variáveis são tipadas dinamicamente e não requerem declarações de tipo explícitas.

Regras básicas de nomenclatura de variáveis:

Nomes de variáveis podem conter apenas letras, números e sublinhados.
Nomes de variáveis não podem começar com um número.
Nomes de variáveis diferenciam maiúsculas de minúsculas.
Palavras-chave do Ruby não podem ser usadas como nomes de variáveis.

Os principais tipos de dados básicos do Ruby são:

Inteiro (Integer): por exemplo, 42 ou -10.
Ponto Flutuante (Float): por exemplo, 3.14 ou 2.5e3.
String (String): por exemplo, "hello" ou 'world', usando aspas simples ou duplas.
Booleano (Boolean): true ou false.
Nil (Nil): Representado por nil, indicando nulo ou sem valor.
Símbolo (Symbol): por exemplo, :name, identificadores imutáveis.

3.1 Tipos Numéricos

Ruby suporta inteiros e números de ponto flutuante.

# Inteiro
idade = 25
populacao = 1_000_000  # Sublinhados para legibilidade

# Ponto flutuante
temperatura = 36.5
pi = 3.14159

# Operações
puts 10 + 5   # 15
puts 10 / 3   # 3 (divisão inteira)
puts 10.0 / 3 # 3.333... (divisão de ponto flutuante)

3.2 String

Strings são sequências de caracteres, delimitadas por aspas simples ou duplas.

aspas_simples = 'String com aspas simples'
aspas_duplas = "String com aspas duplas"
multilinha = "Esta é uma
string de múltiplas linhas"

# Interpolação de string (apenas em aspas duplas)
nome = "Alice"
saudacao = "Olá, #{nome}!"
puts saudacao  # "Olá, Alice!"

Operações com strings:

texto = "Programação Ruby"
puts texto.length        # Comprimento da string
puts texto.upcase        # Converter para maiúsculas
puts texto.downcase      # Converter para minúsculas
puts texto[0]            # Acessar primeiro caractere
puts texto[0..3]         # Fatiamento de string
puts texto.include?("Ruby")  # Verificar inclusão

3.3 Tipo Booleano

O tipo booleano tem dois valores: true e false.

esta_ativo = true
esta_completo = false

# Operações booleanas
resultado1 = true && false  # false
resultado2 = true || false  # true
resultado3 = !true          # false

3.4 Tipo Nil

nil representa um estado nulo ou sem valor.

valor = nil

if valor.nil?
  puts "Valor é nulo"
end

3.5 Símbolo

Símbolos são identificadores imutáveis, frequentemente usados como chaves em hashes.

:name
:email
:created_at

# Símbolos vs Strings
puts :name.object_id == :name.object_id  # true (mesmo objeto)
puts "name".object_id == "name".object_id  # false (objetos diferentes)

4. Estruturas de Dados

Ruby fornece várias estruturas de dados embutidas para armazenar e manipular dados.

4.1 Array

Um array é uma coleção ordenada que pode conter múltiplos valores.

numeros = [1, 2, 3, 4, 5]
numeros.push(6)        # Adicionar elemento
numeros.unshift(0)     # Inserir no início
numeros.delete(3)      # Remover valor específico
numeros[0] = 10        # Modificar elemento
puts numeros.inspect   # [10, 2, 4, 5, 6]

Operações com arrays:

numeros = [10, 20, 30, 40, 50]
puts numeros[1..3]     # [20, 30, 40]
puts numeros.first     # 10
puts numeros.last      # 50
puts numeros.include?(30)  # true

4.2 Hash

Um hash é uma coleção de pares chave-valor, semelhante a dicionários em outras linguagens.

estudante = {
  name: "John",
  age: 20,
  major: "Computer Science"
}

# Acessando e modificando hash
puts estudante[:name]
estudante[:age] = 21
estudante[:gpa] = 3.8

# Iterando sobre hash
estudante.each do |chave, valor|
  puts "#{chave}: #{valor}"
end

5. Controle de Fluxo

Ruby fornece várias declarações de controle de fluxo para gerenciar a execução do programa.

5.1 Declarações if

A declaração if avalia uma condição e executa seu bloco se a condição for verdadeira.

idade = 20
if idade >= 18
  puts "Adulto"
elsif idade >= 13
  puts "Adolescente"
else
  puts "Criança"
end

# if em uma linha
puts "Adulto" if idade >= 18

5.2 Declarações unless

unless é o oposto de if - executa quando a condição é falsa.

idade = 15
unless idade >= 18
  puts "Não é adulto"
end

# unless em uma linha
puts "Não é adulto" unless idade >= 18

5.3 Declarações case

Declarações case fornecem uma maneira limpa de lidar com múltiplas condições.

nota = "B"

case nota
when "A"
  puts "Excelente"
when "B"
  puts "Bom"
when "C"
  puts "Médio"
else
  puts "Precisa melhorar"
end

5.4 Loops

Ruby suporta várias construções de loop.

Loop while:

contador = 0
while contador < 5
  puts contador
  contador += 1
end

Loop until:

contador = 0
until contador >= 5
  puts contador
  contador += 1
end

Loop for:

for i in 0..4
  puts i
end

Iterador each:

(0..4).each do |i|
  puts i
end

# Com arrays
frutas = ["maçã", "banana", "cereja"]
frutas.each do |fruta|
  puts fruta
end

break e next:

(0..9).each do |i|
  break if i == 5     # Sair do loop
  next if i % 2 == 0  # Pular números pares
  puts i              # Saída: 1, 3
end

6. Métodos

Métodos em Ruby são definidos usando a palavra-chave def.

Definição Básica de Método:

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

# Chamando o método
mensagem = saudar("John")
puts mensagem

Parâmetros Padrão:

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

puts saudar("Alice")          # "Olá, Alice!"
puts saudar("Bob", "Oi")      # "Oi, Bob!"

Argumentos Variáveis:

def somar_numeros(*numeros)
  numeros.sum
end

puts somar_numeros(1, 2, 3, 4)  # 10

Argumentos de Palavra-Chave:

def criar_pessoa(nome:, idade:, cidade: "Desconhecida")
  { nome: nome, idade: idade, cidade: cidade }
end

pessoa = criar_pessoa(nome: "Alice", idade: 25)
puts pessoa.inspect

7. Blocos e Procs

Blocos são pedaços de código que podem ser passados para métodos.

Usando Blocos:

# Usando do...end
3.times do
  puts "Olá!"
end

# Usando chaves
3.times { puts "Olá!" }

# Blocos com parâmetros
(1..3).each do |numero|
  puts "Número: #{numero}"
end

Palavra-Chave Yield:

def executar_bloco
  puts "Antes do bloco"
  yield
  puts "Depois do bloco"
end

executar_bloco { puts "Dentro do bloco" }

Procs:

Procs são objetos que encapsulam blocos.

quadrado = Proc.new { |x| x * x }
puts quadrado.call(5)  # 25

# Passando procs para métodos
def aplicar_operacao(numeros, operacao)
  numeros.map { |n| operacao.call(n) }
end

numeros = [1, 2, 3, 4]
quadrados = aplicar_operacao(numeros, quadrado)
puts quadrados.inspect  # [1, 4, 9, 16]

8. Classes e Objetos

Ruby é uma linguagem puramente orientada a objetos onde tudo é um objeto.

Definição Básica de Classe:

class Pessoa
  def initialize(nome, idade)
    @nome = nome
    @idade = idade
  end

  def apresentar
    "Eu sou #{@nome}, #{@idade} anos"
  end

  def fazer_aniversario
    @idade += 1
    "#{@nome} fez aniversário, agora tem #{@idade} anos"
  end
end

# Criando objetos
pessoa1 = Pessoa.new("John", 25)
pessoa2 = Pessoa.new("Jane", 30)

puts pessoa1.apresentar
puts pessoa2.fazer_aniversario

Métodos Acessores:

class Pessoa
  attr_reader :nome    # Acesso de leitura
  attr_writer :idade   # Acesso de escrita
  attr_accessor :cidade  # Acesso de leitura e escrita

  def initialize(nome, idade, cidade)
    @nome = nome
    @idade = idade
    @cidade = cidade
  end
end

pessoa = Pessoa.new("Alice", 25, "Nova York")
puts pessoa.nome      # "Alice"
pessoa.idade = 26       # Definir idade
pessoa.cidade = "Boston" # Definir cidade
puts pessoa.cidade      # "Boston"

Métodos de Classe e Variáveis:

class Estudante
  @@contador_estudantes = 0  # Variável de classe

  def initialize(nome)
    @nome = nome
    @@contador_estudantes += 1
  end

  def self.contador_estudantes  # Método de classe
    @@contador_estudantes
  end
end

estudante1 = Estudante.new("John")
estudante2 = Estudante.new("Jane")
puts Estudante.contador_estudantes  # 2

Herança:

class Animal
  def initialize(nome)
    @nome = nome
  end

  def falar
    "#{@nome} faz um som"
  end
end

class Cachorro < Animal
  def falar
    "#{@nome} late"
  end
end

class Gato < Animal
  def falar
    "#{@nome} mia"
  end
end

cachorro = Cachorro.new("Buddy")
gato = Gato.new("Mimi")

puts cachorro.falar  # "Buddy late"
puts gato.falar      # "Mimi mia"

9. Módulos e Mixins

Módulos são usados para agrupar métodos e constantes relacionados, e podem ser misturados em classes.

Definição de Módulo:

module Falavel
  def falar
    "#{@nome} diz algo"
  end
end

class Pessoa
  include Falavel

  def initialize(nome)
    @nome = nome
  end
end

pessoa = Pessoa.new("Alice")
puts pessoa.falar  # "Alice diz algo"

Namespacing com Módulos:

module Matematica
  PI = 3.14159

  def self.quadrado(x)
    x * x
  end
end

puts Matematica::PI        # 3.14159
puts Matematica.quadrado(5)  # 25

10. Tratamento de Exceções

Ruby fornece tratamento robusto de exceções usando begin, rescue, ensure e raise.

Tratamento Básico de Exceções:

begin
  resultado = 10 / 0
rescue ZeroDivisionError => e
  puts "Não é possível dividir por zero: #{e.message}"
else
  puts "Divisão bem-sucedida"
ensure
  puts "Isso sempre executa"
end

Lançando Exceções:

def dividir(a, b)
  raise "Não é possível dividir por zero" if b == 0
  a / b
end

begin
  resultado = dividir(10, 0)
rescue => e
  puts "Erro: #{e.message}"
end

11. Operações com Arquivos

Ruby fornece métodos simples para ler e escrever arquivos.

Lendo Arquivos:

# Ler arquivo inteiro
conteudo = File.read("exemplo.txt")
puts conteudo

# Ler linha por linha
File.foreach("exemplo.txt") do |linha|
  puts linha.chomp
end

Escrevendo Arquivos:

# Escrever no arquivo
File.write("saida.txt", "Olá, Ruby!\n")

# Anexar ao arquivo
File.open("saida.txt", "a") do |arquivo|
  arquivo.puts "Anexando novo conteúdo."
end

12. Métodos Úteis Embarcados

Ruby vem com muitos métodos úteis embarcados.

Métodos de String:

texto = "  Programação Ruby  "
puts texto.strip        # Remover espaços em branco
puts texto.split(" ")   # Dividir em array
puts texto.gsub("Ruby", "Python")  # Substituir

Métodos de Array:

numeros = [3, 1, 4, 1, 5, 9, 2]
puts numeros.sort.inspect      # [1, 1, 2, 3, 4, 5, 9]
puts numeros.uniq.inspect      # [3, 1, 4, 5, 9, 2]
puts numeros.select { |n| n > 3 }.inspect  # [4, 5, 9]

Métodos de Hash:

pessoa = { nome: "Alice", idade: 25, cidade: "Nova York" }
puts pessoa.keys.inspect    # [:nome, :idade, :cidade]
puts pessoa.values.inspect  # ["Alice", 25, "Nova York"]
puts pessoa.has_key?(:idade)  # true

13. Ruby Gems

RubyGems é o gerenciador de pacotes do Ruby para instalar e gerenciar bibliotecas.

Instalando Gems:

gem install rails

Usando Gems no Código:

require 'json'

# Analisar JSON
string_json = '{"name": "Alice", "age": 25}'
pessoa = JSON.parse(string_json)
puts pessoa["name"]  # "Alice"

# Gerar JSON
hash_pessoa = { name: "Bob", age: 30 }
saida_json = JSON.generate(hash_pessoa)
puts saida_json  # {"name":"Bob","age":30}

14. Guia de Estilo Ruby

Ruby tem um guia de estilo da comunidade forte que promove código limpo e legível.

Indentação: Use 2 espaços para indentação.

Convenções de Nomenclatura:

Variáveis e métodos: snake_case
Classes e módulos: CamelCase
Constantes: SCREAMING_SNAKE_CASE

Parênteses: Use parênteses para chamadas de método com argumentos, omita para chamadas de método sem argumentos.

Blocos: Use do...end para blocos de múltiplas linhas, {} para blocos de uma linha.

A sintaxe elegante e os recursos poderosos do Ruby tornam-no um prazer de trabalhar. Seu foco na felicidade e produtividade do desenvolvedor o tornou popular para desenvolvimento web, scripting e tarefas de automação.