Comment utiliser la méthode Ruby Map avec des exemples

Ruby est un langage de programmation puissant, et l'une de ses méthodes les plus polyvalentes et les plus utilisées est la méthode map. Qu'il s'agisse de transformer des tableaux ou de simplifier des opérations complexes, la méthode map est indispensable à tout développeur Ruby. Dans cet article, nous verrons ce qu'est la méthode map, comment elle fonctionne, et nous fournirons des exemples pratiques pour vous aider à l'intégrer dans votre flux de travail de développement Ruby.

Qu'est-ce que la méthode Ruby Map ?

La méthode map est une méthode énumérable de Ruby utilisée pour créer un nouveau tableau en transformant chaque élément d'un tableau ou d'une collection existante. Elle applique un bloc de code donné à chaque élément et renvoie le tableau résultant.

Cette méthode est particulièrement utile lorsque vous souhaitez modifier ou transformer des éléments sans altérer le tableau d'origine.

Syntaxe de la méthode de la carte

rubis

array.map { |element| block }
# OR
array.map do |element|
  bloc
end

Caractéristiques principales :

1. Non-destructif: Le tableau d'origine reste inchangé, sauf si l'on utilise map ! (avec un point d'exclamation).
2. Compatibilité énumérable: Fonctionne avec n'importe quel énumérable, comme les tableaux et les hachages.

Exemple de base de la méthode Ruby Map

Commençons par un exemple simple :

rubis

nombres = [1, 2, 3, 4, 5]
nombres_carrés = nombres.map { |num| num ** 2 }
puts nombres_carrés
# Sortie : [1, 4, 9, 16, 25]

Ici, le bloc { |num| num ** 2 } prend chaque nombre, l'élève au carré et crée un nouveau tableau avec les résultats.

Quand utiliser la méthode Ruby Map

Utiliser le carte lorsque vous en avez besoin :

1. Appliquer la même opération à chaque élément d'une collection.
2. Transformer des données d'une forme à une autre.
3. Générer un nouveau tableau à partir d'un tableau existant sans modifier l'original.

Utiliser Ruby Map avec des chaînes de caractères

Vous pouvez utiliser le carte pour manipuler des chaînes de caractères dans un tableau.

rubis

names = ["Alice", "Bob", "Charlie"]
uppercase_names = names.map { |name| name.upcase }
puts uppercase_names
# Sortie : ["ALICE", "BOB", "CHARLIE"]

Utilisation de Ruby Map avec des hachages

carte fonctionne également de manière transparente avec les hachages :

rubis

étudiants = { "Alice" => 85, "Bob" => 90, "Charlie" => 78 }
adjusted_scores = students.map { |name, score| [name, score + 5] }.to_h
puts adjusted_scores
# Sortie : {"Alice"=>90, "Bob"=>95, "Charlie"=>83}

Ici, carte transforme chaque paire clé-valeur en un tableau modifié et le reconvertit en un hachage à l'aide de to_h.

Utiliser Ruby Map avec des plages

Le carte fonctionne également avec les plages :

rubis

range = (1..5)
doubled_values = range.map { |num| num * 2 }
puts doubled_values
# Sortie : [2, 4, 6, 8, 10]

Enchaîner Ruby Map avec d'autres méthodes

Le carte peut être combinée avec d'autres méthodes énumérables pour des opérations plus complexes :

rubis

numbers = [1, 2, 3, 4, 5]
result = numbers.map { |num| num ** 2 }.select { |num| num > 10 }
puts result
# Sortie : [16, 25]

Ici, les nombres sont élevés au carré, puis seuls les nombres supérieurs à 10 sont sélectionnés.

Utiliser Ruby Map avec des blocs ou des procs

Vous pouvez passer des blocs ou des procs à la fonction carte pour une meilleure réutilisation.

rubis

incrément = Proc.new { |num| num + 1 }
nombres = [1, 2, 3, 4, 5]
nombres_incrémentés = nombres.map(&incrément)
puts nombres_incrémentés
# Sortie : [2, 3, 4, 5, 6]

Différence entre carte et chaque

Alors que les deux carte et chacun peuvent itérer dans un tableau, ils ont des cas d'utilisation différents :

Exemple avec chacun:

rubis

numbers.each { |num| puts num ** 2 }
# Sortie :
# 1
# 4
# 9
# 16
# 25

Le résultat est imprimé, mais le tableau original n'est pas modifié et aucun nouveau tableau n'est renvoyé.

Utilisation de la carte avec Bang ( !) pour une transformation destructive

Si vous souhaitez modifier le tableau d'origine, utilisez carte !:

rubis

nombres = [1, 2, 3, 4, 5]
nombres.map ! { |num| num ** 2 }
puts numbers
# Sortie : [1, 4, 9, 16, 25]

Exemples avancés

Carte avec tableaux imbriqués

rubis

matrix = [[1, 2], [3, 4], [5, 6]]
flattened_and_squared = matrix.map { |arr| arr.map { |num| num ** 2 } }
puts flattened_and_squared
# Sortie : [[1, 4], [9, 16], [25, 36]]

Carte pour simplifier les objets

rubis

utilisateurs = [
  { name : "Alice", age : 25 },
  { name : "Bob", age : 30 },
  { name : "Charlie", age : 35 }
]
user_names = users.map { |user| user[:name] }
puts user_names
# Sortie : ["Alice", "Bob", "Charlie"]

Principaux enseignements

• Le carte est un outil polyvalent permettant de transformer des collections en Ruby.
• Il crée un nouveau tableau basé sur les transformations définies dans le bloc.
• Il n'est pas destructif, sauf si vous utilisez la fonction carte !.
• Fonctionne avec des tableaux, des hachages, des plages et même des structures imbriquées.

En maîtrisant les carte vous pouvez écrire un code Ruby plus concis, plus lisible et plus efficace.

Conclusion

Le carte est un élément fondamental de la boîte à outils énumérable de Ruby. Qu'il s'agisse de simples transformations de données ou d'opérations plus complexes, elles permettent de rationaliser le code et d'en améliorer la lisibilité. Que vous construisiez un Application Rails ou en effectuant un traitement de données, le carte est votre solution.

Prêt à plonger plus profondément dans le développement Ruby ? En savoir plus RailsCarma Ressources Ruby et améliorez votre expertise en codage dès aujourd'hui !