Como variáveis e tipos básicos funcionam em Ruby?

Question

Accepted Answer

Ruby é **dinamicamente tipada** — variáveis não declaram um tipo e podem conter qualquer valor. Ruby tem vários tipos básicos (todos objetos) e usa **convenções de nomenclatura** (sigils) para indicar o escopo das variáveis.

## Variáveis e tipagem dinâmica

```ruby
count = 42           # no type declaration — inferred
name = "Ann"
count = "now a string"   # dynamically typed — can change type
```

## Os tipos básicos (todos são objetos)

```ruby
42              # Integer
3.14            # Float
"hello"         # String
:symbol         # Symbol (an immutable, interned identifier)
true / false    # Boolean (TrueClass / FalseClass)
nil             # NilClass — "nothing" (Ruby's null)
[1, 2, 3]       # Array
{ a: 1 }        # Hash (key-value)
1..10           # Range
```

## Convenções de nomenclatura de variáveis indicam escopo

```ruby
name        = "local"      # local variable (lowercase)
@instance   = "instance"   # @ → INSTANCE variable (per object)
@@class_var = "class"      # @@ → CLASS variable (shared across instances)
$global     = "global"     # $ → global variable (avoid)
CONSTANT    = "constant"   # Uppercase start → CONSTANT (convention; can change with warning)
```

Ruby usa **sigils** (prefixos) para denotar o escopo das variáveis: nomes simples são locais, `@` para variáveis de instância, `@@` para variáveis de classe, `$` para globais (desaconselhado), e maiúsculas para constantes. Isso é distintivo — o prefixo indica o escopo à primeira vista.

## Truthiness (uma peculiaridade do Ruby)

```ruby
# in Ruby, ONLY false and nil are falsy — EVERYTHING else is truthy
puts "truthy" if 0        # prints — 0 is TRUTHY in Ruby! (unlike many languages)
puts "truthy" if ""        # prints — empty string is truthy too
puts "falsy" unless nil    # nil is falsy
```

**Apenas `false` e `nil` são falsy** em Ruby — `0`, `""` e `[]` são todos truthy (diferentemente de muitas linguagens em que 0/vazio são falsy). Uma armadilha comum.

## Por que isso importa

Compreender as variáveis e tipos básicos do Ruby é conhecimento fundamental do dia a dia.

Ruby é dinamicamente tipado (variáveis podem conter qualquer valor, sem declarações de tipo), e uma característica distintiva é o uso de **convenções de nomenclatura (sigils) para indicar o escopo das variáveis** — `@` para variáveis de instância, `@@` para variáveis de classe, `$` para globais, maiúsculas para constantes — então o prefixo da variável indica seu escopo à primeira vista, o que é importante para ler e escrever Ruby corretamente (especialmente variáveis `@instance`, usadas constantemente em classes).

Conhecer os tipos básicos (todos os quais são objetos no modelo orientado a objetos puro do Ruby) — incluindo o tipo distintivo **Symbol** — é necessário para trabalhar com dados.

Uma quirk particularmente importante de entender é a **truthiness** do Ruby: **apenas `false` e `nil` são falsy**, enquanto tudo o mais (incluindo `0`, `""` e `[]`) é truthy — isso difere de muitas linguagens (em que 0 ou valores vazios são falsy) e é uma fonte comum de bugs para desenvolvedores vindos de outras linguagens.

Compreender tipagem dinâmica, as convenções de nomenclatura que indicam escopo, os tipos básicos e especialmente a regra de truthiness só-false-e-nil é fundamental para escrever Ruby correto e evitar armadilhas comuns, tornando-se conhecimento essencial e imprescindível para a linguagem.