Class: Hash
Relationships & Source Files | |
Super Chains via Extension / Inclusion / Inheritance | |
Instance Chain:
self,
::Enumerable
|
|
Inherits: | Object |
Defined in: | hash.c |
Overview
A Hash is a dictionary-like collection of unique keys and their values. Also called associative arrays, they are similar to Arrays, but where an ::Array uses integers as its index, a Hash
allows you to use any object type.
Hashes enumerate their values in the order that the corresponding keys were inserted.
A Hash can be easily created by using its implicit form:
grades = { "Jane Doe" => 10, "Jim Doe" => 6 }
Hashes allow an alternate syntax for keys that are symbols. Instead of
= { :font_size => 10, :font_family => "Arial" }
You could write it as:
= { font_size: 10, font_family: "Arial" }
Each named key is a symbol you can access in hash:
:font_size] # => 10
[
A Hash can also be created through its .new method:
grades = Hash.new
grades["Dorothy Doe"] = 9
Hashes have a default value that is returned when accessing keys that do not exist in the hash. If no default is set nil
is used. You can set the default value by sending it as an argument to .new:
grades = Hash.new(0)
Or by using the #default= method:
grades = {"Timmy Doe" => 8}
grades.default = 0
Accessing a value in a Hash
requires using its key:
puts grades["Jane Doe"] # => 0
Common Uses
Hashes are an easy way to represent data structures, such as
books = {}
books[:matz] = "The Ruby Language"
books[:black] = "The Well-Grounded Rubyist"
Hashes are also commonly used as a way to have named parameters in functions. Note that no brackets are used below. If a hash is the last argument on a method call, no braces are needed, thus creating a really clean interface:
Person.create(name: "John Doe", age: 27)
def self.create(params)
@name = params[:name]
@age = params[:age]
end
Hash Keys
Two objects refer to the same hash key when their #hash value is identical and the two objects are #eql? to each other.
A user-defined class may be used as a hash key if the #hash and #eql? methods are overridden to provide meaningful behavior. By default, separate instances refer to separate hash keys.
A typical implementation of #hash is based on the object's data while #eql? is usually aliased to the overridden #== method:
class Book
attr_reader :, :title
def initialize(, title)
@author =
@title = title
end
def ==(other)
self.class === other and
other. == @author and
other.title == @title
end
alias eql? ==
def hash
@author.hash ^ @title.hash # XOR
end
end
book1 = Book.new 'matz', 'Ruby in a Nutshell'
book2 = Book.new 'matz', 'Ruby in a Nutshell'
reviews = {}
reviews[book1] = 'Great reference!'
reviews[book2] = 'Nice and compact!'
reviews.length #=> 1
See also Object#hash and Object#eql?
Class Method Summary
-
.[](key, value, ... ) ⇒ Hash
Creates a new hash populated with the given objects.
-
.new ⇒ Hash
constructor
Returns a new, empty hash.
-
.try_convert(obj) ⇒ Hash?
Try to convert obj into a hash, using to_hash method.
Instance Attribute Summary
-
#default_proc ⇒ Object
rw
If .new was invoked with a block, return that block, otherwise return
nil
. -
#default_proc=(proc_obj or nil)
rw
Sets the default proc to be executed on each failed key lookup.
-
#any? {|(key, value)| ... } ⇒ Boolean
readonly
See also Enumerable#any?
-
#compare_by_identity ⇒ Hash
readonly
Makes hsh compare its keys by their identity, i.e. it will consider exact same objects as same keys.
-
#compare_by_identity? ⇒ Boolean
readonly
Returns
true
if hsh will compare its keys by their identity. -
#empty? ⇒ Boolean
readonly
Returns
true
if hsh contains no key-value pairs.
::Enumerable - Included
Instance Method Summary
-
#<(other) ⇒ Boolean
Returns
true
if hash is subset of other. -
#<=(other) ⇒ Boolean
Returns
true
if hash is subset of other or equals to other. -
#==(other_hash) ⇒ Boolean
Equality—Two hashes are equal if they each contain the same number of keys and if each key-value pair is equal to (according to
Object#==
) the corresponding elements in the other hash. -
#>(other) ⇒ Boolean
Returns
true
if other is subset of hash. -
#>=(other) ⇒ Boolean
Returns
true
if other is subset of hash or equals to hash. -
#[](key) ⇒ value
Element Reference—Retrieves the value object corresponding to the key object.
-
#[]=(key, value) ⇒ value
(also: #store)
Element Assignment.
-
#assoc(obj) ⇒ Array?
Searches through the hash comparing obj with the key using #==.
-
#clear ⇒ Hash
Removes all key-value pairs from hsh.
-
#default(key = nil) ⇒ Object
Returns the default value, the value that would be returned by hsh if key did not exist in hsh.
-
#default=(obj) ⇒ Object
Sets the default value, the value returned for a key that does not exist in the hash.
-
#delete(key) ⇒ value
Deletes the key-value pair and returns the value from hsh whose key is equal to key.
-
#delete_if {|key, value| ... } ⇒ Hash
Deletes every key-value pair from hsh for which block evaluates to
true
. -
#dig(key, ...) ⇒ Object
Extracts the nested value specified by the sequence of key objects by calling
dig
at each step, returningnil
if any intermediate step isnil
. -
#each {|key, value| ... } ⇒ Hash
(also: #each_pair)
Calls block once for each key in hsh, passing the key-value pair as parameters.
-
#each_key {|key| ... } ⇒ Hash
Calls block once for each key in hsh, passing the key as a parameter.
-
#each_pair {|key, value| ... } ⇒ Hash
Alias for #each.
-
#each_value {|value| ... } ⇒ Hash
Calls block once for each key in hsh, passing the value as a parameter.
-
#eql?(other) ⇒ Boolean
Returns
true
if hash and other are both hashes with the same content. -
#fetch(key [, default] ) ⇒ Object
Returns a value from the hash for the given key.
-
#fetch_values(key, ...) ⇒ Array
Returns an array containing the values associated with the given keys but also raises ::KeyError when one of keys can't be found.
-
#flatten ⇒ Array
Returns a new array that is a one-dimensional flattening of this hash.
-
#has_key?(key) ⇒ Boolean
Alias for #key?.
-
#has_value?(value) ⇒ Boolean
Alias for #value?.
-
#hash ⇒ Fixnum
Compute a hash-code for this hash.
-
#include?(key) ⇒ Boolean
Alias for #key?.
-
#inspect ⇒ String
Alias for #to_s.
-
#invert ⇒ Hash
Returns a new hash created by using hsh's values as keys, and the keys as values.
-
#keep_if {|key, value| ... } ⇒ Hash
Deletes every key-value pair from hsh for which block evaluates to false.
-
#key(value) ⇒ key
Returns the key of an occurrence of a given value.
-
#key?(key) ⇒ Boolean
(also: #include?, #member?, #has_key?)
Returns
true
if the given key is present in hsh. -
#keys ⇒ Array
Returns a new array populated with the keys from this hash.
-
#length ⇒ Fixnum
(also: #size)
Returns the number of key-value pairs in the hash.
-
#member?(key) ⇒ Boolean
Alias for #key?.
-
#merge(other_hash) ⇒ Hash
Returns a new hash containing the contents of other_hash and the contents of hsh.
-
#merge!(other_hash) ⇒ Hash
(also: #update)
Adds the contents of other_hash to hsh.
-
#rassoc(obj) ⇒ Array?
Searches through the hash comparing obj with the value using #==.
-
#rehash ⇒ Hash
Rebuilds the hash based on the current hash values for each key.
-
#reject {|key, value| ... } ⇒ Hash
Returns a new hash consisting of entries for which the block returns false.
-
#reject! {|key, value| ... } ⇒ Hash?
Equivalent to #delete_if, but returns
nil
if no changes were made. -
#replace(other_hash) ⇒ Hash
Replaces the contents of hsh with the contents of other_hash.
-
#select {|key, value| ... } ⇒ Hash
Returns a new hash consisting of entries for which the block returns true.
-
#select! {|key, value| ... } ⇒ Hash?
Equivalent to #keep_if, but returns
nil
if no changes were made. -
#shift ⇒ Array, Object
Removes a key-value pair from hsh and returns it as the two-item array
[
key, value]
, or the hash's default value if the hash is empty. -
#size ⇒ Fixnum
Alias for #length.
-
#store(key, value) ⇒ value
Alias for #[]=.
-
#to_a ⇒ Array
Converts hsh to a nested array of
[
key, value]
arrays. -
#to_h ⇒ Hash
Returns
self
. -
#to_hash ⇒ Hash
Returns
self
. - #to_proc
-
#to_s ⇒ String
(also: #inspect)
Return the contents of this hash as a string.
-
#update(other_hash) ⇒ Hash
Alias for #merge!.
-
#value?(value) ⇒ Boolean
(also: #has_value?)
Returns
true
if the given value is present for some key in hsh. -
#values ⇒ Array
Returns a new array populated with the values from hsh.
-
#values_at(key, ...) ⇒ Array
Return an array containing the values associated with the given keys.
::Enumerable - Included
#chunk | Enumerates over the items, chunking them together based on the return value of the block. |
#chunk_while | Creates an enumerator for each chunked elements. |
#collect | Alias for Enumerable#map. |
#collect_concat | Alias for Enumerable#flat_map. |
#count | Returns the number of items in |
#cycle | Calls block for each element of enum repeatedly n times or forever if none or |
#detect | Alias for Enumerable#find. |
#drop | Drops first n elements from enum, and returns rest elements in an array. |
#drop_while | Drops elements up to, but not including, the first element for which the block returns |
#each_cons | Iterates the given block for each array of consecutive <n> elements. |
#each_entry | Calls block once for each element in |
#each_slice | Iterates the given block for each slice of <n> elements. |
#each_with_index | Calls block with two arguments, the item and its index, for each item in enum. |
#each_with_object | Iterates the given block for each element with an arbitrary object given, and returns the initially given object. |
#entries | Alias for Enumerable#to_a. |
#find | Passes each entry in enum to block. |
#find_all | Alias for Enumerable#select. |
#find_index | Compares each entry in enum with value or passes to block. |
#first | Returns the first element, or the first |
#flat_map | Returns a new array with the concatenated results of running block once for every element in enum. |
#grep | Returns an array of every element in enum for which |
#grep_v | Inverted version of Enumerable#grep. |
#group_by | Groups the collection by result of the block. |
#include? | Alias for Enumerable#member?. |
#inject | Combines all elements of enum by applying a binary operation, specified by a block or a symbol that names a method or operator. |
#lazy | Returns a lazy enumerator, whose methods map/collect, flat_map/collect_concat, select/find_all, reject, grep, grep_v, zip, take, take_while, drop, and drop_while enumerate values only on an as-needed basis. |
#map | Returns a new array with the results of running block once for every element in enum. |
#max | Returns the object in enum with the maximum value. |
#max_by | Returns the object in enum that gives the maximum value from the given block. |
#member? | Returns |
#min | Returns the object in enum with the minimum value. |
#min_by | Returns the object in enum that gives the minimum value from the given block. |
#minmax | Returns a two element array which contains the minimum and the maximum value in the enumerable. |
#minmax_by | Returns a two element array containing the objects in enum that correspond to the minimum and maximum values respectively from the given block. |
#partition | Returns two arrays, the first containing the elements of enum for which the block evaluates to true, the second containing the rest. |
#reduce | Alias for Enumerable#inject. |
#reject | Returns an array for all elements of |
#reverse_each | Builds a temporary array and traverses that array in reverse order. |
#select | Returns an array containing all elements of |
#slice_after | Creates an enumerator for each chunked elements. |
#slice_before | Creates an enumerator for each chunked elements. |
#slice_when | Creates an enumerator for each chunked elements. |
#sort | Returns an array containing the items in enum sorted, either according to their own |
#sort_by | Sorts enum using a set of keys generated by mapping the values in enum through the given block. |
#take | Returns first n elements from enum. |
#take_while | Passes elements to the block until the block returns |
#to_a | Returns an array containing the items in enum. |
#to_h | Returns the result of interpreting enum as a list of |
#zip | Takes one element from enum and merges corresponding elements from each args. |
Constructor Details
.new ⇒ Hash
.new(obj) ⇒ Hash
.new {|hash, key| ... } ⇒ Hash
Hash
.new(obj) ⇒ Hash
.new {|hash, key| ... } ⇒ Hash
Returns a new, empty hash. If this hash is subsequently accessed by a key that doesn't correspond to a hash entry, the value returned depends on the style of new
used to create the hash. In the first form, the access returns nil
. If obj is specified, this single object will be used for all default values. If a block is specified, it will be called with the hash object and the key, and should return the default value. It is the block's responsibility to store the value in the hash if required.
h = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"] #=> 100
h["c"] #=> "Go Fish"
# The following alters the single default object
h["c"].upcase! #=> "GO FISH"
h["d"] #=> "GO FISH"
h.keys #=> ["a", "b"]
# While this creates a new default object each time
h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
h["c"] #=> "Go Fish: c"
h["c"].upcase! #=> "GO FISH: C"
h["d"] #=> "Go Fish: d"
h.keys #=> ["c", "d"]
Class Method Details
.[](key, value, ... ) ⇒ Hash
.[]([ [key, value], ... ] ) ⇒ Hash
.[](object ) ⇒ Hash
Hash
.[]([ [key, value], ... ] ) ⇒ Hash
.[](object ) ⇒ Hash
Creates a new hash populated with the given objects.
Similar to the literal { key => value, ... }
. In the first form, keys and values occur in pairs, so there must be an even number of arguments.
The second and third form take a single argument which is either an array of key-value pairs or an object convertible to a hash.
Hash["a", 100, "b", 200] #=> {"a"=>100, "b"=>200}
Hash[ [ ["a", 100], ["b", 200] ] ] #=> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] #=> {"a"=>100, "b"=>200}
.try_convert(obj) ⇒ Hash
?
Try to convert obj into a hash, using to_hash method. Returns converted hash or nil if obj cannot be converted for any reason.
Hash.try_convert({1=>2}) # => {1=>2}
Hash.try_convert("1=>2") # => nil
Instance Attribute Details
#any? {|(key, value)| ... } ⇒ Boolean
(readonly)
#any? ⇒ Boolean
Boolean
(readonly)
#any? ⇒ Boolean
See also Enumerable#any?
#compare_by_identity ⇒ Hash
(readonly)
Makes hsh compare its keys by their identity, i.e. it will consider exact same objects as same keys.
h1 = { "a" => 100, "b" => 200, :c => "c" }
h1["a"] #=> 100
h1.compare_by_identity
h1.compare_by_identity? #=> true
h1["a".dup] #=> nil # different objects.
h1[:c] #=> "c" # same symbols are all same.
#compare_by_identity? ⇒ Boolean
(readonly)
Returns true
if hsh will compare its keys by their identity. Also see #compare_by_identity.
#default_proc ⇒ Object (rw)
#default_proc=(proc_obj or nil) (rw)
#empty? ⇒ Boolean
(readonly)
Returns true
if hsh contains no key-value pairs.
{}.empty? #=> true
Instance Method Details
#<(other) ⇒ Boolean
Returns true
if hash is subset of other.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2 #=> true
h2 < h1 #=> false
h1 < h1 #=> false
#<=(other) ⇒ Boolean
Returns true
if hash is subset of other or equals to other.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2 #=> true
h2 <= h1 #=> false
h1 <= h1 #=> true
#==(other_hash) ⇒ Boolean
Equality—Two hashes are equal if they each contain the same number of keys and if each key-value pair is equal to (according to Object#==
) the corresponding elements in the other hash.
h1 = { "a" => 1, "c" => 2 }
h2 = { 7 => 35, "c" => 2, "a" => 1 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2 #=> false
h2 == h3 #=> true
h3 == h4 #=> false
The orders of each hashes are not compared.
h1 = { "a" => 1, "c" => 2 }
h2 = { "c" => 2, "a" => 1 }
h1 == h2 #=> true
#>(other) ⇒ Boolean
Returns true
if other is subset of hash.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2 #=> false
h2 > h1 #=> true
h1 > h1 #=> false
#>=(other) ⇒ Boolean
Returns true
if other is subset of hash or equals to hash.
h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2 #=> false
h2 >= h1 #=> true
h1 >= h1 #=> true
#[](key) ⇒ value
Element Reference—Retrieves the value object corresponding to the key object. If not found, returns the default value (see .new for details).
h = { "a" => 100, "b" => 200 }
h["a"] #=> 100
h["c"] #=> nil
#[]=(key, value) ⇒ value
#store(key, value) ⇒ value
Also known as: #store
value
#store(key, value) ⇒ value
Element Assignment
Associates the value given by value
with the key given by #key.
h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h #=> {"a"=>9, "b"=>200, "c"=>4}
h.store("d", 42) #=> 42
h #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
#key should not have its value changed while it is in use as a key (an unfrozen String
passed as a key will be duplicated and frozen).
a = "a"
b = "b".freeze
h = { a => 100, b => 200 }
h.key(100).equal? a #=> false
h.key(200).equal? b #=> true
#assoc(obj) ⇒ Array?
Searches through the hash comparing obj with the key using #==. Returns the key-value pair (two elements array) or nil
if no match is found. See Array#assoc.
h = {"colors" => ["red", "blue", "green"],
"letters" => ["a", "b", "c" ]}
h.assoc("letters") #=> ["letters", ["a", "b", "c"]]
h.assoc("foo") #=> nil
#clear ⇒ Hash
Removes all key-value pairs from hsh.
h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
h.clear #=> {}
#default(key = nil) ⇒ Object
Returns the default value, the value that would be returned by hsh if key did not exist in hsh. See also .new and #default=.
h = Hash.new #=> {}
h.default #=> nil
h.default(2) #=> nil
h = Hash.new("cat") #=> {}
h.default #=> "cat"
h.default(2) #=> "cat"
h = Hash.new {|h,k| h[k] = k.to_i*10} #=> {}
h.default #=> nil
h.default(2) #=> 20
#default=(obj) ⇒ Object
Sets the default value, the value returned for a key that does not exist in the hash. It is not possible to set the default to a ::Proc that will be executed on each key lookup.
h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"] #=> 100
h["z"] #=> "Go fish"
# This doesn't do what you might hope...
h.default = proc do |hash, key|
hash[key] = key + key
end
h[2] #=> #<Proc:0x401b3948@-:6>
h["cat"] #=> #<Proc:0x401b3948@-:6>
#delete(key) ⇒ value
#delete(key) {|key| ... } ⇒ value
value
#delete(key) {|key| ... } ⇒ value
Deletes the key-value pair and returns the value from hsh whose key is equal to key. If the key is not found, it returns nil. If the optional code block is given and the key is not found, pass in the key and return the result of block.
h = { "a" => 100, "b" => 200 }
h.delete("a") #=> 100
h.delete("z") #=> nil
h.delete("z") { |el| "#{el} not found" } #=> "z not found"
#delete_if {|key, value| ... } ⇒ Hash
#delete_if ⇒ Enumerator
Hash
#delete_if ⇒ Enumerator
#dig(key, ...) ⇒ Object
Extracts the nested value specified by the sequence of key objects by calling dig
at each step, returning nil
if any intermediate step is nil
.
h = { foo: {bar: {baz: 1}}}
h.dig(:foo, :, :baz) #=> 1
h.dig(:foo, :zot, :xyz) #=> nil
g = { foo: [10, 11, 12] }
g.dig(:foo, 1) #=> 11
g.dig(:foo, 1, 0) #=> TypeError: Fixnum does not have #dig method
g.dig(:foo, : ) #=> TypeError: no implicit conversion of Symbol into Integer
#each {|key, value| ... } ⇒ Hash
#each_pair {|key, value| ... } ⇒ Hash
#each ⇒ Enumerator
#each_pair ⇒ Enumerator
Also known as: #each_pair
Hash
#each_pair {|key, value| ... } ⇒ Hash
#each ⇒ Enumerator
#each_pair ⇒ Enumerator
#each_key {|key| ... } ⇒ Hash
#each_key ⇒ Enumerator
Hash
#each_key ⇒ Enumerator
#each {|key, value| ... } ⇒ Hash
#each_pair {|key, value| ... } ⇒ Hash
#each ⇒ Enumerator
#each_pair ⇒ Enumerator
Hash
#each_pair {|key, value| ... } ⇒ Hash
#each ⇒ Enumerator
#each_pair ⇒ Enumerator
Alias for #each.
#each_value {|value| ... } ⇒ Hash
#each_value ⇒ Enumerator
Hash
#each_value ⇒ Enumerator
Calls block once for each key in hsh, passing the value as a parameter.
If no block is given, an enumerator is returned instead.
h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }
produces:
100
200
#eql?(other) ⇒ Boolean
Returns true
if hash and other are both hashes with the same content. The orders of each hashes are not compared.
Returns a value from the hash for the given key. If the key can't be found, there are several options: With no other arguments, it will raise an ::KeyError exception; if default 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"
The following example shows that an exception is raised if the key is not found and a default value is not supplied.
h = { "a" => 100, "b" => 200 }
h.fetch("z")
produces:
prog.rb:2:in `fetch': key not found (KeyError)
from prog.rb:2
Returns an array containing the values associated with the given keys but also raises ::KeyError when one of keys can't be found. Also see #values_at and #fetch.
h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
h.fetch_values("cow", "cat") #=> ["bovine", "feline"]
h.fetch_values("cow", "bird") # raises KeyError
h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"]
Returns a new array that is a one-dimensional flattening of this hash. That is, for every key or value that is an array, extract its elements into the new array. Unlike Array#flatten, this method does not flatten recursively by default. The optional level argument determines the level of recursion to flatten.
a = {1=> "one", 2 => [2,"two"], 3 => "three"}
a.flatten # => [1, "one", 2, [2, "two"], 3, "three"]
a.flatten(2) # => [1, "one", 2, 2, "two", 3, "three"]
#has_key?(key) ⇒ Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
Alias for #key?.
#has_value?(value) ⇒ Boolean
#value?(value) ⇒ Boolean
Boolean
#value?(value) ⇒ Boolean
Alias for #value?.
#hash ⇒ Fixnum
Compute a hash-code for this hash. Two hashes with the same content will have the same hash code (and will compare using #eql?).
See also Object#hash.
#has_key?(key) ⇒ Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
Alias for #key?.
Alias for #to_s.
#invert ⇒ Hash
Returns a new hash created by using hsh's values as keys, and the keys as values. If a key with the same value already exists in the hsh, then the last one defined will be used, the earlier value(s) will be discarded.
h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
h.invert #=> {0=>"a", 100=>"m", 200=>"d", 300=>"y"}
#keep_if {|key, value| ... } ⇒ Hash
#keep_if ⇒ Enumerator
Hash
#keep_if ⇒ Enumerator
Deletes every key-value pair from hsh for which block evaluates to false.
If no block is given, an enumerator is returned instead.
#key(value) ⇒ key
Returns the key of an occurrence of a given value. If the value is not found, returns nil
.
h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 }
h.key(200) #=> "b"
h.key(300) #=> "c"
h.key(999) #=> nil
#has_key?(key) ⇒ Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
Also known as: #include?, #member?, #has_key?
Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
#keys ⇒ Array
Returns a new array populated with the keys from this hash. See also #values.
h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
h.keys #=> ["a", "b", "c", "d"]
Also known as: #size
Returns the number of key-value pairs in the hash.
h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.length #=> 4
h.delete("a") #=> 200
h.length #=> 3
#has_key?(key) ⇒ Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
Boolean
#include?(key) ⇒ Boolean
#key?(key) ⇒ Boolean
#member?(key) ⇒ Boolean
Alias for #key?.
#merge(other_hash) ⇒ Hash
#merge(other_hash) {|key, oldval, newval| ... } ⇒ Hash
Hash
#merge(other_hash) {|key, oldval, newval| ... } ⇒ Hash
Returns a new hash containing the contents of other_hash and the contents of hsh. If no block is specified, the value for entries with duplicate keys will be that of other_hash. Otherwise the value for each duplicate key is determined by calling the block with the key, its value in hsh and its value in other_hash.
h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge(h2) #=> {"a"=>100, "b"=>254, "c"=>300}
h1.merge(h2){|key, oldval, newval| newval - oldval}
#=> {"a"=>100, "b"=>54, "c"=>300}
h1 #=> {"a"=>100, "b"=>200}
#merge!(other_hash) ⇒ Hash
#update(other_hash) ⇒ Hash
#merge!(other_hash) {|key, oldval, newval| ... } ⇒ Hash
#update(other_hash) {|key, oldval, newval| ... } ⇒ Hash
Also known as: #update
Hash
#update(other_hash) ⇒ Hash
#merge!(other_hash) {|key, oldval, newval| ... } ⇒ Hash
#update(other_hash) {|key, oldval, newval| ... } ⇒ Hash
Adds the contents of other_hash to hsh. If no block is specified, entries with duplicate keys are overwritten with the values from other_hash, otherwise the value of each duplicate key is determined by calling the block with the key, its value in hsh and its value in other_hash.
h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge!(h2) #=> {"a"=>100, "b"=>254, "c"=>300}
h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.merge!(h2) { |key, v1, v2| v1 }
#=> {"a"=>100, "b"=>200, "c"=>300}
#rassoc(obj) ⇒ Array?
Searches through the hash comparing obj with the value using #==. Returns the first key-value pair (two-element array) that matches. See also Array#rassoc.
a = {1=> "one", 2 => "two", 3 => "three", "ii" => "two"}
a.rassoc("two") #=> [2, "two"]
a.rassoc("four") #=> nil
#rehash ⇒ Hash
Rebuilds the hash based on the current hash values for each key. If values of key objects have changed since they were inserted, this method will reindex hsh. If rehash
is called while an iterator is traversing the hash, a ::RuntimeError 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
#reject {|key, value| ... } ⇒ Hash
#reject ⇒ Enumerator
Hash
#reject ⇒ Enumerator
Returns a new hash consisting of entries for which the block returns false.
If no block is given, an enumerator is returned instead.
h = { "a" => 100, "b" => 200, "c" => 300 }
h.reject {|k,v| k < "b"} #=> {"b" => 200, "c" => 300}
h.reject {|k,v| v > 100} #=> {"a" => 100}
#reject! {|key, value| ... } ⇒ Hash
?
#reject! ⇒ Enumerator
Hash
?
#reject! ⇒ Enumerator
Equivalent to #delete_if, but returns nil
if no changes were made.
#replace(other_hash) ⇒ Hash
Replaces the contents of hsh with the contents of other_hash.
h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 }) #=> {"c"=>300, "d"=>400}
#select {|key, value| ... } ⇒ Hash
#select ⇒ Enumerator
Hash
#select ⇒ Enumerator
Returns a new hash consisting of entries for which the block returns true.
If no block is given, an enumerator is returned instead.
h = { "a" => 100, "b" => 200, "c" => 300 }
h.select {|k,v| k > "a"} #=> {"b" => 200, "c" => 300}
h.select {|k,v| v < 200} #=> {"a" => 100}
#select! {|key, value| ... } ⇒ Hash
?
#select! ⇒ Enumerator
Hash
?
#select! ⇒ Enumerator
Equivalent to #keep_if, but returns nil
if no changes were made.
#shift ⇒ Array, Object
Removes a key-value pair from hsh and returns it as the two-item array [
key, value ]
, or the hash's default value if the hash is empty.
h = { 1 => "a", 2 => "b", 3 => "c" }
h.shift #=> [1, "a"]
h #=> {2=>"b", 3=>"c"}
Alias for #length.
#[]=(key, value) ⇒ value
#store(key, value) ⇒ value
value
#store(key, value) ⇒ value
Alias for #[]=.
#to_a ⇒ Array
Converts hsh to a nested array of [
key, value ]
arrays.
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_a #=> [["c", 300], ["a", 100], ["d", 400]]
#to_h ⇒ Hash
Returns self
. If called on a subclass of Hash
, converts the receiver to a Hash
object.
#to_hash ⇒ Hash
Returns self
.
#to_proc
Also known as: #inspect
Return the contents of this hash as a string.
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_s #=> "{\"c\"=>300, \"a\"=>100, \"d\"=>400}"
#merge!(other_hash) ⇒ Hash
#update(other_hash) ⇒ Hash
#merge!(other_hash) {|key, oldval, newval| ... } ⇒ Hash
#update(other_hash) {|key, oldval, newval| ... } ⇒ Hash
Hash
#update(other_hash) ⇒ Hash
#merge!(other_hash) {|key, oldval, newval| ... } ⇒ Hash
#update(other_hash) {|key, oldval, newval| ... } ⇒ Hash
Alias for #merge!.
#has_value?(value) ⇒ Boolean
#value?(value) ⇒ Boolean
Also known as: #has_value?
Boolean
#value?(value) ⇒ Boolean
Returns 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
#values ⇒ Array
Returns a new array populated with the values from hsh. See also #keys.
h = { "a" => 100, "b" => 200, "c" => 300 }
h.values #=> [100, 200, 300]
#values_at(key, ...) ⇒ Array
Return an array containing the values associated with the given keys. Also see #select.
h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
h.values_at("cow", "cat") #=> ["bovine", "feline"]