Optionale Argumente mit default-Wert in Ruby

Ich würde gerne eine Funktion erstellen, die optionale Argumente mit default-Werten

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

end

und rufen Sie die Funktion mit den Argumenten, die ich möchte, um anzugeben, nur

my_function(b=100)

Wie kann ich dies in Ruby 1.9.2?

InformationsquelleAutor AdamNYC | 2013-05-01
  1. 6

    Kann man nicht tun, das (oder etwas ähnliches) in Ruby < 2.0. Das beste, was Sie tun können, ist:

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

my_function(b: 100)
    • -1. Das ist falsch. Sie können beliebig viele optionale Argumente, wie Sie wollen, und Sie müssen nicht der Letzte sein. def foo(mand1, mand2, opt1=:opt1, opt2=:opt2, *splat, mand3, mand4, &block) p local_variables.map {|v| "#{v} = #{eval(v.to_s)}" } end ist völlig in Ordnung.
    • Recht. Ich war falsch. Ich Entferne das Teil.
    • Ich glaubst, dass einige ältere version von Ruby hast, erfordern die Argumente mit Standardwerten werden, wenn nicht die Letzte, zumindest nachdem alle "normalen" Argumente.
    • Ah, ja. Es scheint, dass Ruby 1.9 wurde die Möglichkeit eingeführt, um die Standard-defaults vor einem nicht-Standard-Argumente.
    InformationsquelleAutor sawa
  2. 24

    Argumente gebunden sind Parameter wie diese:

    1. Solange es ungebunden obligatorische Parameter am Anfang der Liste der parameter, binden Sie die Argumente von Links nach rechts
    2. Solange es ungebunden obligatorische Parameter am Ende der Parameterliste, binden Sie die Argumente von rechts nach Links
    3. Alle übrig gebliebenen Argumente gebunden sind optionale Parameter von Links nach rechts
    4. Alle übrig gebliebenen Argumente werden gesammelt, in einem array gespeichert und an die splat argument
    5. Ein block, eingepackt in ein Proc und an das block-argument
    6. Wenn es alle ungebundenen Parametern oder übrig gebliebene Argumente raise eine ArgumentError

    Hier ein Beispiel:

    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>

    So, wie Sie sehen können, aus Schritt 3 oben und von der Beispiel können Sie nicht tun, da optionale Parameter gebunden sind, von Links nach rechts, aber Sie wollen, geben Sie die mittlere argument.

    Beachten Sie, dass dies hat Auswirkungen auf API-design: gestalten Sie die parameter-Listen in der Weise, dass die "instabilen" optionale Parameter, d.h. diejenigen, die ein Benutzer wahrscheinlich will sich selbst versorgen, sind am weitesten Links.

    Ruby 2.0 hat nun keyword-Argumente, das ist genau das, was Sie suchen:

    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}
    • Vielen Dank, Jorg. Sehr informativ
    InformationsquelleAutor Jörg W Mittag
  3. 8

    So, den Sie versuchen zu implementieren keyword-Argumente? Dies soll eine neue Funktion in Ruby 2.0, aber Sie können versuchen, ihn zu imitieren, in 1.9.x mit einem hash von Argumenten statt. Hier ein Beitrag erläutert, wie Sie das erreichen können,, was gibt der folgende code-Beispiel:

    def foo(options = {})
  options = {bar: 'bar'}.merge(options)
  puts "#{options[:bar]} #{options[:buz]}"
end

foo(buz: 'buz') # => 'bar buz'
    • Erstellen Sie keine Antworten, die wirklich nur einen link enthalten, auf eine Antwort. WENN, die Verbindung bricht, wird Ihre Antwort nützlich sein? Stattdessen fassen Sie den relevanten Teil der Antwort.
    • Der link ist kaputt
    InformationsquelleAutor hlh
Schreibe einen Kommentar