Les arguments optionnels avec la valeur par défaut en Ruby

Je voudrais créer une fonction qui a des arguments optionnels avec les valeurs par défaut

def my_function(a = nil, b=nil, c=500)

end

et appeler la fonction avec les arguments que je tiens à spécifier qu'

my_function(b=100)

Comment puis-je faire cela de Ruby 1.9.2?

OriginalL'auteur AdamNYC | 2013-05-01

  1. 6

    Vous ne pouvez pas le faire (ou quelque chose de similaire) en Ruby < 2.0. Le mieux que vous pourriez faire est de:

    def my_function(h = {})
  h[:c] ||= 500
  # Use h[:a], h[:b], h[:c]
  ...
end

my_function(b: 100)
    -1. Ce qui est faux. Vous pouvez avoir autant d'arguments facultatifs que vous souhaitez, et ils n'ont pas à être le dernier. def foo(mand1, mand2, opt1=:opt1, opt2=:opt2, *splat, mand3, mand4, &block) p local_variables.map {|v| "#{v} = #{eval(v.to_s)}" } end est parfaitement bien.
    La droite. J'ai eu tort à ce sujet. Je vais supprimer cette partie.
    I pense que certaines anciennes version de Ruby n'a besoin d'arguments ayant les valeurs par défaut, si ce n'est la dernière, au moins après tout "ordinaire" des arguments.
    Ah, oui. Il semble que Ruby 1.9 introduit la possibilité de défaut valeurs par défaut avant de non-arguments par défaut.

    OriginalL'auteur sawa

  2. 24

    Arguments sont liés à des paramètres comme ceci:

    1. Tant qu'il y a délié les paramètres obligatoires au début de la liste des paramètres, lier les arguments de gauche à droite
    2. Tant qu'il y a délié les paramètres obligatoires à la fin de la liste des paramètres, lier les arguments de droite à gauche
    3. Les restes arguments sont liés à des paramètres optionnels de gauche à droite
    4. Les restes arguments sont rassemblées dans un tableau et lié à la splat argument
    5. Un bloc est enveloppé dans un Proc et lié au bloc argument
    6. S'il y a des unbound les paramètres ou les restes d'arguments, raise un ArgumentError

    Voici un exemple:

    def foo(mand1, mand2, opt1=:opt1, opt2=:opt2, *splat, mand3, mand4, &block)
  p local_variables.map {|v| "#{v} = #{eval(v.to_s)}" }
end

foo 1, 2, 3
# ArgumentError: wrong number of arguments (3 for 4+)

foo 1, 2, 3, 4
# mand1 = 1
# mand2 = 2
# opt1 = opt1
# opt2 = opt2
# splat = []
# mand3 = 3
# mand4 = 4
# block = 

foo 1, 2, 3, 4, 5
# mand1 = 1
# mand2 = 2
# opt1 = 3
# opt2 = opt2
# splat = []
# mand3 = 4
# mand4 = 5
# block = 

foo 1, 2, 3, 4, 5, 6
# mand1 = 1
# mand2 = 2
# opt1 = 3
# opt2 = 4
# splat = []
# mand3 = 5
# mand4 = 6
# block = 

foo 1, 2, 3, 4, 5, 6, 7
# mand1 = 1
# mand2 = 2
# opt1 = 3
# opt2 = 4
# splat = [5]
# mand3 = 6
# mand4 = 7
# block = 

foo 1, 2, 3, 4, 5, 6, 7, 8 do end
# mand1 = 1
# mand2 = 2
# opt1 = 3
# opt2 = 4
# splat = [5, 6]
# mand3 = 7
# mand4 = 8
# block = #<Proc:0x007fdc732cb468@(pry):42>

    Donc, comme vous pouvez le voir à la fois à partir de l'étape 3 ci-dessus et de l'exemple, vous ne pouvez pas faire cela, parce que les paramètres facultatifs sont tenus de gauche à droite, mais vous souhaitez spécifier le milieu argument.

    Noter que ceci a des implications sur la conception d'API: vous devez concevoir vos listes de paramètres de telle manière que les plus "instable" paramètres facultatifs, c'est à dire ceux que l'utilisateur le plus probable souhaite fournir eux-mêmes, sont les plus à gauche.

    Ruby 2.0 a maintenant mot-clé arguments, ce qui est exactement ce que vous cherchez:

    def foo(m1, m2, o1=:o1, o2=:o2, *s, m3, m4, key1: :key1, key2: :key2, **keys, &b)
puts local_variables.map {|v| "#{v} = #{eval(v.to_s)}" }
end
foo 1, 2, 3
# ArgumentError: wrong number of arguments (3 for 4+)
foo 1, 2, 3, 4
# m1 = 1
# m2 = 2
# o1 = o1
# o2 = o2
# s = []
# m3 = 3
# m4 = 4
# key1 = key1
# key2 = key2
# b = 
# keys = {}
foo 1, 2, 3, 4, 5
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = o2
# s = []
# m3 = 4
# m4 = 5
# key1 = key1
# key2 = key2
# b = 
# keys = {}
foo 1, 2, 3, 4, 5, 6
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = 4
# s = []
# m3 = 5
# m4 = 6
# key1 = key1
# key2 = key2
# b = 
# keys = {}
foo 1, 2, 3, 4, 5, 6, 7
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = 4
# s = [5]
# m3 = 6
# m4 = 7
# key1 = key1
# key2 = key2
# b = 
# keys = {}
foo 1, 2, 3, 4, 5, 6, 7, 8
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = 4
# s = [5, 6]
# m3 = 7
# m4 = 8
# key1 = key1
# key2 = key2
# b = 
# keys = {}
foo 1, 2, 3, 4, 5, 6, 7, 8, key1: 9
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = 4
# s = [5, 6]
# m3 = 7
# m4 = 8
# key1 = 9
# key2 = key2
# b = 
# keys = {}
foo 1, 2, 3, 4, 5, 6, 7, 8, key1: 9, key2: 10
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = 4
# s = [5, 6]
# m3 = 7
# m4 = 8
# key1 = 9
# key2 = 10
# b = 
# keys = {}
foo 1, 2, 3, 4, 5, 6, 7, 8, key1: 9, key2: 10, key3: 11
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = 4
# s = [5, 6]
# m3 = 7
# m4 = 8
# key1 = 9
# key2 = 10
# b = 
# keys = {:key3=>11}
foo 1, 2, 3, 4, 5, 6, 7, 8, key1: 9, key2: 10, key3: 11, key4: 12 do end
# m1 = 1
# m2 = 2
# o1 = 3
# o2 = 4
# s = [5, 6]
# m3 = 7
# m4 = 8
# key1 = 9
# key2 = 10
# b = #<Proc:0x007fdc75135a48@(pry):77>
# keys = {:key3=>11, key4=>12}
    Merci beaucoup, Jorg. Très instructif

    OriginalL'auteur Jörg W Mittag

  3. 8

    Si vous essayez de mettre en œuvre les arguments mots-clefs? C'est censé être une nouvelle fonctionnalité de Ruby 2.0, mais vous pouvez essayer de l'imiter en 1.9.x avec une valeur de hachage des arguments à la place. Voici un post qui explique comment vous pouvez accomplir cela, ce qui donne l'exemple de code suivant:

    def foo(options = {})
options = {bar: 'bar'}.merge(options)
puts "#{options[:bar]} #{options[:buz]}"
end
foo(buz: 'buz') # => 'bar buz'
    Ne créez pas de réponses vraiment seulement contenir un lien vers une réponse. SI que le lien est rompu, votre réponse sera utile? Au lieu de cela, résumer la partie pertinente de cette réponse.
    Le lien est cassé

    OriginalL'auteur hlh