nil n'est pas null nil is not null

nil n'est pas l'absence d'objet. C'est un objet bien présent.nil is not the absence of an object. It's an object, fully present.

On a établi que tout est objet, sans exception. nil est le cas qui le prouve jusqu'au bout. Là où d'autres langages ont un null qui signifie « rien ici » — et qui plante quand on l'interroge — Ruby a nil : l'unique instance de NilClass, un objet qui a une classe et répond à des messages. Son fameux NoMethodError n'est pas un crash : c'est un objet qui décline poliment un message qu'il ne connaît pas.We established that everything is an object, no exceptions. nil is the case that proves it all the way down. Where other languages have a null meaning 'nothing here' — that crashes when queried — Ruby has nil: the sole instance of NilClass, an object that has a class and answers messages. Its infamous NoMethodError is no crash: it's an object politely declining a message it doesn't know.

nil.class            # => NilClass
nil.nil?             # => true
nil.to_s             # => ""      — nil répond, et utilement
nil.to_a             # => []
nil.inspect          # => "nil"

nil.upcase           # NoMethodError: undefined method 'upcase' for nil
# ↑ pas un crash mémoire : un objet qui dit « je n'ai pas ce message »

null plante parce qu'il n'y a rien. nil répond parce qu'il y a quelque chose.null crashes because there's nothing. nil answers because there's something.

La confusion vient du nom : on traduit nil par null et on s'attend au même comportement. Mais ce sont deux choses opposées. null est l'absence de référence — le déréférencer plante car il n'y a rien derrière. nil est un objet bien réel : on peut l'interroger, le convertir, le tester. Le NoMethodError n'est pas le NullPointerException — c'est un objet présent qui ne connaît pas un message.The confusion comes from the name: we translate nil as null and expect the same behavior. But they are opposites. null is the absence of a reference — dereferencing it crashes because there's nothing behind it. nil is a genuine object: you can query it, convert it, test it. NoMethodError is not NullPointerException — it's a present object that doesn't know a message.

// Java : null est l'ABSENCE d'objet
String name = lookup();   // renvoie null si rien trouvé
name.length();            // NullPointerException — on déréférence le vide

// null n'a pas de classe, pas de méthodes, pas d'identité :
null.getClass();          // ne compile même pas
// le crash vient de ce qu'il n'y a RIEN derrière la référence

null n'a ni classe, ni méthode, ni identité — c'est une référence qui ne pointe sur rien. Le crash n'est pas « ce message est inconnu », c'est « il n'y a aucun objet ici pour recevoir quoi que ce soit ».null has no class, no method, no identity — it's a reference pointing at nothing. The crash isn't "this message is unknown," it's "there is no object here to receive anything."

nil a un protocole. Et il n'est faux qu'avec false.nil has a protocol. And it's falsy only alongside false.

Puisque nil est un objet, il a des méthodes — et elles sont pensées pour qu'il se fonde dans les conversions sans planter. Deux choses à intérioriser : en Ruby, seuls nil et false sont faux (0, la chaîne vide et le tableau vide sont tous vrais), et l'opérateur &. permet d'envoyer un message « seulement si le receveur n'est pas nil ». Deux outils précis — qu'on verra ensuite ne pas sur-utiliser.Since nil is an object, it has methods — designed so it blends into conversions without crashing. Two things to internalize: in Ruby, only nil and false are falsy (0, the empty string and the empty array are all truthy), and the &. operator sends a message 'only if the receiver isn't nil'. Two precise tools — which we'll then see not to overuse.

user&.account&.balance      # si user est nil → nil, sans NoMethodError

# &. n'est que du sucre : a&.b équivaut à
a.nil? ? nil : a.b

# à ne pas confondre avec || (valeur par défaut) :
name = user.name || "anonyme"   # "" reste "" ; seuls nil/false déclenchent le défaut

# En Ruby, SEULS nil et false sont faux. Tout le reste est vrai.
!!0        # => true   — zéro est vrai
!!""       # => true   — la chaîne vide est vraie
!![]       # => true   — le tableau vide est vrai
!!nil      # => false
!!false    # => false
# donc "if x" teste la présence (nil/false), pas le "vide"

Venant d'un langage où 0 ou la chaîne vide sont « faux », c'est un piège classique : ici if count est vrai même quand count vaut 0. if teste la présence (ni nil ni false), jamais le « vide ».Coming from a language where 0 or the empty string are "falsy," this is a classic trap: here if count is true even when count is 0. if tests presence (neither nil nor false), never "emptiness."

Le &. en chaîne ne règle pas le nil. Il le déplace.A chain of &. doesn't fix the nil. It relocates it.

Sitôt qu'on découvre &., on est tenté d'en mettre partout « pour ne plus jamais voir de NoMethodError ». Mais &. ne supprime pas le nil : il le laisse passer. Une chaîne de &. renvoie nil au moindre maillon absent — et ce nil continue son chemin jusqu'à exploser ailleurs, à mille lignes de la vraie cause. On n'a pas évité le bug ; on l'a rendu plus difficile à trouver.The moment you discover &., you're tempted to sprinkle it everywhere 'to never see NoMethodError again'. But &. doesn't remove the nil: it lets it through. A chain of &. returns nil at the first missing link — and that nil travels on until it blows up elsewhere, a thousand lines from the real cause. You didn't avoid the bug; you made it harder to find.

# Le réflexe « par sécurité » : un &. à chaque maillon
total = user&.cart&.items&.sum(&:price)

# Si user existe mais cart est nil (un bug !), total devient nil…
# … et le nil voyage. Trois écrans plus loin :
"Total : #{total.round(2)} €"   # NoMethodError: undefined 'round' for nil
# l'erreur surgit LOIN de la cause — un cart qui n'aurait jamais dû être nil

# Le correctif : ne pas avaler le nil — décider à la frontière

# 1. si l'absence est un BUG : garantis l'invariant, échoue tôt et clair
cart = user.cart or raise "panier manquant pour #{user.id}"
total = cart.items.sum(&:price)

# 2. si l'absence est LÉGITIME : un défaut explicite, une seule fois
items = user.cart&.items || []
total = items.sum(&:price)        # 0, pas nil — le reste du code respire

# 3. mieux : un objet qui se comporte comme un panier vide (Null Object)
cart = user.cart || EmptyCart.new