¿Cómo funcionan las variables y los tipos básicos en Ruby?

Question

Accepted Answer

Ruby es **dinámicamente tipado** — las variables no declaran un tipo y pueden contener cualquier valor. Ruby tiene varios tipos básicos (todos son objetos) y usa **convenciones de nombres** (sigils) para indicar el alcance de las variables.

## Variables y tipado dinámico

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

## Los tipos básicos (todos son 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
```

## Las convenciones de nombres de variables indican el alcance

```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** (prefijos) para denotar el alcance de las variables: los nombres simples son locales, `@` para variables de instancia, `@@` para variables de clase, `$` para globales (desaconsejado) y mayúsculas para constantes. Esto es distintivo — el prefijo te dice el alcance de un vistazo.

## Veracidad (una peculiaridad de 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
```

**Solo `false` y `nil` son falsy** en Ruby — `0`, `""` y `[]` son todos truthy (a diferencia de muchos lenguajes donde 0/vacío es falsy). Una trampa común.

## Por qué es importante

Comprender las variables y tipos básicos de Ruby es conocimiento fundamental para el día a día.

Ruby es dinámicamente tipado (las variables contienen cualquier valor, sin declaraciones de tipo), y una característica distintiva es su uso de **convenciones de nombres (sigils) para indicar el alcance de las variables** — `@` para variables de instancia, `@@` para variables de clase, `$` para globales, mayúsculas para constantes — por lo que el prefijo de la variable te dice su alcance de un vistazo, lo que es importante para leer y escribir Ruby correctamente (especialmente variables `@instance`, usadas constantemente en clases).

Conocer los tipos básicos (todos los cuales son objetos en el modelo orientado a objetos puro de Ruby) — incluyendo el tipo **Symbol** distintivo — es necesario para trabajar con datos.

Una peculiaridad particularmente importante de entender es la **veracidad de Ruby**: **solo `false` y `nil` son falsy**, mientras que todo lo demás (incluyendo `0`, `""` y `[]`) es truthy — esto difiere de muchos lenguajes (donde 0 o valores vacíos son falsy) y es una fuente común de errores para desarrolladores que vienen de otros lenguajes.

Comprender el tipado dinámico, las convenciones de nombres que indican alcance, los tipos básicos, y especialmente la regla de veracidad solo-false-y-nil es fundamental para escribir Ruby correcto y evitar trampas comunes, lo que lo hace conocimiento esencial e imprescindible para el lenguaje.