Les chaînes de caractères Ruby disposent d'un riche ensemble de méthodes de manipulation, et beaucoup existent sous deux formes : une version normale (retourne une nouvelle chaîne) et une version bang (!) (modifie la chaîne sur place, en mutant l'original). Comprendre cette distinction est important pour la correction et pour éviter les bugs.
"hello".upcase # "HELLO"
"HELLO".downcase # "hello"
" hi ".strip # "hi" — remove surrounding whitespace
"hello".reverse # "olleh"
"hello".length # 5
"hello world".split(" ") # ["hello", "world"]
["a", "b"].join("-") # "a-b"
"hello".sub("l", "L") # "heLlo" — replace FIRST
"hello".gsub("l", "L") # "heLLo" — replace ALL (global)
"hello".include?("ell") # true
"hello".start_with?("he") # true
"hello".chars # ["h", "e", "l", "l", "o"]
"42".to_i; "3.14".to_f # convert to number
"Hi #{name}" # interpolation
str = "hello"
# normal version — returns a NEW string, original UNCHANGED
upper = str.upcase # upper = "HELLO", but str is STILL "hello"
puts str # "hello" — unchanged
# BANG version — modifies the original IN PLACE (mutates it)
str.upcase! # str is NOW "HELLO" — the original changed!
puts str # "HELLO"
Les versions ! (bang) mutent la chaîne originale sur place, tandis que les versions sans bang retournent une nouvelle chaîne et laissent l'original inchangé. C'est une distinction critique — utiliser upcase! alors qu'on voulait upcase (ou inversement) change le fait que l'original soit modifié, ce qui peut causer des bugs subtils.
"hello".upcase! # "HELLO"
"HELLO".upcase! # nil! — bang methods return nil if NOTHING changed
# → don't chain off a bang method's return value carelessly
str.strip!&.upcase # be careful — strip! returns nil if there was nothing to strip
Un piège subtil : les méthodes bang retournent nil si elles n'ont fait aucun changement — donc enchaîner à partir de leur valeur retournée peut casser.
La manipulation de chaînes de caractères est omniprésente en programmation, donc connaître les riches méthodes de chaîne de Ruby est une connaissance utile au quotidien — mais le point le plus important est de comprendre la distinction bang (!) vs non-bang, qui est à la fois une convention de nommage Ruby et une source fréquente de bugs.
La version non-bang retourne une nouvelle chaîne (laissant l'original inchangé), tandis que la version bang mute l'original sur place — et les confondre change le fait que l'objet original soit modifié, ce qui cause des bugs subtils et difficiles à déboguer (par exemple, s'attendre à ce que l'original soit inchangé mais utiliser upcase! le mute, ou s'attendre à une mutation mais utiliser upcase laisse l'original intouché).
Comme les chaînes Ruby sont mutables et que beaucoup de méthodes ont les deux formes, comprendre cette distinction est important pour la correction — savoir que ! signifie typiquement « modifie sur place / est la version dangereuse » (une convention s'étendant au-delà des chaînes à d'autres méthodes Ruby comme map!, sort!) vous permet de prédire et de contrôler le comportement de mutation.
Le piège supplémentaire que les méthodes bang retournent nil quand elles ne font aucun changement (ce qui peut casser l'enchaînement de méthodes) est également utile à connaître.
Comprendre les utiles méthodes de chaîne de Ruby et surtout la distinction mutation bang/non-bang (une convention Ruby fondamentale affectant si l'original est modifié) est important pour écrire du Ruby correct qui gère les chaînes en toute sécurité — c'est une source fréquente de bugs de mutation, et la convention ! est un idiome Ruby fondamental qui reflète une compréhension de la sémantique sur place vs nouvel objet, ce qui la rend pratiquement pertinente pour le travail constant avec les chaînes en Ruby et un sujet courant concernant une convention Ruby distinctive et source de bugs.