Dołącz parę klucz / wartość do skrótu za pomocą znaku << w Rubim

80

W Rubim można dodawać wartości do istniejących tablic używając <<:

a = []
a << "foo"

ale czy możesz również dołączyć pary klucz / wartość do istniejącego skrótu?

h = {}
h << :key "bar"

Wiem, że potrafisz:

h[:key] = ""
h[:key] << "bar"

ale tego nie chcę.

Dzięki.

jcarpio
źródło
21
Dlaczego nie h[:key] = "bar"?
Hauleth
4
To nie działa:h[:key] << "bar"
Chris Nielsen,

Odpowiedzi:

141

Jest merge!.

h = {}
h.merge!(key: "bar")
# => {:key=>"bar"}
sawa
źródło
3
Nie sądzę, aby merge!kwalifikowało się to jako zwykłe utworzenie nowej pary klucz / wartość, ponieważ jest ona faktycznie używana do innego celu.
PericlesTheo
Słuszna uwaga. Myślę, że może to również skończyć się w zależności od innych czynników, których PO nie opublikował.
Michael Durrant
1
Ach, dzięki. Wygląda na to, że metoda sklepu działa podobnie. Było to głównie pytanie akademickie, ponieważ widziałem <<, o którym mówiłem, jako sposób na dołączanie do tablic, ale chciałem sprawdzić, czy działa to w przypadku skrótów. Dzięki jeszcze raz.
jcarpio
5
Różnica jest taka: storepo prostu dodaje nową parę, nie obchodzi go, czy klucz już istnieje. ze merge!jednak wpisy z zduplikowane klucze są zastępowane więc metoda robi nieco więcej niż tylko dodanie par. Jeśli porównasz te dwa, okaże storesię , że jesteś szybszy (trywialne, ale szczególnie w przypadku małych haszów)
PericlesTheo
2
@jcarpio Thanks. Hash#merge!zwraca wartość skrótu odbiornika, tak jak Array#<<zwraca tablicę odbiornika. Hash#storeto zupełnie inna sprawa. Ponadto, z cukrem składni mieszania key: "bar"w pozycji argumentu, pomyślałem, że jest to najbliższe możliwe do uzyskania notacji. Wiedziałem, że ten jest bliżej tego, czego chciałeś.
sawa
89

Ponieważ skróty nie są z natury uporządkowane, nie istnieje pojęcie dołączania. Jednak skróty Ruby od wersji 1.9 utrzymują kolejność reklam. Oto sposoby dodawania nowych par klucz / wartość.

Najprostszym rozwiązaniem jest

h[:key] = "bar"

Jeśli chcesz metodę, użyj store:

h.store(:key, "bar")

Jeśli naprawdę chcesz użyć operatora „łopata” ( <<), w rzeczywistości jest on dołączany do wartości skrótu jako tablica i musisz określić klucz:

h[:key] << "bar"

Powyższe działa tylko wtedy, gdy istnieje klucz. Aby dołączyć nowy klucz, musisz zainicjować skrót wartością domyślną, co możesz zrobić w następujący sposób:

h = Hash.new {|h, k| h[k] = ''}
h[:key] << "bar"

Możesz ulec pokusie, aby małpa łatać Hash, aby dołączyć operatora łopaty, który działa w sposób, w jaki napisałeś:

class Hash
  def <<(k,v)
    self.store(k,v)
  end
end

Jednak to nie dziedziczy „cukru syntaktycznego” stosowanego do operatora łopaty w innych kontekstach:

h << :key, "bar" #doesn't work
h.<< :key, "bar" #works
Mark Thomas
źródło
Dokładny! Dzięki za wkład i wgląd.
jcarpio
Należy zauważyć, że od Ruby 1.9 skróty są uporządkowane.
stal
1
Ruby 1.9+ utrzymuje kolejność wstawiania, ale Hash jako struktura danych nie ma pojęcia żadnego rodzaju wrodzonej kolejności.
Mark Thomas
27

Nie, nie sądzę, aby można było dołączać pary klucz / wartość. Jedyne, co jest mi najbliższe , to użycie storemetody:

h = {}
h.store("key", "value")
PericlesTheo
źródło
3

Może chcesz Hash # merge?

1.9.3p194 :015 > h={}
 => {} 
1.9.3p194 :016 > h.merge(:key => 'bar')
 => {:key=>"bar"} 
1.9.3p194 :017 > 

Jeśli chcesz zmienić tablicę w miejscu, użyj merge!

1.9.3p194 :016 > h.merge!(:key => 'bar')
 => {:key=>"bar"} 
Michael Durrant
źródło
Myślę, że mergeto nie jest dobry pomysł, ponieważ zwraca nową tablicę; nie dodawanie nowej pary do istniejącego skrótu.
PericlesTheo
A co z merge!(tj. Do istniejącej tablicy) zamiast merge?
Michael Durrant
1
merge!technicznie działa w tym kontekście, ale myślę, że powinien być używany do łączenia dwóch skrótów, a nie po prostu dodawania nowej pary. Ponadto, jeśli porównasz merge!, jest wolniej niż store;)
PericlesTheo
3

Są podobne merge!i storetraktują istniejące skróty w różny sposób w zależności od nazw kluczy, dlatego wpłyną na twoje preferencje. Inne niż to, z punktu widzenia składni, merge!„s key: "value"składnia zbliżony przeciwko JavaScript i Python. Osobiście zawsze nienawidziłem par klucz-wartość oddzielających przecinki.

hash = {}
hash.merge!(key: "value")
hash.merge!(:key => "value")
puts hash

{:key=>"value"}

hash = {}
hash.store(:key, "value")
hash.store("key", "value")
puts hash

{:key=>"value", "key"=>"value"}

Aby operator łopaty <<działał, radziłbym skorzystać z odpowiedzi Marka Thomasa .

kayleeFrye_onDeck
źródło
1

Musiałem zrobić podobną rzecz, ale musiałem dodać wartości z tymi samymi kluczami. Kiedy używam scalania lub aktualizacji, nie mogę wypychać wartości za pomocą tych samych kluczy. Musiałem więc użyć tablicy skrótów.

    my_hash_static = {:header =>{:company => 'xx', :usercode => 'xx', :password => 'xx',
                      :type=> 'n:n', :msgheader => from}, :body=>[]}
    my_hash_dynamic = {:mp=>{:msg=>message, :no=>phones} }        
    my_hash_full = my_hash_static[:body].push my_hash_dynamic
Caner Çakmak
źródło