Apa yang dilakukan oleh operator ganda * (percikan)

Pernahkah Anda melihat fungsi yang dideklarasikan seperti ini?

def foo a, **b
  ...
end

Saya mengerti bahwa satu *adalah operator percikan. Apa **artinya

Ruby 2.0 memperkenalkan argumen kata kunci, dan **bertindak seperti *, tetapi untuk argumen kata kunci. Ini mengembalikan hash dengan pasangan kunci / nilai.

Untuk kode ini:

def foo(a, *b, **c)
  [a, b, c]
end

Ini demo:

> foo 10
=> [10, [], {}]
> foo 10, 20, 30
=> [10, [20, 30], {}]
> foo 10, 20, 30, d: 40, e: 50
=> [10, [20, 30], {:d=>40, :e=>50}]
> foo 10, d: 40, e: 50
=> [10, [], {:d=>40, :e=>50}]

Itu adalah operator percikan ganda yang tersedia sejak Ruby 2.0.

Itu menangkap semua argumen kata kunci (yang juga bisa menjadi hash sederhana, yang merupakan cara idiomatis untuk meniru argumen kata kunci sebelum mereka menjadi bagian dari bahasa Ruby)

def my_method(**options)
  puts options.inspect
end

my_method(key: "value")

Kode di atas mencetak {key:value}ke konsol.

Sama seperti operator percikan tunggal menangkap semua argumen reguler, tetapi bukannya array Anda mendapatkan hash .

Contoh kehidupan nyata:

Sebagai contoh di Rails, cyclemetodenya terlihat seperti ini:

def cycle(first_value, *values)
  options = values.extract_options!
  # ...
end

Metode ini bisa disebut seperti ini: cycle("red", "green", "blue", name: "colors").

Ini adalah pola yang cukup umum: Anda menerima daftar argumen dan yang terakhir adalah hash opsi, yang dapat diekstraksi - misalnya - menggunakan ActiveSupport extract_options!.

Di Ruby 2.0 Anda dapat menyederhanakan metode ini:

def cycle(first_value, *values, **options)
  # Same code as above without further changes!
end

Memang ini hanya perbaikan kecil jika Anda sudah menggunakan ActiveSupport tetapi untuk Ruby biasa kode ini mendapatkan cukup banyak keringkasan.

Selain itu, Anda dapat menggunakannya di sisi pemanggil seperti ini:

def foo(opts); p opts end
bar = {a:1, b:2}

foo(bar, c: 3)
=> ArgumentError: wrong number of arguments (given 2, expected 1)

foo(**bar, c: 3)
=> {:a=>1, :b=>2, :c=>3}