Ruby à double paramètre floc est trop gourmand avec l'argument de Hash

Question

Dans Ruby 2.4.1, j'ai une méthode comme ceci:

def example(*args, **kwargs) 
    p args 
    p kwargs 
end 

je peux passer des arguments de position qui sont pas Hash très bien:

irb(main):001:0> example("Greetings") 
["Greetings"] 
{} 

Et si je veux utiliser des paramètres nommés, c'est très bien aussi:

irb(main):002:0> example(something: 42) 
[] 
{:something=>42} 

Mais en essayant de passer un Hash comme argument de position, cela se produit:

irb(main):002:0> example({something: 42}) 
[] 
{:something=>42} 

Je veux *args prendre {something: 42}, pas **kwargs.

Les arguments de position doivent être en option, mais même si *args étaient arg=nil, le double-floc est encore trop gourmand:

irb(main):001:0> def example(arg=nil, **kwargs) 
irb(main):002:1> p arg 
irb(main):003:1> p kwargs 
irb(main):004:1> end 
=> :example 

irb(main):005:0> example({"key":"value"}) 
nil 
{:key=>"value"} 

irb(main):006:0> example({"key":"value"}, this_is: "in kwargs") 
{:key=>"value"} 
{:this_is=>"in kwargs"} 

Comment puis-je passer un Hash comme argument de position lorsque la méthode prend également **?

Answer 1

C'est toujours difficile à gérer parce que le **kwargs va prendre en charge agressivement ce hachage. Cela présente aussi une certaine confusion de la part de l'appelant, car ils vont devoir faire attention lors de l'appel, peu importe ce que vous faites:

# Is this options or the body? It's not clear. 
example({ payload: true }) 

je recommande de passer à quelque chose de plus explicite, comme:

def example(**kwargs) 
    body = kwargs.delete(:body) 
end 

Puis l'appeler comme ceci:

example(body: { ... }, user: "username", ...) 

Si vous pouvez préciser les arguments autorisés, encore mieux:

def example(body: nil, user: nil, password: nil) 
    # ... 
end