Cosa significa sia gli operatori * che (*) in ruby?

Question

Mi sono appena presentato allo splat di Ruby. E ho giocato con lui in molti modi. ma l'esperimento di seguito in qualche modo mi ha fatto pensarci due volte :)

langs = ["java", "csharp", "ruby", "haskell" ] 
# => ["java", "csharp", "ruby", "haskell"] 

l1,*,l2 = *langs 
# => ["java", "csharp", "ruby", "haskell"] 
l1 
# => "java" 
l2 
# => "haskell" 

l1,*,*,l2 = *langs 
SyntaxError: (irb):27: syntax error, unexpected tSTAR 
l1,*,*,l2 = *langs 
    ^
    from /usr/bin/irb:12:in `<main>' 

Sì, l'errore è evidente, come ho usato più di 1 *(splat) operatori nella stessa lista degli argomenti.

Ora ho provato a giocare con esso.

l1,(*),(*),l2 = *langs 
# => ["java", "csharp", "ruby", "haskell"] 

Ahh! qui funziona. Ma non riuscivo a capire perché?

l1 
# => "java" 
l2 
# => "haskell" 
l1,(*),l2 = *langs 
# => ["java", "csharp", "ruby", "haskell"] 
l1 
# => "java" 
l2 
# => "ruby" 

Dall'esempio precedente sembra che stia saltando gli elementi dell'array.

Le domande sono:

• (a) quello che l'operatore (*) si chiama?

• (b) quando ho usato in splat (*) nella riga l1,*,l2 = *langs consuma tutti gli elementi - "csharp", "ruby". C'è un modo per vedere cosa consuma tecnicamente lo *? Ovviamente sto chiamando con l'uso se l1,*,l2 = *langs non da l1,l*,l2 = *langs.

Answer 1

Ciò è dovuto a how parentheses work with parallel assignment come spiegato da Matz.

Ad esempio:

a, b, c = *[1, 2, 3] 
a => 1 
b => 2 
c => 3 

è diverso:

a, (b, c) = *[1, 2, 3] 
a => 1 
b => 2 
c => nil 

Fondamentalmente, la parentesi dire: assegnare l'elemento destro in questo indice alle variabili nelle parentesi. Quindi 2 è assegnato a b, con nulla lasciato all'indice 1 da assegnare a c. Allo stesso modo, (*) prenderà solo l'elemento al dato indice e lo distribuirà.

# the * is interpreted to mean 'take all remaining elements' 
a, * = 1, 2, 3, 4 

# the * is interpreted to mean 'take all remaining elements except 
# the last element' 
a, *, c = 1, 2, 3, 4 

# incorrect syntax, can't splat more than once on all remaining 
# elements 
a, *, *, c = 1, 2, 3, 4 

# the * is interpreted to mean 'take all elements at index 1' 
a, (*), c = 1, 2, 3, 4 

# the *'s are interpreted to mean 'take all elements at index 1, 
# then again at index 2' 
a, (*), (*), c = 1, 2, 3, 4 

Tipicamente, l'operatore * viene utilizzato in combinazione con una variabile come *foo - ma se non si terrà il suo posto e prendere assegnazioni all'elemento come se fosse una variabile (essenzialmente scartarli)

Answer 2

Riflessione in questo modo: la parentesi da soli (ignorando un nome variabile o operatore splat) accedono un singolo elemento dell'array:

l1, (),(), l2 = *['a', 'b', 'c', 'd'] 
^ ^^^
'a' 'b' 'c' 'd' 

Se fosse un array di array, avrebbe più senso uso parentesi:

>> l1,(l3, l4),(l5, l6),l2 = *['a', ['b', 'c'], ['d', 'e'], 'f'] 
=> ["a", ["b", "c"], ["d", "e"], "f"] 
>> l1 
=> "a" 
>> l3 
=> "b" 
>> l4 
=> "c" 
>> l5 
=> "d" 
>> l6 
=> "e" 
>> l2 
=> "f" 

Dunque la (*) sta prendendo un singolo elemento dalla matrice, e splat-assegnandogli.Le parentesi stesse prendono un elemento SINGLE, lo splat quindi prende quel singolo elemento e lo "splats".

È bene notare che quando si esegue l'assegnamento multi-variabile da una matrice, il simbolo non è necessario sul lato matrice:

>> a,b,c = ['a', 'b', 'c'] 
=> ["a", "b", "c"] 
>> a 
=> "a" 
>> b 
=> "b" 
>> c 
=> "c" 

Answer 3

(*) realtà solo legge un elemento dal lato destro. Considerate questo esempio, che ha un quinto elemento nella langs matrice:

langs = ["java", "csharp", "ruby", "haskell", "python" ] 

Così, quando si utilizza un simbolo normale, si ottiene:

l1,*,l2 = langs 

l1 #=> "java" 
l2 #=> "python" 

in contrasto con il tuo esempio con le parentesi:

Voglio menzionare che, in questo caso, normalmente si utilizzerà _ per assegnare i valori medi a "niente" (equivalente all'ultimo esempio):

l1,_,_,l2 = langs 

l1 #=> "java" 
l2 #=> "haskell" 

Se volete vedere quello che ha finito per essere all'interno dei valori medi, è possibile assegnare in modo esplicito i valori alle variabili in questo modo:

l1,*m,l2 = *langs 

l1 #=> "java" 
l2 #=> "python" 
m #=> ["csharp","ruby","haskell"] 

o con l'altro esempio:

l1,(*m1),(*m2),l2 = langs 

l1 #=> "java" 
l2 #=> "haskell" 
m1 #=> ["csharp"] 
m2 #=> ["ruby"] 

Quindi spero che questo chiarisca che (*) non è un operatore a sé stante, ma in realtà solo uno splat tra parentesi e quindi non ha un proprio nome.