Fundamentos da linguagem Ruby

Ruby é uma linguagem de programação dinâmica, fortemente tipada e orientada a objetos, conhecida por possuir uma sintaxe simples e expressiva. Um dos princípios fundamentais da linguagem é que tudo é um objeto, incluindo números, strings, true, false e nil.

---

1. Sintaxe básica

Ruby possui uma sintaxe enxuta. Não é necessário utilizar ; ao final das instruções.

name = "Tiago"
age = 25

puts name
puts age

Blocos de código são delimitados principalmente por palavras-chave como end.

if age >= 18
  puts "Maior de idade"
end

Comentários

Comentário de uma linha:

# Este é um comentário

Comentários de múltiplas linhas podem ser escritos com =begin e =end, embora o # seja mais comum.

---

2. Variáveis

Ruby não exige declaração explícita de variáveis. O tipo é determinado pelo valor atribuído.

name = "Tiago"
age = 25
active = true

As variáveis podem receber valores de tipos diferentes:

value = 10
value = "Ruby"

Isso é possível porque Ruby possui tipagem dinâmica.

Tipos de variáveis

Ruby possui diferentes tipos de variáveis:

name = "Tiago"     # variável local
@name = "Tiago"    # variável de instância
@@count = 10       # variável de classe
$version = "1.0"   # variável global

No desenvolvimento cotidiano, variáveis locais e de instância são as mais comuns.

---

3. Constantes

Constantes são identificadas por nomes iniciados com letra maiúscula.

PI = 3.14159
MAX_USERS = 100

Por convenção, constantes com mais de uma palavra utilizam SCREAMING_SNAKE_CASE.

DEFAULT_TIMEOUT = 30

Uma constante pode ser alterada, mas Ruby emite um aviso.

---

4. Tipos básicos

Ruby possui diversos tipos fundamentais.

Integer

Representa números inteiros.

age = 25
quantity = 10

Float

Representa números com ponto decimal.

price = 19.90
temperature = 36.5

String

Representa textos.

name = "Tiago"
message = 'Hello Ruby'

Strings podem utilizar aspas simples ou duplas. Aspas duplas permitem interpolação:

name = "Tiago"

puts "Olá, #{name}!"

Boolean

Ruby possui dois valores booleanos:

true
false

Nil

nil representa a ausência de um valor.

user = nil

Uma característica importante:

nil.nil?
# => true

Em Ruby, apenas false e nil são considerados falsos em condições. Valores como 0, "" e [] são verdadeiros.

---

5. Arrays

Arrays representam coleções ordenadas de elementos.

names = ["Tiago", "João", "Maria"]

Os elementos são acessados por índice, começando em 0.

names[0]
# => "Tiago"

Um array pode conter diferentes tipos:

values = [10, "Ruby", true, nil]

Também é possível criar arrays vazios:

names = []

---

6. Hashes

Hashes armazenam dados no formato chave → valor.

user = {
  name: "Tiago",
  age: 25,
  active: true
}

Acessando valores:

user[:name]
# => "Tiago"

user[:age]
# => 25

As chaves podem ser de diferentes tipos, mas símbolos são muito comuns:

user = {
  name: "Tiago",
  age: 25
}

---

7. Símbolos

Símbolos são identificadores imutáveis representados normalmente por :.

:name
:email
:status

São muito utilizados como chaves de hashes:

user = {
  name: "Tiago",
  email: "tiago@example.com"
}

Também podem ser comparados:

:name == :name
# => true

---

8. Operadores

Aritméticos

10 + 5
10 - 5
10 * 5
10 / 5
10 % 3
2 ** 3

Comparação

10 == 10
10 != 5
10 > 5
10 < 5
10 >= 10
10 <= 10

Operadores lógicos

age >= 18 && active

Principais operadores:

&&  # E
||  # OU
!   # NÃO

Ruby também possui operadores textuais:

age >= 18 and active
age >= 18 or active
not active

Apesar de existirem, &&, || e ! são mais comuns.

---

9. Condicionais

if / elsif / else

if age >= 18
  puts "Maior de idade"
elsif age >= 12
  puts "Adolescente"
else
  puts "Criança"
end

Ruby também permite colocar uma condição em uma única linha:

puts "Maior de idade" if age >= 18

---

unless

unless executa o código quando a condição é falsa.

unless active
  puts "Usuário inativo"
end

É equivalente conceitualmente a:

if !active
  puts "Usuário inativo"
end

---

case

case é utilizado para trabalhar com múltiplas possibilidades.

status = :approved

case status
when :approved
  puts "Aprovado"
when :pending
  puts "Pendente"
when :rejected
  puts "Rejeitado"
else
  puts "Desconhecido"
end

---

10. Operador ternário

Para condições simples:

message = age >= 18 ? "Maior" : "Menor"

Estrutura:

condição ? valor_se_verdadeiro : valor_se_falso

---

11. Loops

while

Executa enquanto a condição for verdadeira.

count = 0

while count < 5
  puts count
  count += 1
end

until

Executa enquanto a condição for falsa.

count = 0

until count >= 5
  puts count
  count += 1
end

for

Percorre uma sequência:

for number in 1..5
  puts number
end

Embora faça parte da linguagem, em Ruby moderno é mais comum utilizar métodos de iteração, que serão estudados posteriormente.

---

12. Ranges

Ranges representam intervalos de valores.

1..5

Inclui o início e o fim:

(1..5).to_a
# => [1, 2, 3, 4, 5]

Com ..., o último valor não é incluído:

(1...5).to_a
# => [1, 2, 3, 4]

Ranges podem ser utilizados com números, caracteres e outros objetos compatíveis.

---

13. Métodos

Métodos encapsulam comportamentos reutilizáveis.

def greet
  puts "Olá!"
end

Chamando o método:

greet

Parâmetros

def greet(name)
  puts "Olá, #{name}!"
end

greet("Tiago")

Retorno

Em Ruby, o resultado da última expressão executada é retornado automaticamente.

def sum(a, b)
  a + b
end

result = sum(10, 5)
# => 15

Não é necessário utilizar return. Também é possível utilizar return explicitamente:

def validate(age)
  return false if age < 18

  true
end

---

14. Métodos também são utilizados pelos objetos

Como tudo em Ruby é objeto, operações são realizadas através de métodos.

name = "Ruby"

name.upcase
# => "RUBY"

name.length
# => 4

Até números possuem métodos:

10.even?
# => true

10.to_s
# => "10"

Isso é uma das características fundamentais da linguagem: os dados possuem comportamento através de métodos.

---

15. Blocos

Blocos são trechos de código que podem ser passados para métodos. Podem ser escritos com {}:

[1, 2, 3].each { |number| puts number }

Ou com do...end:

[1, 2, 3].each do |number|
  puts number
end

O parâmetro entre | | representa o valor recebido pelo bloco. Blocos são uma característica central da linguagem e servem como base para diversas formas de iteração e abstração em Ruby.

---

16. Entrada e saída

puts

Exibe uma informação e adiciona uma quebra de linha.

puts "Hello Ruby"

print

Exibe uma informação sem adicionar automaticamente uma quebra de linha.

print "Hello "
print "Ruby"

gets

Lê uma entrada do usuário:

name = gets

Normalmente utilizamos chomp para remover a quebra de linha:

name = gets.chomp

---

17. Conversão de tipos

Ruby possui métodos para converter valores entre tipos.

"10".to_i
# => 10

"10.5".to_f
# => 10.5

10.to_s
# => "10"

Exemplos:

age = gets.chomp.to_i
price = gets.chomp.to_f

Ruby possui tipagem forte, portanto não realiza automaticamente algumas conversões entre tipos incompatíveis:

"10" + 5
# => TypeError

É necessário realizar a conversão explicitamente:

"10".to_i + 5
# => 15

---

18. Convenções básicas de escrita

Ruby possui algumas convenções importantes:

snake_case

Variáveis e métodos:

user_name = "Tiago"

def calculate_price
end

SCREAMING_SNAKE_CASE

Constantes:

MAX_RETRIES = 3

? em métodos booleanos

Métodos que respondem uma pergunta normalmente terminam com ?:

user.active?
number.even?
name.empty?

! em métodos

O ! normalmente indica uma versão que pode modificar o objeto ou possuir comportamento mais agressivo.

name.upcase!

O significado exato depende do método; ! não significa simplesmente "retorna booleano".