Recherche…


Remarques

Les arguments de mots-clés ont été introduits dans Ruby 2.0 et améliorés dans Ruby 2.1 avec l’ajout d’arguments de mots-clés requis .

Une méthode simple avec un argument mot-clé ressemble à la suivante:

def say(message: "Hello World")
  puts message
end

say
# => "Hello World"

say message: "Today is Monday"
# => "Today is Monday"

Pour rappel, la même méthode sans argument mot-clé aurait été:

def say(message = "Hello World")
  puts message
end

say
# => "Hello World"

say "Today is Monday"
# => "Today is Monday"
2.0

Vous pouvez simuler un argument de mot clé dans les versions précédentes de Ruby en utilisant un paramètre Hash. C'est encore une pratique très courante, en particulier dans les bibliothèques qui offrent une compatibilité avec les versions antérieures à la version 2.0 de Ruby:

def say(options = {})
  message = options.fetch(:message, "Hello World")
  puts 
end

say
# => "Hello World"

say message: "Today is Monday"
# => "Today is Monday"

Utilisation des arguments de mots clés

Vous définissez un argument de mot clé dans une méthode en spécifiant le nom dans la définition de la méthode:

def say(message: "Hello World")
  puts message
end

say
# => "Hello World"

say message: "Today is Monday"
# => "Today is Monday"

Vous pouvez définir plusieurs arguments de mot-clé, l'ordre de définition n'est pas pertinent:

def say(message: "Hello World", before: "<p>", after: "</p>")
  puts "#{before}#{message}#{after}"
end

say
# => "<p>Hello World</p>"

say message: "Today is Monday"
# => "<p>Today is Monday</p>"

say after: "</p><hr>", message: "Today is Monday"
# => "<p>Today is Monday</p><hr>"

Les arguments de mots clés peuvent être mélangés avec des arguments positionnels:

def say(message, before: "<p>", after: "</p>")
  puts "#{before}#{message}#{after}"
end

say "Hello World", before: "<span>", after: "</span>"
# => "<span>Hello World</span>"

Le mélange de l'argument mot-clé avec l'argument positionnel était une approche très courante avant Ruby 2.1, car il n'était pas possible de définir les arguments de mot clé requis .

De plus, dans Ruby <2.0, il était très courant d'ajouter un Hash à la fin d'une définition de méthode à utiliser pour les arguments facultatifs. La syntaxe est très similaire aux arguments de mot-clé, au point que les arguments facultatifs via Hash sont compatibles avec les arguments de mots-clés Ruby 2.

def say(message, options = {})
  before = option.fetch(:before, "<p>")
  after  = option.fetch(:after, "</p>")
  puts "#{before}#{message}#{after}"
end

# The method call is syntactically equivalent to the keyword argument one
say "Hello World", before: "<span>", after: "</span>"
# => "<span>Hello World</span>"

Notez que si vous tentez de transmettre un argument de mot-clé non défini, une erreur se produira:

def say(message: "Hello World")
  puts message
end

say foo: "Hello"
# => ArgumentError: unknown keyword: foo

Arguments de mots clés requis

2.1

Les arguments de mots clés requis ont été introduits dans Ruby 2.1, en tant qu'amélioration des arguments de mots clés.

Pour définir un argument de mot-clé comme requis, déclarez simplement l'argument sans valeur par défaut.

def say(message:)
  puts message
end

say
# => ArgumentError: missing keyword: message

say message: "Hello World"
# => "Hello World"

Vous pouvez également mélanger les arguments de mots clés requis et non obligatoires:

def say(before: "<p>", message:, after: "</p>")
  puts "#{before}#{message}#{after}"
end

say
# => ArgumentError: missing keyword: message

say message: "Hello World"
# => "<p>Hello World</p>"

say message: "Hello World", before: "<span>", after: "</span>"
# => "<span>Hello World</span>"

Utilisation d'arguments de mots clés arbitraires avec l'opérateur splat

Vous pouvez définir une méthode pour accepter un nombre arbitraire d'arguments par mot clé en utilisant l'opérateur double splat ( ** ):

def say(**args)
  puts args
end

say foo: "1", bar: "2"
# {:foo=>"1", :bar=>"2"}

Les arguments sont capturés dans un Hash . Vous pouvez manipuler le Hash , par exemple pour extraire les arguments souhaités.

def say(**args)
  puts args[:message] || "Message not found"
end

say foo: "1", bar: "2", message: "Hello World"
# Hello World

say foo: "1", bar: "2"
# Message not found

L'utilisation d'un opérateur splat avec des arguments de mot-clé empêchera la validation des arguments, la méthode ne déclenchera jamais une ArgumentError en cas de mot-clé inconnu.

En ce qui concerne l'opérateur splat standard, vous pouvez reconvertir un Hash en arguments de mots-clés pour une méthode:

def say(message: nil, before: "<p>", after: "</p>")
  puts "#{before}#{message}#{after}"
end

args = { message: "Hello World", after: "</p><hr>" }
say(**args)
# <p>Hello World</p><hr>

args = { message: "Hello World", foo: "1" }
say(**args)
# => ArgumentError: unknown keyword: foo

Ceci est généralement utilisé lorsque vous devez manipuler des arguments entrants et les transmettre à une méthode sous-jacente:

def inner(foo:, bar:)
  puts foo, bar
end

def outer(something, foo: nil, bar: nil, baz: nil)
  puts something
  params = {}
  params[:foo] = foo || "Default foo"
  params[:bar] = bar || "Default bar"
  inner(**params)
end

outer "Hello:", foo: "Custom foo"
# Hello:
# Custom foo
# Default bar


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow