标签: hash-of-hashes

在Ruby中创建哈希哈希允许方便的两个(或更多)维度查找.但是,插入时必须始终检查散列中是否已存在第一个索引.例如:

h = Hash.new
h['x'] = Hash.new if not h.key?('x')
h['x']['y'] = value_to_insert

最好在自动创建新哈希的情况下执行以下操作:

h = Hash.new
h['x']['y'] = value_to_insert

类似地,当查找第一个索引尚不存在的值时,如果返回nil而不是接收"[]"错误的未定义方法,则更为可取.

looked_up_value = h['w']['z']

可以创建一个具有此行为的Hash包装类,但是是否存在用于完成此任务的Ruby习惯用法？

我正在使用ruby编写的一个小实用程序,它广泛使用嵌套哈希.目前,我正在检查对嵌套哈希元素的访问,如下所示:

structure = { :a => { :b => 'foo' }}

# I want structure[:a][:b]

value = nil

if structure.has_key?(:a) && structure[:a].has_key?(:b) then
  value = structure[:a][:b]
end

有一个更好的方法吗？我想能够说:

value = structure[:a][:b]

而得到nil,如果:一个是不是一个关键structure,等等.

我正在尝试构建一个API包装器gem,并且在将API返回的JSON转换为更多Rubyish格式时遇到问题.

JSON包含多层嵌套,包括哈希和数组.我想要做的是递归地将所有键转换为snake_case以便于使用.

这是我到目前为止所得到的:

def convert_hash_keys(value)
  return value if (not value.is_a?(Array) and not value.is_a?(Hash))
  result = value.inject({}) do |new, (key, value)|
    new[to_snake_case(key.to_s).to_sym] = convert_hash_keys(value)
    new
  end
  result
end

上面调用此方法将字符串转换为snake_case:

def to_snake_case(string)
  string.gsub(/::/, '/').
  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
  gsub(/([a-z\d])([A-Z])/,'\1_\2').
  tr("-", "_").
  downcase
end

理想情况下,结果类似于以下内容:

hash = {:HashKey => {:NestedHashKey => [{:Key => "value"}]}}

convert_hash_keys(hash)
# => {:hash_key => {:nested_hash_key => [{:key => "value"}]}}

我得到的递归是错误的,我试过的这种解决方案的每个版本都不会将符号转换为超出第一级别,或者过度使用并尝试转换整个哈希值,包括值.

尝试在辅助类中解决所有这些问题,而不是修改实际的Hash和String函数(如果可能).

先感谢您.

我正在寻找一种避免nil在深层嵌套哈希中检查每个级别的好方法.例如:

name = params[:company][:owner][:name] if params[:company] && params[:company][:owner] && params[:company][:owner][:name]

这需要三次检查,并且会产生非常难看的代码.有办法解决这个问题吗？

我有一个哈希:

h = {'name' => 'sayuj', 
     'age' => 22, 
     'project' => {'project_name' => 'abc', 
                   'duration' => 'prq'}}

我需要一个这个哈希的副本,更改不应该影响原始哈希.

当我尝试时,

d = h.dup # or d = h.clone
d['name'] = 'sayuj1'
d['project']['duration'] = 'xyz'

p d #=> {"name"=>"sayuj1", "project"=>{"duration"=>"xyz", "project_name"=>"abc"}, "age"=>22}
p h #=> {"name"=>"sayuj", "project"=>{"duration"=>"xyz", "project_name"=>"abc"}, "age"=>22}

在这里,您可以看到project['duration']原始哈希中的更改是因为project是另一个哈希对象.

我想要散列duped或cloned递归.我怎样才能做到这一点？

有什么比这简单的方法

if hash.key?('a')
  hash['a']['b'] = 'c' 
else  
  hash['a'] = {}
  hash['a']['b'] = 'c' 
end

我正在尝试使用嵌套哈希.我有一副牌代表如下:

deck_of_cards = {
:hearts => {:two => 2, :three => 3, :four => 4, :five => 5, :six => 6, :seven => 7, :eight => 8, :nine => 9, :ten => 10, :jack => 10, 
            :queen => 10, :king => 10, :ace => 11},
:spades => {:two => 2, :three => 3, :four => 4, :five => 5, :six => 6, :seven => 7, :eight => 8, :nine => 9, :ten => 10, :jack => 10, 
            :queen => 10, …

我如何在哈希中创建哈希,嵌套哈希有一个键来识别它.我在嵌套哈希中创建的元素也是如何为它们设置密钥的

例如

test = Hash.new()

#create second hash with a name?? test = Hash.new("test1")??
test("test1")[1] = 1???
test("test1")[2] = 2???

#create second hash with a name/key test = Hash.new("test2")???
test("test2")[1] = 1??
test("test2")[2] = 2??

谢谢

给出如下的哈希:

AppConfig = {
  'service' => {
    'key' => 'abcdefg',
    'secret' => 'secret_abcdefg'
  },
  'other' => {
    'service' => {
      'key' => 'cred_abcdefg',
      'secret' => 'cred_secret_abcdefg'
    }
  }
}

在某些情况下我需要一个函数来返回服务/密钥,在其他情况下我需要其他/ service/key.一种简单的方法是传入散列和一组键,如下所示:

def val_for(hash, array_of_key_names)
  h = hash
  array_of_key_names.each { |k| h = h[k] }
  h
end

这样调用会产生'cred_secret_abcdefg':

val_for(AppConfig, %w[other service secret])

看起来应该有比我在val_for()中编写的更好的方法.

我有哈希哈希,如下:

%hash = ( a  => { b => 1, c =>2, d => 3},
          a1 => { b => 11, c =>12, d => 13},
          a2 => { b => 21, c =>22, d => 23} )

我想提取"b"元素并将其放入数组中.现在,我正在遍历哈希来执行此操作,但我认为我可以通过使用map来略微提高效率.我很确定如果这是一个哈希数组,我会使用这样的东西:

@hasharray = ( { b => 1, c =>2, d => 3},
               { b => 11, c =>12, d => 13},
               { b => 21, c =>22, d => 23} )
@array = map { …