Ruby Language
Argumenty słów kluczowych

Uwagi

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

say
# => "Hello World"

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

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

say
# => "Hello World"

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

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

say
# => "Hello World"

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

Używanie argumentów słów kluczowych

Definiujesz argument słowa kluczowego w metodzie, podając nazwę w definicji metody:

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

say
# => "Hello World"

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

Możesz zdefiniować wiele argumentów słów kluczowych, kolejność definicji nie ma znaczenia:

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>"

Argumenty słów kluczowych można łączyć z argumentami pozycyjnymi:

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

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

Mieszanie argumentu słowa kluczowego z argumentem pozycyjnym było bardzo powszechnym podejściem przed Ruby 2.1, ponieważ nie było możliwe zdefiniowanie wymaganych argumentów słowa kluczowego .

Co więcej, w Ruby <2.0 bardzo często dodawano Hash na końcu definicji metody w celu użycia opcjonalnych argumentów. Składnia jest bardzo podobna do argumentów słów kluczowych, do tego stopnia, że opcjonalne argumenty za pomocą Hash są kompatybilne z argumentami słów kluczowych 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>"

Pamiętaj, że próba przekazania niezdefiniowanego słowa kluczowego spowoduje błąd:

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

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

Wymagane argumenty słów kluczowych

def say(message:)
  puts message
end

say
# => ArgumentError: missing keyword: message

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

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>"

Używanie dowolnych argumentów słów kluczowych z operatorem splat

Możesz zdefiniować metodę akceptowania dowolnej liczby argumentów słów kluczowych za pomocą operatora double splat ( ** ):

def say(**args)
  puts args
end

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

Argumenty są przechwytywane w Hash . Możesz manipulować Hash , na przykład w celu wyodrębnienia żądanych argumentów.

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

Użycie operatora splat z argumentami słowa kluczowego zapobiegnie sprawdzeniu poprawności argumentu słowa kluczowego, metoda nigdy nie zgłosi ArgumentError w przypadku nieznanego słowa kluczowego.

Podobnie jak w przypadku standardowego operatora splat, możesz ponownie przekonwertować Hash na argumenty słów kluczowych dla metody:

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

Jest to zwykle używane, gdy trzeba manipulować przychodzącymi argumentami i przekazać je do podstawowej metody:

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