Bagaimana menambahkan hash yang sudah ada di Ruby

Berkenaan dengan menambahkan key => valuepasangan ke hash terpopulasi yang ada di Ruby, saya sedang dalam proses mengerjakan Ruby Awal dari Apress dan baru saja menyelesaikan bab hashes.

Saya mencoba menemukan cara paling sederhana untuk mencapai hasil yang sama dengan hash seperti ini dengan array:

x = [1, 2, 3, 4]
x << 5
p x

Jika Anda memiliki hash, Anda dapat menambahkan item ke dalamnya dengan mereferensikannya dengan kunci:

hash = { }
hash[:a] = 'a'
hash[:a]
# => 'a'

Di sini, seperti [ ]membuat array kosong, { }akan membuat hash kosong.

Array memiliki nol atau lebih elemen dalam urutan tertentu, di mana elemen dapat diduplikasi. Hash memiliki nol atau lebih elemen yang diatur berdasarkan kunci , di mana kunci tidak boleh diduplikasi tetapi nilai yang disimpan di posisi tersebut dapat.

Hash di Ruby sangat fleksibel dan dapat memiliki hampir semua jenis kunci yang dapat Anda lemparkan. Ini membuatnya berbeda dari struktur kamus yang Anda temukan dalam bahasa lain.

Penting untuk diingat bahwa sifat spesifik dari kunci hash sering kali penting:

hash = { :a => 'a' }

# Fetch with Symbol :a finds the right value
hash[:a]
# => 'a'

# Fetch with the String 'a' finds nothing
hash['a']
# => nil

# Assignment with the key :b adds a new entry
hash[:b] = 'Bee'

# This is then available immediately
hash[:b]
# => "Bee"

# The hash now contains both keys
hash
# => { :a => 'a', :b => 'Bee' }

Ruby on Rails mengacaukannya dengan menyediakan HashWithIndifferentAccess yang akan mengonversi secara bebas antara metode pengalamatan Symbol dan String.

Anda juga dapat mengindeks hampir semua hal, termasuk kelas, angka, atau Hash lainnya.

hash = { Object => true, Hash => false }

hash[Object]
# => true

hash[Hash]
# => false

hash[Array]
# => nil

Hash dapat diubah menjadi Array dan sebaliknya:

# Like many things, Hash supports .to_a
{ :a => 'a' }.to_a
# => [[:a, "a"]]

# Hash also has a handy Hash[] method to create new hashes from arrays
Hash[[[:a, "a"]]]
# => {:a=>"a"} 

Ketika sampai pada "memasukkan" sesuatu ke dalam Hash, Anda dapat melakukannya satu per satu, atau menggunakan mergemetode untuk menggabungkan hash:

{ :a => 'a' }.merge(:b => 'b')
# {:a=>'a',:b=>'b'}

Perhatikan bahwa ini tidak mengubah hash asli, tetapi mengembalikan yang baru. Jika Anda ingin menggabungkan satu hash ke hash lainnya, Anda dapat menggunakan merge!metode:

hash = { :a => 'a' }

# Returns the result of hash combined with a new hash, but does not alter
# the original hash.
hash.merge(:b => 'b')
# => {:a=>'a',:b=>'b'}

# Nothing has been altered in the original
hash
# => {:a=>'a'}

# Combine the two hashes and store the result in the original
hash.merge!(:b => 'b')
# => {:a=>'a',:b=>'b'}

# Hash has now been altered
hash
# => {:a=>'a',:b=>'b'}

Seperti banyak metode pada String dan Array, ini !menunjukkan bahwa ini adalah operasi di tempat .

my_hash = {:a => 5}
my_hash[:key] = "value"

Jika Anda ingin menambahkan lebih dari satu:

hash = {:a => 1, :b => 2}
hash.merge! :c => 3, :d => 4
p hash

x = {:ca => "Canada", :us => "United States"}
x[:de] = "Germany"
p x

hash = { a: 'a', b: 'b' }
 => {:a=>"a", :b=>"b"}
hash.merge({ c: 'c', d: 'd' })
 => {:a=>"a", :b=>"b", :c=>"c", :d=>"d"} 

Mengembalikan nilai yang digabungkan.

hash
 => {:a=>"a", :b=>"b"} 

Tapi tidak mengubah objek pemanggil

hash = hash.merge({ c: 'c', d: 'd' })
 => {:a=>"a", :b=>"b", :c=>"c", :d=>"d"} 
hash
 => {:a=>"a", :b=>"b", :c=>"c", :d=>"d"} 

Penugasan kembali berhasil.

hash {}
hash[:a] = 'a'
hash[:b] = 'b'
hash = {:a => 'a' , :b = > b}

Anda mungkin mendapatkan kunci dan nilai dari input pengguna, sehingga Anda dapat menggunakan Ruby .to_sym dapat mengonversi string menjadi simbol, dan .to_i akan mengonversi string menjadi integer.
Sebagai contoh:

movies ={}
movie = gets.chomp
rating = gets.chomp
movies[movie.to_sym] = rating.to_int
# movie will convert to a symbol as a key in our hash, and 
# rating will be an integer as a value.

Anda dapat menggunakan operator percikan ganda yang tersedia sejak Ruby 2.0:

h = { a: 1, b: 2 }
h = { **h, c: 3 }
p h
# => {:a=>1, :b=>2, :c=>3}