add toolbox

2026-10-14 20:14:32 +02:00
1 parent 1bf550a752
commit 58c443ec6c
@@ -0,0 +1,687 @@
 # Toolbox Ruby
 Cette fiche regroupe les méthodes Ruby les plus courantes à connaître ou à savoir retrouver rapidement.
 Certaines méthodes utilisées avec `Array`, `Hash` ou `Range` proviennent en réalité du module `Enumerable`.
 ## String
 ```ruby
 text = "Bonjour Ruby"
 ```
 ### Informations
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `length` / `size` | Nombre de caractères | `text.length` |
 | `empty?` | Vérifie si la chaîne est vide | `text.empty?` |
 | `include?` | Cherche une sous-chaîne | `text.include?("Ruby")` |
 | `start_with?` | Vérifie le début | `text.start_with?("Bon")` |
 | `end_with?` | Vérifie la fin | `text.end_with?("Ruby")` |
 | `match?` | Teste une expression régulière | `text.match?(/Ruby/)` |
 ### Transformer
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `upcase` | Met en majuscules | `text.upcase` |
 | `downcase` | Met en minuscules | `text.downcase` |
 | `capitalize` | Met la première lettre en majuscule | `text.capitalize` |
 | `strip` | Supprime les espaces aux extrémités | `" Ruby ".strip` |
 | `reverse` | Inverse la chaîne | `"Ruby".reverse` |
 | `sub` | Remplace la première occurrence | `"test test".sub("test", "Ruby")` |
 | `gsub` | Remplace toutes les occurrences | `"a-a-a".gsub("-", "_")` |
 ### Découper
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `split` | Découpe en tableau | `"a,b,c".split(",")` |
 | `chars` | Retourne un tableau de caractères | `"Ruby".chars` |
 | `lines` | Retourne un tableau de lignes | `"a\nb".lines` |
 ### Convertir
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `to_i` | Convertit en entier | `"42".to_i` |
 | `to_f` | Convertit en nombre décimal | `"3.14".to_f` |
 | `to_sym` | Convertit en symbole | `"name".to_sym` |
 ---
 ## Integer
 ```ruby
 number = 42
 ```
 ### Tester
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `even?` | Nombre pair | `42.even?` |
 | `odd?` | Nombre impair | `7.odd?` |
 | `zero?` | Égal à zéro | `0.zero?` |
 | `positive?` | Strictement positif | `5.positive?` |
 | `negative?` | Strictement négatif | `(-5).negative?` |
 ### Manipuler
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `abs` | Valeur absolue | `(-5).abs` |
 | `digits` | Retourne les chiffres en ordre inverse | `123.digits # => [3, 2, 1]` |
 ### Répéter
 ```ruby
 3.times do
  puts "Ruby"
 end
 ```
 `times` est particulièrement utile pour effectuer une action un nombre précis de fois.
 ### Convertir
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `to_s` | Convertit en chaîne | `42.to_s` |
 | `to_f` | Convertit en nombre décimal | `42.to_f` |
 ---
 ## Float
 ```ruby
 number = 3.14159
 ```
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `round` | Arrondit | `3.14159.round(2) # => 3.14` |
 | `floor` | Arrondit vers le bas | `3.9.floor # => 3` |
 | `ceil` | Arrondit vers le haut | `3.1.ceil # => 4` |
 | `to_i` | Convertit en entier | `3.9.to_i # => 3` |
 ---
 ## Array
 ```ruby
 numbers = [1, 2, 3]
 ```
 ### Informations
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `length` / `size` | Nombre d'éléments | `numbers.length` |
 | `empty?` | Vérifie si le tableau est vide | `numbers.empty?` |
 | `include?` | Vérifie la présence d'une valeur | `numbers.include?(2)` |
 | `index` | Position d'un élément | `numbers.index(2)` |
 ### Accéder aux éléments
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `[]` | Accède à un élément | `numbers[0]` |
 | `first` | Premier élément | `numbers.first` |
 | `last` | Dernier élément | `numbers.last` |
 Les indices commencent à `0`.
 ```ruby
 numbers[0]
 # => 1
 ```
 Les intervalles permettent d'extraire plusieurs éléments :
 ```ruby
 numbers[1..]
 # => [2, 3]
 ```
 ### Ajouter et retirer
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `<<` | Ajoute à la fin | `numbers << 4` |
 | `push` | Ajoute à la fin | `numbers.push(4)` |
 | `pop` | Retire et retourne le dernier | `numbers.pop` |
 | `unshift` | Ajoute au début | `numbers.unshift(0)` |
 | `shift` | Retire et retourne le premier | `numbers.shift` |
 | `delete` | Supprime les éléments égaux à une valeur | `numbers.delete(2)` |
 ### Transformer
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `reverse` | Inverse le tableau | `numbers.reverse` |
 | `sort` | Trie | `[3, 1, 2].sort` |
 | `uniq` | Supprime les doublons | `[1, 1, 2].uniq` |
 | `compact` | Supprime les `nil` | `[1, nil, 2].compact` |
 | `flatten` | Aplatit les tableaux imbriqués | `[[1, 2], [3]].flatten` |
 | `join` | Transforme en chaîne | `[1, 2, 3].join("-")` |
 | `shuffle` | Mélange | `numbers.shuffle` |
 | `sample` | Prend un élément au hasard | `numbers.sample` |
 ### Combinaisons
 ```ruby
 [1, 2, 3].combination(2).to_a
 # => [[1, 2], [1, 3], [2, 3]]
 ```
 `combination` est utile lorsque l'ordre des éléments n'a pas d'importance.
 ---
 ## Hash
 ```ruby
 person = {
  name: "Alice",
  age: 30
 }
 ```
 ### Accéder aux valeurs
 ```ruby
 person[:name]
 # => "Alice"
 ```
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `[]` | Lit une valeur | `person[:name]` |
 | `[]=` | Ajoute ou modifie une valeur | `person[:age] = 31` |
 | `fetch` | Lit une clé et signale son absence | `person.fetch(:name)` |
 | `dig` | Cherche dans des structures imbriquées | `data.dig(:user, :name)` |
 ### Informations
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `keys` | Retourne les clés | `person.keys` |
 | `values` | Retourne les valeurs | `person.values` |
 | `key?` | Vérifie la présence d'une clé | `person.key?(:name)` |
 | `value?` | Vérifie la présence d'une valeur | `person.value?("Alice")` |
 | `empty?` | Vérifie si le Hash est vide | `person.empty?` |
 | `size` | Nombre de paires clé-valeur | `person.size` |
 ### Modifier
 | Méthode | Utilité | Exemple |
 |---|---|---|
 | `delete` | Supprime une clé | `person.delete(:age)` |
 | `merge` | Retourne un nouveau Hash fusionné | `person.merge(city: "Paris")` |
 ---
 ## Enumerable
 `Enumerable` fournit une grande partie des méthodes utilisées pour parcourir, transformer et interroger des collections.
 `Array`, `Hash` et `Range` utilisent notamment ce module.
 ```ruby
 numbers = [1, 2, 3, 4]
 ```
 ### Parcourir
 #### `each`
 Effectue une action pour chaque élément.
 ```ruby
 numbers.each do |number|
  puts number
 end
 ```
 #### `each_with_index`
 Fournit l'élément et sa position.
 ```ruby
 numbers.each_with_index do |number, index|
  puts "#{index}: #{number}"
 end
 ```
 ### Transformer : `map`
 Crée un nouveau tableau en transformant chaque élément.
 ```ruby
 numbers.map { |number| number * 2 }
 # => [2, 4, 6, 8]
 ```
 À retenir :
 > `map` = transformer chaque élément.
 ### Filtrer : `select`
 Conserve les éléments qui respectent une condition.
 ```ruby
 numbers.select(&:even?)
 # => [2, 4]
 ```
 À retenir :
 > `select` = garder certains éléments.
 ### Rejeter : `reject`
 Inverse de `select`.
 ```ruby
 numbers.reject(&:even?)
 # => [1, 3]
 ```
 ### Trouver : `find`
 Retourne le premier élément correspondant.
 ```ruby
 numbers.find { |number| number > 2 }
 # => 3
 ```
 ### Tester une collection
 #### `any?`
 Au moins un élément correspond-il ?
 ```ruby
 numbers.any?(&:even?)
 # => true
 ```
 #### `all?`
 Tous les éléments correspondent-ils ?
 ```ruby
 numbers.all?(&:positive?)
 # => true
 ```
 #### `none?`
 Aucun élément ne correspond-il ?
 ```ruby
 numbers.none?(&:negative?)
 # => true
 ```
 ### Compter : `count`
 ```ruby
 numbers.count(&:even?)
 # => 2
 ```
 ### Additionner : `sum`
 ```ruby
 numbers.sum
 # => 10
 ```
 ### Minimum et maximum
 ```ruby
 numbers.min
 numbers.max
 ```
 Pour choisir selon une propriété :
 ```ruby
 words = ["chat", "éléphant", "chien"]
 words.min_by(&:length)
 # => "chat"
 words.max_by(&:length)
 # => "éléphant"
 ```
 ### Trier selon un critère : `sort_by`
 ```ruby
 words.sort_by(&:length)
 ```
 ### Regrouper : `group_by`
 ```ruby
 words.group_by(&:length)
 ```
 Retourne un `Hash` regroupant les éléments selon le résultat du bloc.
 ### Parcourir par groupes
 #### `each_cons`
 Groupes successifs qui se chevauchent :
 ```ruby
 [1, 2, 3, 4].each_cons(2).to_a
 # => [[1, 2], [2, 3], [3, 4]]
 ```
 #### `each_slice`
 Groupes successifs qui ne se chevauchent pas :
 ```ruby
 [1, 2, 3, 4].each_slice(2).to_a
 # => [[1, 2], [3, 4]]
 ```
 ### Accumuler : `reduce` / `inject`
 ```ruby
 [1, 2, 3, 4].reduce(0) do |total, number|
  total + number
 end
 # => 10
 ```
 Pour une simple addition, `sum` est généralement plus clair.
 ---
 ## Range
 ```ruby
 range = 1..5
 ```
 ### Parcourir
 ```ruby
 (1..5).each do |number|
  puts number
 end
 ```
 ### Tester
 ```ruby
 (1..5).include?(3)
 # => true
 ```
 ### Convertir en tableau
 ```ruby
 (1..5).to_a
 # => [1, 2, 3, 4, 5]
 ```
 ### Avancer par étapes
 ```ruby
 (0..10).step(2).to_a
 # => [0, 2, 4, 6, 8, 10]
 ```
 ### `..` et `...`
 ```ruby
 1..5
 ```
 inclut `5`.
 ```ruby
 1...5
 ```
 n'inclut pas `5`.
 ---
 ## Regexp
 Les expressions régulières permettent de rechercher un motif dans du texte.
 ```ruby
 text = "Ruby123"
 ```
 ### `match?`
 ```ruby
 text.match?(/\d+/)
 # => true
 ```
 Quelques motifs courants :
 | Motif | Signification |
 |---|---|
 | `\d` | chiffre |
 | `\w` | caractère de mot |
 | `\s` | espace |
 | `.` | presque n'importe quel caractère |
 | `+` | une ou plusieurs fois |
 | `*` | zéro ou plusieurs fois |
 | `?` | zéro ou une fois |
 | `\A` | début de chaîne |
 | `\z` | fin de chaîne |
 Exemple :
 ```ruby
 "123".match?(/\A\d+\z/)
 # => true
 ```
 ---
 ## Object
 Ces méthodes sont utiles avec presque tous les objets Ruby.
 ### `class`
 Retourne la classe de l'objet.
 ```ruby
 "Ruby".class
 # => String
 42.class
 # => Integer
 ```
 Très utile pour comprendre ce que l'on manipule.
 ### `nil?`
 ```ruby
 value.nil?
 ```
 Teste si une valeur est `nil`.
 ### `is_a?`
 ```ruby
 "Ruby".is_a?(String)
 # => true
 ```
 ### `respond_to?`
 Vérifie qu'un objet répond à une méthode.
 ```ruby
 "Ruby".respond_to?(:upcase)
 # => true
 ```
 ---
 ## Conversions courantes
 ```ruby
 42.to_s
 "42".to_i
 "3.14".to_f
 "Ruby".chars
 "Ruby".to_sym
 (1..5).to_a
 ["a", "b", "c"].join(", ")
 ```
 Lorsque quelque chose semble impossible à manipuler directement, penser à la question :
 > **Est-ce que je dois d'abord convertir cet objet ?**
 ---
 ## Choisir une méthode selon le besoin
 | Je veux… | Penser à… |
 |---|---|
 | parcourir tous les éléments | `each` |
 | connaître également leur position | `each_with_index` |
 | transformer chaque élément | `map` |
 | garder certains éléments | `select` |
 | éliminer certains éléments | `reject` |
 | trouver le premier élément correspondant | `find` |
 | savoir si au moins un correspond | `any?` |
 | savoir si tous correspondent | `all?` |
 | savoir si aucun ne correspond | `none?` |
 | compter les éléments correspondants | `count` |
 | additionner | `sum` |
 | trouver le plus petit / grand | `min`, `max` |
 | comparer selon une propriété | `min_by`, `max_by` |
 | trier selon une propriété | `sort_by` |
 | regrouper selon une propriété | `group_by` |
 | parcourir avec les voisins | `each_cons` |
 | parcourir par groupes séparés | `each_slice` |
 | combiner des éléments | `combination` |
 | répéter N fois | `times` |
 | découper une chaîne | `split`, `chars` |
 | chercher dans une chaîne | `include?`, `match?` |
 | ajouter à un tableau | `<<`, `push` |
 | retirer le dernier élément | `pop` |
 | retirer le premier élément | `shift` |
 | obtenir le type d'un objet | `class` |
 | vérifier une méthode disponible | `respond_to?` |
 | convertir un objet | `to_s`, `to_i`, `to_f`, `to_a` |
 ---
 ## Méthodes avec `!`
 Certaines méthodes possèdent une version terminée par `!` :
 ```ruby
 numbers.sort
 numbers.sort!
 ```
 Dans ce type de paire, la méthode sans `!` retourne généralement un nouvel objet alors que la version avec `!` modifie directement le receveur.
 Exemple :
 ```ruby
 numbers = [3, 1, 2]
 sorted = numbers.sort
 numbers
 # => [3, 1, 2]
 sorted
 # => [1, 2, 3]
 ```
 Avec :
 ```ruby
 numbers.sort!
 ```
 `numbers` lui-même est modifié.
 Le `!` est une convention Ruby signalant une méthode plus dangereuse ou ayant des effets plus importants que sa version correspondante sans `!`.
 Il ne signifie pas systématiquement « modifie l'objet » et toutes les méthodes qui modifient un objet ne se terminent pas par `!`.
 ---
 ## Réflexe devant un exercice
 Avant de chercher une méthode, identifier ce que l'on manipule :
 ```ruby
 object.class
 ```
 Puis formuler l'opération recherchée :
 ```text
 Quel est mon objet ?
        ↓
 String / Integer / Array / Hash…
        ↓
 Qu'est-ce que je veux obtenir ?
        ↓
 parcourir / transformer / filtrer / chercher / convertir…
        ↓
 Quelle famille de méthodes correspond ?
 ```
 Exemple :
 ```ruby
 number = 123
 ```
 Je veux parcourir ses chiffres.
 ```text
 Integer
 ↓
 je veux une collection de chiffres
 ↓
 conversion possible
 ↓
 to_s
 ↓
 String
 ↓
 chars
 ↓
 Array
 ↓
 each / map / each_with_index…
 ```
 La bonne méthode n'est pas nécessairement disponible sur l'objet de départ : **la conversion vers un type plus adapté fait souvent partie de la solution**.