blocks|key|1761823|text|keys.inject(hash)+{%7Cacc,+value%7C+acc[value]}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1761824|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>keys.inject(hash) {|acc, value| acc[value]}
</code></pre>

blocks|key|1030083|text|不执行任何错误检查，但是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1030084|h+=+{'k1'+=>+{'s1'+=>+1,+'s2'+=>+2},+'k2'+=>+3}
ks+=+['k1',+'s1']
ks.inject(h){%7Chh,+k%7C+hh[k]}++#+=>+1
['k1',+'s2'].inject(h){%7Chh,+k%7C+hh[k]}+#+=>+2
['k2'].inject(h){%7Chh,+k%7C+hh[k]}+#+=>+3|code-block|syntax|javascript|1030085|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Doesn't do any error checking, but

<pre><code>h = {'k1' =&gt; {'s1' =&gt; 1, 's2' =&gt; 2}, 'k2' =&gt; 3}
ks = ['k1', 's1']
ks.inject(h){|hh, k| hh[k]} # =&gt; 1
['k1', 's2'].inject(h){|hh, k| hh[k]} # =&gt; 2
['k2'].inject(h){|hh, k| hh[k]} # =&gt; 3
</code></pre>

blocks|key|746890|text|最好将对象放在心上，让我们向Hash类添加一个功能|type|unstyled|depth|inlineStyleRanges|entityRanges|data|746891|#+in+intialize+or+whatever
class+Hash
++def+find_path+path+#recursive
++++key+=+path.first
++++if+_path.size+==+1+#+end+of+path+=>+return+value
++++++[key]
++++elsif+[key].kind_of?(Hash)+#+continue
++++++[key].find_path+path[1..-1]
++++else+#+have+to+continue+but+not+a+has+=>+out
++++++nil
++++end
++end

++def+find_path+path+#+not+recursive
++++_path+=+path.clone+#copy+to+shift
++++_tree+=+self+#start+with+self
++++while(_path.size+>+1+&&+_tree)+do+#while+not+the+end+and+_tree+
++++++_v+=+_tree[_path.shift]
++++++_tree+=+_v.kind_of?(Hash)+?+_v+:+nil
++++end
++++_tree+?+_tree[_path.first]+:+nil
++end
end|code-block|syntax|javascript|746892|这样：|746893|hash+=+{:v1+=>+{:v1.1+=>+"yes",+:v1.2+=>+"false"}}
hash.find_path+[:v1,+:v1.1]
#+=>+"yes"
hash.find_path+[:v1]
#+=>+{:v1.1+=>+"yes",+:v1.2+=>+"false"}
hash.find_path+[:v2]
#+=>+nil
hash.find_path+[:v1,+:v1.3]
#+=>+nil|746894|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Better keep object in mind so let's add a feature to Hash class

<pre><code># in intialize or whatever
class Hash
 def find_path path #recursive
 key = path.first
 if _path.size == 1 # end of path =&gt; return value
 [key]
 elsif [key].kind_of?(Hash) # continue
 [key].find_path path[1..-1]
 else # have to continue but not a has =&gt; out
 nil
 end
 end

 def find_path path # not recursive
 _path = path.clone #copy to shift
 _tree = self #start with self
 while(_path.size &gt; 1 &amp;&amp; _tree) do #while not the end and _tree 
 _v = _tree[_path.shift]
 _tree = _v.kind_of?(Hash) ? _v : nil
 end
 _tree ? _tree[_path.first] : nil
 end
end
</code></pre>

This way :

<pre><code>hash = {:v1 =&gt; {:v1.1 =&gt; "yes", :v1.2 =&gt; "false"}}
hash.find_path [:v1, :v1.1]
# =&gt; "yes"
hash.find_path [:v1]
# =&gt; {:v1.1 =&gt; "yes", :v1.2 =&gt; "false"}
hash.find_path [:v2]
# =&gt; nil
hash.find_path [:v1, :v1.3]
# =&gt; nil
</code></pre>

blocks|key|5068318|text|这是我的解决方案(它类似于proxygear的，但它不会对Hash进行猴子补丁，并且在没有参数的情况下调用时它的行为是正确的)。我认为这比两个基于注入的解决方案更好，因为如果你试图访问DNE的路径，它们将会爆炸。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5068319|class+TraversibleHash
++attr_accessor+:hash

++def+initialize(hash)
++++self.hash+=+hash
++end

++def+access(*keys)
++++recursive_access+keys,+hash
++end

private

++def+recursive_access(keys,+hash)
++++return+nil+if+keys.empty?
++++element+=+hash.fetch(keys.shift)+{+return+nil+}
++++return+element+if+keys.empty?
++++return+nil+unless+element.kind_of?+Hash+#+<--+should+maybe+raise+an+error?
++++recursive_access+keys,+element
++end
end|code-block|syntax|javascript|5068320|下面是测试套件：|5068321|describe+TraversibleHash+do
++let(:traversible)+{+TraversibleHash.new+'key1'+=>+{+'sub1'+=>+1,+'sub2'+=>+2+},+'key2'+=>+3,+nil+=>+1+}

++it+'returns+nil+when+invoked+without+args'+do
++++traversible.access.should+be_nil
++end

++it+'returns+nil+when+accessing+nonexistent+keys'+do
++++traversible.access('key3').should+be_nil
++++traversible.access('key2',+'key3').should+be_nil
++++traversible.access('key1',+'sub3').should+be_nil
++++traversible.access('key1',+'sub2',+'subsub1').should+be_nil
++++traversible.access('abc',+'def',+'ghi').should+be_nil
++end

++it+'finds+toplevel+keys'+do
++++traversible.access('key2').should+==+3
++++traversible.access('key1').should+==+{'sub1'+=>+1,+'sub2'+=>+2}
++end

++it+'traverses+nested+hashes+to+find+nested+keys'+do
++++traversible.access('key1',+'sub1').should+==+1
++++traversible.access('key1',+'sub2').should+==+2
++++TraversibleHash.new(1=>{2=>{3=>4}}).access(1,+2,+3).should+==+4
++end
end|5068322|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is my solution (it is similar to proxygear's, but it does not monkey patch Hash, and it behaves correctly when invoked with no args). I think it is better than the two inject based solutions because they will blow up if you try to access paths that DNE. 

<pre><code>class TraversibleHash
 attr_accessor :hash

 def initialize(hash)
 self.hash = hash
 end

 def access(*keys)
 recursive_access keys, hash
 end

private

 def recursive_access(keys, hash)
 return nil if keys.empty?
 element = hash.fetch(keys.shift) { return nil }
 return element if keys.empty?
 return nil unless element.kind_of? Hash # &lt;-- should maybe raise an error?
 recursive_access keys, element
 end
end
</code></pre>

Here is the test suite:

<pre><code>describe TraversibleHash do
 let(:traversible) { TraversibleHash.new 'key1' =&gt; { 'sub1' =&gt; 1, 'sub2' =&gt; 2 }, 'key2' =&gt; 3, nil =&gt; 1 }

 it 'returns nil when invoked without args' do
 traversible.access.should be_nil
 end

 it 'returns nil when accessing nonexistent keys' do
 traversible.access('key3').should be_nil
 traversible.access('key2', 'key3').should be_nil
 traversible.access('key1', 'sub3').should be_nil
 traversible.access('key1', 'sub2', 'subsub1').should be_nil
 traversible.access('abc', 'def', 'ghi').should be_nil
 end

 it 'finds toplevel keys' do
 traversible.access('key2').should == 3
 traversible.access('key1').should == {'sub1' =&gt; 1, 'sub2' =&gt; 2}
 end

 it 'traverses nested hashes to find nested keys' do
 traversible.access('key1', 'sub1').should == 1
 traversible.access('key1', 'sub2').should == 2
 TraversibleHash.new(1=&gt;{2=&gt;{3=&gt;4}}).access(1, 2, 3).should == 4
 end
end
</code></pre>

blocks|key|1030147|text|从Ruby2.3.0开始，你可以使用Hash#dig，它可以做到这一点：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1030148|hash.dig(*keys)|code-block|syntax|javascript|1030149|在迁移之前，您可以使用+gem。|1030150|entityMap^0|I|8|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

From Ruby 2.3.0 onward, you can use <code>Hash#dig</code>, which does exactly that:

<pre><code>hash.dig(*keys)
</code></pre>

You can use the <a href="https://github.com/Invoca/ruby_dig" rel="nofollow">ruby_dig</a> gem until you migrate.

I have Hash like this, representing a data tree

<pre><code>hash = {
 'key1' =&gt; {
 'sub1' =&gt; 1,
 'sub2' =&gt; 2
 },
 'key2' =&gt; 3
}
</code></pre>

I want to explore the tree with an array of keys representing a path.
Some exemples :

with a simple path:

<pre><code>keys = ['key2']
</code></pre>

I want to get <code>3</code>

with this path:

<pre><code>keys = ['key1', 'sub1']
</code></pre>

I want to get <code>1</code>

with invalide path :

<pre><code>keys = ['key1', 'sub1', 'blabla']
keys = ['key1', 'blabla']
</code></pre>

get <code>nil</code>

etc ... etc ... you get the idea

get ruby hash value by keys

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有这样的Hash，表示一个数据树hash = {    'key1' => {         'sub1' => 1,         'sub2' => 2    },    'key2' => 3}我想用一个表示路径的键数组来探索树。下面是一些例子：使用一个简单的路径：keys = ['key2']我想让3使用以下路径：keys = ['key1', 'sub1']我想让1使用无效路径：k

问按键获取ruby散列值
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按键获取ruby散列值EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按键获取ruby散列值
EN