A Hash
is a collection of key-value pairs. It is similar to an Array
, except that indexing is done via arbitrary keys of any object type, not an integer index. The order in which you traverse a hash by either key or value may seem arbitrary, and will generally not be in the insertion order.
Hashes have a default value that is returned when accessing keys that do not exist in the hash. By default, that value is nil
.
Enumerable
collect
, detect
, each_with_index
, entries
, find
, find_all
, grep
, include?
, map
, max
, member?
, min
, reject
, select
, sort
, to_a
{ key, value, ... }
.
Keys and values occur in pairs, so there must be an
even number of arguments.
Hash["a", 100, "b", 200] → {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] → {"a"=>100, "b"=>200}
{ "a" => 100, "b" => 200 } → {"a"=>100, "b"=>200}
nil
) → aHashh = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"] → 100
h["c"] → "Go Fish"
true
or false
Object#==
) the corresponding elements in the other hash.
h1 = { "a" => 1, "c" => 2 }
h2 = { "a" => 1, "c" => 2, 7 => 35 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2 → false
h2 == h3 → true
h3 == h4 → false
h = { "a" => 100, "b" => 200 }
h["a"] → 100
h["c"] → nil
String
passed as a key will be
duplicated and frozen).
h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h → {"a"=>9, "b"=>200, "c"=>4}
h = { "a" => 100, "b" => 200 } → {"a"=>100, "b"=>200}
h.clear → {}
nil
.
See also Hash#default=
.
nil
.
h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"] → 100
h["z"] → "Go fish"
h = { "a" => 100, "b" => 200 }
h.delete("a") → 100
h.delete("z") → nil
h.delete("z") { |el| "#{el} not found" } → "z not found"
true
.
h = { "a" => 100, "b" => 200, "c" => 300 }
h.delete_if {|key, value| key >= "b" } → {"a"=>100}
h = { "a" => 100, "b" => 200 }
h.each {|key, value| print key, " is ", value, "\n" }
produces:
a is 100
b is 200
h = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }
produces:
a
b
Hash#each
.
h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }
produces:
100
200
true
or false
true
if hsh contains no key-value pairs.
{}.empty? → true
IndexError
exception; if
aDefObject is given, then that will be returned; if the
optional code block is specified, then that will be run and its
result returned.
h = { "a" => 100, "b" => 200 }
h.fetch("a") → 100
h.fetch("z", "go fish") → "go fish"
h.fetch("z") { |el| "go fish, #{el}"} → "go fish, z"
h = { "a" => 100, "b" => 200 }
h.fetch("z")
produces:
prog.rb:2:in `fetch': key not found (IndexError)
from prog.rb:2
true
or false
true
if the given key is present in hsh.
h = { "a" => 100, "b" => 200 }
h.has_key?("a") → true
h.has_key?("z") → false
true
or false
true
if the given value is present for some key in
hsh.
h = { "a" => 100, "b" => 200 }
h.has_value?(100) → true
h.has_value?(999) → false
true
or false
Hash#has_key?
.
h = { "a" => 100, "b" => 200 }
h.index(200) → "b"
h.index(999) → nil
h = { "a" => 100, "b" => 200, "c" => 300 }
h.indexes("a", "c") → [100, 300]
h.indexes("a", "c", "z") → [100, 300, nil]
Hash#indexes
.
h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
h.invert → {0=>"a", 100=>"n", 200=>"d", 300=>"y"}
true
or false
Hash#has_key?
.
Hash#values
.
h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
h.keys → ["a", "b", "c", "d"]
h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.length → 4
h.delete("a") → 200
h.length → 3
true
or false
Hash#has_key?
.
Hash#rehash
is called while an
iterator is traversing the hash, an IndexError
will be
raised in the iterator.
a = [ "a", "b" ]
c = [ "c", "d" ]
h = { a => 100, c => 300 }
h[a] → 100
a[0] = "z"
h[a] → nil
h.rehash → {["z", "b"]=>100, ["c", "d"]=>300}
h[a] → 100
Hash#delete_if
, but works on (and returns) a
copy of the hsh. Equivalent to hsh.dup.delete_if
.
nil
Hash#delete_if
, but returns nil
if no
changes were made.
h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 }) → {"c"=>300, "d"=>400}
nil
[
key, value ]
, or nil
if the
hash is empty.
h = { 1 => "a", 2 => "b", 3 => "c" }
h.shift → [1, "a"]
h → {2=>"b", 3=>"c"}
Hash#length
.
[
key, value
]
arrays and sorts it, using Array#sort
.
h = { "a" => 20, "b" => 30, "c" => 10 }
h.sort → [["a", 20], ["b", 30], ["c", 10]]
h.sort {|a,b| a[1]<=>b[1]} → [["c", 10], ["a", 20], ["b", 30]]
Hash#[]=
).
[
key, value
]
arrays.
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_a → [["a", 100], ["c", 300], ["d", 400]]
[
key, value ]
pairs and then converting that array to a string using
Array#join
with the default separator.
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_s → "a100c300d400"
h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.update(h2) → {"a"=>100, "b"=>254, "c"=>300}
true
or false
Hash#has_value?
.
Hash#keys
.
h = { "a" => 100, "b" => 200, "c" => 300 }
h.values → [100, 200, 300]
Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide"
Copyright © 2001 by Addison Wesley Longman, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/).
Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder.
Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.