Erreur commune : l'indexation qui commence à 0 (off-by-one)

Pourquoi l'indexation commence-t-elle à 0 et non à 1 ?

C'est sans doute la convention la plus déroutante pour les débutants en programmation, toutes langues confondues. Pourquoi compter à partir de 0 ? La réponse est à la fois historique et logique. En informatique, un index ne représente pas tant le 'numéro' d'un élément (premier, deuxième, ...) que le décalage (ou 'offset') par rapport au début de la collection.

Imaginez une rue où toutes les maisons sont alignées. La première maison se trouve directement au point de départ de la rue. Son décalage par rapport au début est de 0 mètre. La deuxième maison est à une distance d'une 'maison-unité' du départ, donc son décalage est de 1. L'index d'un tableau fonctionne exactement de la même manière.

Le premier élément est au début du tableau, son décalage est donc 0. Le deuxième élément est à un pas du début, son décalage est 1, et ainsi de suite. Une fois que vous intégrez cette idée de 'décalage' plutôt que de 'numérotation', la logique de l'indexation à 0 devient beaucoup plus naturelle.

Qu'est-ce que l'erreur "Off-By-One" et comment se manifeste-t-elle ?

L'erreur 'off-by-one' (décalé de un) est l'une des erreurs de logique les plus fréquentes en programmation. Elle se produit lorsque l'on se trompe d'un cran dans l'indexation, souvent en confondant la taille du tableau avec son dernier index valide.

Considérons un tableau simple. Sa taille, c'est-à-dire le nombre total d'éléments qu'il contient, se trouve avec la méthode .length (ou .size).

players = ["Alice", "Bob", "Charlie"]

# Le nombre de joueurs dans le tableau
puts players.length # Affiche : 3

L'erreur classique est de penser que si le tableau a une taille de 3, alors le dernier joueur doit être à l'index 3. C'est faux. Puisque l'on commence à 0, les index valides pour ce tableau sont 0, 1, et 2. Tenter d'accéder à l'index 3 revient à chercher un quatrième élément qui n'existe pas.

# Tentative incorrecte d'accéder au dernier élément
last_player = players[3] # L'index 3 est hors des limites

puts last_player.inspect # Affiche : nil

Dans ce cas, Ruby retourne nil, ce qui est relativement inoffensif. Cependant, dans des contextes plus complexes, comme une boucle, cette erreur peut conduire à des résultats inattendus ou à des crashs si vous essayez d'appeler une méthode sur une valeur nil.

La règle d'or pour trouver le dernier index

Pour éviter systématiquement l'erreur off-by-one, il existe une règle simple et universelle : le dernier index valide d'un tableau est toujours égal à sa longueur moins un.

Appliquons cette règle à notre exemple précédent :

players = ["Alice", "Bob", "Charlie"]

# 1. Obtenir la longueur du tableau
list_length = players.length # Donne 3

# 2. Calculer le dernier index valide
last_index = list_length - 1 # Donne 2

# 3. Accéder à l'élément avec le bon index
last_player = players[last_index]

puts last_player # Affiche : Charlie

Cette approche mathématique est infaillible. Cependant, comme nous l'avons déjà vu, Ruby nous offre une manière bien plus élégante et moins sujette à l'erreur pour obtenir le dernier élément : l'index négatif -1.

# La manière idiomatique et sûre en Ruby
last_player = players[-1]

puts last_player # Affiche : Charlie