Cosa fa un operatore double * (splat)

Hai visto una funzione dichiarata come questa?

def foo a, **b
  ...
end

Capisco che un singolo *è l'operatore splat. Cosa **significa?

Ruby 2.0 ha introdotto argomenti per parole chiave e si **comporta come *, ma per argomenti per parole chiave. Restituisce un hash con coppie chiave / valore.

Per questo codice:

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

Ecco una 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}]

Questo è l' operatore double splat che è disponibile da Ruby 2.0.

Cattura tutti gli argomenti di parole chiave (che può anche essere un semplice hash, che era il modo idiomatico di emulare argomenti di parole chiave prima che diventassero parte del linguaggio Ruby)

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

my_method(key: "value")

Il codice sopra viene stampato {key:value}sulla console.

Proprio come il singolo operatore splat cattura tutti gli argomenti regolari, ma invece di un array ottieni un hash .

Esempio di vita reale:

Ad esempio in Rails il cyclemetodo è simile al seguente:

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

Questo metodo può essere chiamato in questo modo: cycle("red", "green", "blue", name: "colors").

Questo è un modello abbastanza comune: accetti un elenco di argomenti e l'ultimo è un hash delle opzioni, che può essere estratto - ad esempio - usando ActiveSupport extract_options!.

In Ruby 2.0 puoi semplificare questi metodi:

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

È vero che è solo un piccolo miglioramento se si sta già utilizzando ActiveSupport ma per il semplice Ruby il codice guadagna molta concisione.

Inoltre, puoi usarlo nel lato chiamante in questo modo:

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}