Is Auto-Initialization of Multi-Dimensional Hash Array Possible in Ruby, as It Is in PHP

Is auto-initialization of multi-dimensional hash array possible in Ruby, as it is in PHP?

Try this:

def hash_with_default_hash
    Hash.new { |hash, key| hash[key] = hash_with_default_hash }
end

a = hash_with_default_hash

If the key doesn't exist, then the result of the block will be used as the default value. In this case, the default value is also a hash which uses hashes as its default values.

Multiple initialization of auto-vivifying hashes using a new operator in Ruby

Where you ask for a := b := c := AutoHash.new.few 3 I think (not sure I understand your desire) that you really want a,b,c=Autohash.new.few 3

---

Why does few take variable args, when you only ever use the first?

I also find your creation of the return value to be confusing, maybe try

def few(n=0) 
  Array.new(n) { AutoHash.new } 
end 

---

Beyond that, it seems like few should be a class method. a,b,c=AutoHash.few 3 which will work if you defined few on the class:

def AutoHash.few(n=0)
  Array.new(n) { AutoHash.new }
end

---

If a,b,c=AutoHash.few 3 isn't what you're looking for, and you really want to implement your own operator, then check out Hacking parse.y, which was a talk given at RubyConf 2009. You can watch the presentation at http://rubyconf2009.confreaks.com/19-nov-2009-17-15-hacking-parsey-tatsuhiro-ujihisa.html and you can see the slides at http://www.slideshare.net/ujihisa/hacking-parsey-rubyconf-2009

How to handle combination []+= for auto-vivifying hash in Ruby?

There is no way to define a []+= method in ruby. What happens when you type

x[y] += z

is

x[y] = x[y] + z

so both the [] and []= methods are called on x (and + is called on x[y], which in this case is an AutoHash). I think that the best way to handle this problem would be to define a + method on AutoHash, which will just return it's argument. This will make AutoHash.new[:x] += y work for just about any type of y, because the "empty" version of y.class ('' for strings, 0 for numbers, ...) plus y will almost always equal y.

class AutoHash
  def +(x); x; end
end

Adding that method will make both of these work:

# Numbers:
a = AutoHash.new
5.times { a[:sum] += 10 }
a[:sum] #=> 50

# Strings:
a = AutoHash.new
5.times { a[:sum] += 'a string ' }
a[:sum] #=> "a string a string a string a string a string "

And by the way, here is a cleaner version of your code:

class AutoHash < Hash
  def initialize(args={})
    super
    @update, @update_index = args[:update], args[:update_key]
  end

  def [](k)
    if has_key? k
      super(k)
    else
      AutoHash.new :update => self, :update_key => k
    end
  end

  def []=(k, v)
    @update[@update_index] = self if @update and @update_index
    super
  end

  def +(x); x; end

  def self.few(n)
    Array.new(n) { AutoHash.new }
  end
end

:)

How to assign hash['a']['b']= 'c' if hash['a'] doesn't exist?

The easiest way is to construct your Hash with a block argument:

hash = Hash.new { |h, k| h[k] = { } }
hash['a']['b'] = 1
hash['a']['c'] = 1
hash['b']['c'] = 1
puts hash.inspect
# "{"a"=>{"b"=>1, "c"=>1}, "b"=>{"c"=>1}}"

This form for new creates a new empty Hash as the default value. You don't want this:

hash = Hash.new({ })

as that will use the exact same hash for all default entries.

Also, as Phrogz notes, you can make the auto-vivified hashes auto-vivify using default_proc:

hash = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }

UPDATE: I think I should clarify my warning against Hash.new({ }). When you say this:

h = Hash.new({ })

That's pretty much like saying this:

h = Hash.new
h.default = { }

And then, when you access h to assign something as h[:k][:m] = y, it behaves as though you did this:

if(h.has_key?(:k))
    h[:k][:m] = y
else
    h.default[:m] = y
end

And then, if you h[:k2][:n] = z, you'll end up assigning h.default[:n] = z. Note that h still says that h.has_key?(:k) is false.

However, when you say this:

h = Hash.new(0)

Everything will work out okay because you will never modified h[k] in place here, you'll only read a value from h (which will use the default if necessary) or assign a new value to h.

ruby hash autovivification (facets)

The standard new method for Hash accepts a block. This block is called in the event of trying to access a key in the Hash which does not exist. The block is passed the Hash itself and the key that was requested (the two parameters) and should return the value that should be returned for the requested key.

You will notice that the leet lambda does 2 things. It returns a new Hash with leet itself as the block for handling defaults. This is the behaviour which allows autonew to work for Hashes of arbitrary depth. It also assigns this new Hash to hsh[key] so that next time you request the same key you will get the existing Hash rather than a new one being created.

Hashes of Hashes Idiom in Ruby?

You can pass the Hash.new function a block that is executed to yield a default value in case the queried value doesn't exist yet:

h = Hash.new { |h, k| h[k] = Hash.new }

Of course, this can be done recursively. There's an article explaining the details.

For the sake of completeness, here's the solution from the article for arbitrary depth hashes:

hash = Hash.new(&(p = lambda{|h, k| h[k] = Hash.new(&p)}))

The person to originally come up with this solution is Kent Sibilev.

Ruby multidimensional array

Strictly speaking it is not possible to create multi dimensional arrays in Ruby. But it is possible to put an array in another array, which is almost the same as a multi dimensional array.

This is how you could create a 2D array in Ruby:

a = [[1,2,3], [4,5,6], [7,8,9]]

---

As stated in the comments, you could also use NArray which is a Ruby numerical array library:

require 'narray'
b = NArray[ [1,2,3], [4,5,6], [7,8,9] ]

---

Use a[i][j] to access the elements of the array. Basically a[i] returns the 'sub array' stored on position i of a and thus a[i][j] returns element number j from the array that is stored on position i.

Merge multidimensional array of hash based on hash key and value in ruby

maybe this can help you.

input = [
  [
  {"id"=>"1","name"=>"a"},
  {"id"=>"2","name"=>"b"},
  {"id"=>"3","name"=>"c"},
  {"id"=>"4","name"=>"d"},
  {"id"=>"5","name"=>"e"},
  {"id"=>"6","name"=>"f"}
  ],
  [
  {"id"=>"3","hoby"=>"AA"},
  {"id"=>"3","hoby"=>"BB"},
  {"id"=>"1","hoby"=>"CC"},
  {"id"=>"1","hoby"=>"DD"},
  {"id"=>"4","hoby"=>"EE"}
  ],
  [
  {"id"=>"1","language"=>"A"},
  {"id"=>"1","language"=>"B"},
  {"id"=>"2","language"=>"B"},
  {"id"=>"2","language"=>"C"},
  {"id"=>"6","language"=>"D"}
  ]
]

This way you can make your "sort" results.

output = {}
input.flatten.each do |h|
  output[h["id"]] = {} unless output[h["id"]]
  output[h["id"]].merge!(h)
end

output.values
# => [
# =>   {"id"=>"1", "name"=>"a", "hoby"=>"DD", "language"=>"B"},
# =>   {"id"=>"2", "name"=>"b", "language"=>"C"},
# =>   {"id"=>"3", "name"=>"c", "hoby"=>"BB"},
# =>   {"id"=>"4", "name"=>"d", "hoby"=>"EE"},
# =>   {"id"=>"5", "name"=>"e"},
# =>   {"id"=>"6", "name"=>"f", "language"=>"D"}
# => ]

But the better way is use Hash in input. You can define input like hash and "id" like key so if you generate the data, you dont have problem to sort it.

Someting like this

{
  "1" => {"name" => "a", "hoby" => "DD", "language" => "B"}
}

One liner nested hash creation in Ruby? (I come from Perl)

Unfortunately, there is no simple, practical way. A Ruby equivalent would be an ugly, ugly beast like:

((((@date[month] ||= {})[day] ||= {})[hours] ||= {})[min] ||= {})[sec] = 1

There is a way to assign default values for missing keys in hashes, though:

@date = Hash.new { |hash, key| hash[key] = {} }

# @date[:month] is set to a new, empty hash because the key is missing.
@date[:month][:day] = 1

Unfortunately this does not work recursively.

...unless you create it yourself; hooray for Ruby!

class Hash
  def self.recursive
    new { |hash, key| hash[key] = recursive }
  end
end

@date = Hash.recursive
@date[month][day][hours][min][sec] = 1
# @date now equals {month=>{day=>{hours=>{min=>{sec=>1}}}}}

Keep in mind, though, that all unset values are now {} rather than nil.

Multidimensional arrays in Ruby like PHP

More than a multidimensional array, hash of arrays would fit better.

In php you only have the type array, but in ruby the class Hash is very useful

objs_hash = {}
objs.each do |obj|
    objs_hash[obj.id] = obj
end

---

Related Topics