Çift * (uyarısı) operatörü ne yapar

Böyle bildirilen bir işlev gördünüz mü?

def foo a, **b
  ...
end

Bir *tekin uyarıcı operatör olduğunu anlıyorum . Ne anlama **geliyor?

Ruby 2.0, anahtar kelime bağımsız değişkenlerini tanıttı ve anahtar kelime bağımsız değişkenleri için **gibi davranıyor *. Anahtar / değer çiftleri içeren bir Hash döndürür.

Bu kod için:

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

İşte bir 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}]

Bu, Ruby 2.0'dan beri kullanılabilen çift ​​splat operatörüdür.

Tüm anahtar kelime bağımsız değişkenlerini yakalar (bu, Ruby dilinin bir parçası haline gelmeden önce anahtar kelime bağımsız değişkenlerini taklit etmenin deyimsel yolu olan basit bir karma da olabilir)

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

my_method(key: "value")

Yukarıdaki kod {key:value}konsola yazdırılır .

Tıpkı tek splat operatörünün tüm normal argümanları yakalaması gibi, ancak bir dizi yerine bir karma alırsınız .

Gerçek hayat örneği:

Örneğin, Rails'te cycleyöntem şöyle görünür:

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

Bu yöntem şu şekilde adlandırılabilir: cycle("red", "green", "blue", name: "colors") .

Bu oldukça yaygın bir kalıptır: Bağımsız değişkenlerin bir listesini kabul edersiniz ve sonuncusu ActiveSupport'ları kullanarak ayıklanabilecek bir seçenek karmasıdır extract_options!.

Ruby 2.0'da şu yöntemleri basitleştirebilirsiniz:

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

Kuşkusuz, zaten ActiveSupport kullanıyorsanız bu sadece küçük bir gelişme ancak düz Ruby için kod oldukça özlü hale geliyor.

Buna ek olarak, bu şekilde arayan tarafında da kullanabilirsiniz:

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}