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.
Enumerablecollect, 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 falseObject#==) 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 → falseh = { "a" => 100, "b" => 200 }
h["a"] → 100
h["c"] → nilString 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 200h = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }produces:
a
bHash#each.
h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }produces:
100
200true or falsetrue if hsh contains no key-value pairs.
{}.empty? → trueIndexError 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:2true or falsetrue if the given key is present in hsh.
h = { "a" => 100, "b" => 200 }
h.has_key?("a") → true
h.has_key?("z") → falsetrue or falsetrue 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) → falsetrue or falseHash#has_key?.
h = { "a" => 100, "b" => 200 }
h.index(200) → "b"
h.index(999) → nilh = { "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 falseHash#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 → 3true or falseHash#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] → 100Hash#delete_if, but works on (and returns) a
copy of the hsh. Equivalent to hsh.dup.delete_if.
nilHash#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 falseHash#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.