Comment fonctionnent les variables et les types de base en Ruby?

Question

Accepted Answer

Ruby est **dynamiquement typé** — les variables ne déclarent pas de type et peuvent contenir n'importe quelle valeur. Ruby a plusieurs types de base (tous des objets) et utilise des **conventions de nommage** (sigiles) pour indiquer la portée des variables.

## Variables et typage dynamique

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

## Les types de base (tous sont des objets)

```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
```

## Les conventions de nommage des variables indiquent la portée

```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 utilise des **sigiles** (préfixes) pour indiquer la portée des variables : les noms simples sont locaux, `@` pour les variables d'instance, `@@` pour les variables de classe, `$` pour les globales (déconseillé), et majuscules pour les constantes. C'est distinctif — le préfixe vous indique la portée d'un coup d'œil.

## Truthiness (une particularité 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
```

**Seuls `false` et `nil` sont falsy** en Ruby — `0`, `""`, et `[]` sont tous truthy (contrairement à de nombreux langages où 0/vide sont falsy). Une confusion courante.

## Pourquoi c'est important

Comprendre les variables et les types de base de Ruby est une connaissance fondamentale du quotidien.

Ruby est dynamiquement typé (les variables contiennent n'importe quelle valeur, pas de déclarations de type), et une caractéristique distinctive est son utilisation de **conventions de nommage (sigiles) pour indiquer la portée des variables** — `@` pour les variables d'instance, `@@` pour les variables de classe, `$` pour les globales, majuscules pour les constantes — donc le préfixe de la variable vous indique sa portée d'un coup d'œil, ce qui est important pour lire et écrire du Ruby correctement (en particulier les variables `@instance`, utilisées constamment dans les classes).

Connaître les types de base (qui sont tous des objets dans le modèle orienté objet pur de Ruby) — y compris le type distinctif **Symbol** — est nécessaire pour travailler avec des données.

Une particularité particulièrement importante à comprendre est la **truthiness** de Ruby : **seuls `false` et `nil` sont falsy**, tandis que tout le reste (y compris `0`, `""`, et `[]`) est truthy — cela diffère de nombreux langages (où 0 ou les valeurs vides sont falsy) et est une source courante de bugs pour les développeurs venant d'autres langages.

Comprendre le typage dynamique, les conventions de nommage indiquant la portée, les types de base, et particulièrement la règle que seuls false et nil sont falsy, est fondamental pour écrire du Ruby correct et éviter les pièges courants, ce qui en fait une connaissance essentielle et incontournable du langage.