blocks|key|4881230|text|首先，您需要在一个常量中定义键首选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4881231|PECKING_ORDER+=+%25w[+person+dog+fruit+]|code-block|syntax|javascript|4881232|然后你可以用它来找到它：|4881233|def+detect(item)
++PECKING_ORDER.lazy.map+do+%7Ckey%7C
++++[+key,+item.dig(key)+]
++end.find+do+%7Ckey,+v%7C
++++v
++end
end|4881234|在那里它可以挖掘出第一件被发现的物品。这里使用了lazy，所以它不会不必要地把它们都挖掘出来，只需要一次做一个，直到有一个命中。|offset|length|style|CODE|4881235|这为您提供了一个键/值对，您可以将其用于动态分派：|4881236|items.each+do+%7Citem%7C
++key,+value+=+detect(item)

++if+(key)
++++send(:"transform_#{key}",+value)
++end
end|4881237|entityMap^0|0|0|0|0|O|4|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

First you'll want to define the key preference in a constant:

<pre><code>PECKING_ORDER = %w[ person dog fruit ]
</code></pre>

Then you can use that to find it:

<pre><code>def detect(item)
 PECKING_ORDER.lazy.map do |key|
 [ key, item.dig(key) ]
 end.find do |key, v|
 v
 end
end
</code></pre>

Where that can dig up the first item that's found. <code>lazy</code> is used here so it doesn't dig them all up needlessly, just does them one at a time until there's a hit.

This gives you a key/value pair which you can use with dynamic dispatch:

<pre><code>items.each do |item|
 key, value = detect(item)

 if (key)
 send(:"transform_#{key}", value)
 end
end
</code></pre>

blocks|key|3412279|text|如果您知道映射，您可以创建一个伪工厂散列：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3412280|methods_mapped+=+{
++"person"+=>+->(person)+{+do_something_with_person(person)+},
++"dog"+=>+->(dog)+{+do_something_with_dog(dog)+},
++"fruit"+=>+->(fruit)+{+do_something_with_fruit(fruit)+}
}

items.map+do+%7Citem%7C
++key+=+item.keys.first+#+what+if+keys.size+>+1+?
++method+=+methods_mapped.fetch(key)
++method.call(item[key])
end|code-block|syntax|javascript|3412281|或者你可以从相反的方向：|3412282|methods_mapped.each+do+%7Ckey,+method%7C
++method.call(items.dig(key))
end|3412283|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|$]]

if you know the mapping, you could make a pseudo factory hash:

<pre><code>methods_mapped = {
 "person" =&gt; -&gt;(person) { do_something_with_person(person) },
 "dog" =&gt; -&gt;(dog) { do_something_with_dog(dog) },
 "fruit" =&gt; -&gt;(fruit) { do_something_with_fruit(fruit) }
}

items.map do |item|
 key = item.keys.first # what if keys.size &gt; 1 ?
 method = methods_mapped.fetch(key)
 method.call(item[key])
end
</code></pre>

or you could it from the opposite direction:

<pre><code>methods_mapped.each do |key, method|
 method.call(items.dig(key))
end
</code></pre>

blocks|key|1096407|text|我会让它保持简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1096408|items.map+do+%7Citem%7C
++do_something_with_person(item)+if+item.dig('person')
++do_something_with_dog(item)+if+item.dig('dog')
++do_something_with_fruit(item)+if+item.dig('fruit')
end|code-block|syntax|javascript|1096409|或|1096410|items.each+do+%7Citem%7C
++case+item
++++when+item.dig('person')+then+do_something_with_person(item)
++++when+item.dig('dog')+then+do_something_with_dog(item)
++++when+item.dig('fruit')+then+do_something_with_fruit(item)
++end
end|1096411|1096412|def+do_something(item)
++case
++++when+item.dig('person')+then+do_something_with_person(item)
++++when+item.dig('dog')+then+do_something_with_dog(item)
++++when+item.dig('fruit')+then+do_something_with_fruit(item)
++end
end
items.map+{+%7Citem%7C+do_something(item)+}|1096413|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|K|3|H|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|M|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

I would kept it simple:

<pre><code>items.map do |item|
 do_something_with_person(item) if item.dig('person')
 do_something_with_dog(item) if item.dig('dog')
 do_something_with_fruit(item) if item.dig('fruit')
end
</code></pre>

or

<pre><code>items.each do |item|
 case item
 when item.dig('person') then do_something_with_person(item)
 when item.dig('dog') then do_something_with_dog(item)
 when item.dig('fruit') then do_something_with_fruit(item)
 end
end
</code></pre>

or

<pre><code>def do_something(item)
 case
 when item.dig('person') then do_something_with_person(item)
 when item.dig('dog') then do_something_with_dog(item)
 when item.dig('fruit') then do_something_with_fruit(item)
 end
end
items.map { |item| do_something(item) }
</code></pre>

blocks|key|4881288|text|假设f是一个给定的方法，它以散列作为参数。在不失一般性的前提下，假设如下。这对应于OP的transform_person、transform_dog和transform_fruit方法的组合。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4881289|def+f(h)
++case+h.keys.first
++when+:person+then+"somebody"
++when+:dog++++then+"doggie"+
++when+:fruit++then+"juicy"
++end
end|code-block|syntax|javascript|4881290|假设我们也被给定了(这里不需要dig+)|4881291|items+=+data[:items]
++#=>+[{:person=>{:name=>"Melba"}},
++#++++{:dog=>{:tricks=>[:roll_over,+:shake_a_paw]}},
++#++++{:fruit=>{:good=>"raspberries"}}]|4881292|和|4881293|key_order+=+[:bird,+:marsupial,+:dog,+:person]|4881294|我们希望找到key_order的第一个元素k，它的items包含一个散列h，它的h.key?(k)+#=>+true。如果找到这样的散列h，我们就执行f(h)。|4881295|首先计算一个散列key_map。|4881296|key_map+=+items.each_with_object({})+{+%7Cg,h%7C+h[g.keys.first]+=+g+}
++#=>+{:person=>{:person=>{:name=>"Melba"}},
++#++++:dog=>{:dog=>{:tricks=>[:roll_over,+:shake_a_paw]}},
++#++++:fruit=>{:fruit=>{:good=>"raspberries"}}}|4881297|然后我们简单地执行|4881298|k+=+key_order.find+{+%7Ck%7C+key_map[k]+}
++#=>+:dog
k+?+f(key_map[k])+:+nil
++#=>+"doggie"|4881299|entityMap^0|2|1|18|G|1P|D|23|F|0|0|F|3|0|0|0|0|6|9|L|1|P|5|10|1|14|I|1W|1|23|4|0|8|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1H|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|W|3|X|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|23|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|24|8|@]|D|@]|E|$I|J]]|$1|12|3|-4|5|6|7|25|8|@]|D|@]|E|$]]]|13|$]]

Let <code>f</code> be a given method that takes as an argument a hash. Without loss of generality, suppose it is as follows. This corresponds to the OP's <code>transform_person</code>, <code>transform_dog</code> and <code>transform_fruit</code> methods combined.

<pre><code>def f(h)
 case h.keys.first
 when :person then "somebody"
 when :dog then "doggie" 
 when :fruit then "juicy"
 end
end
</code></pre>

Suppose we are also given (no need for <code>dig</code> here)

<pre><code>items = data[:items]
 #=&gt; [{:person=&gt;{:name=&gt;"Melba"}},
 # {:dog=&gt;{:tricks=&gt;[:roll_over, :shake_a_paw]}},
 # {:fruit=&gt;{:good=&gt;"raspberries"}}]
</code></pre>

and

<pre><code>key_order = [:bird, :marsupial, :dog, :person]
</code></pre>

We wish to find the first element <code>k</code> of <code>key_order</code> for which <code>items</code> contains a hash <code>h</code> for which <code>h.key?(k) #=&gt; true</code>. If such a hash <code>h</code> is found we are to then execute <code>f(h)</code>.

First compute a hash <code>key_map</code>.

<pre><code>key_map = items.each_with_object({}) { |g,h| h[g.keys.first] = g }
 #=&gt; {:person=&gt;{:person=&gt;{:name=&gt;"Melba"}},
 # :dog=&gt;{:dog=&gt;{:tricks=&gt;[:roll_over, :shake_a_paw]}},
 # :fruit=&gt;{:fruit=&gt;{:good=&gt;"raspberries"}}}
</code></pre>

Then we simply execute

<pre><code>k = key_order.find { |k| key_map[k] }
 #=&gt; :dog
k ? f(key_map[k]) : nil
 #=&gt; "doggie"
</code></pre>

I have a JSON data structure like this...

<pre><code>{
 "items": [
 {
 "person": { // person hash }
 },
 {
 "dog": { // dog hash }
 },
 {
 "fruit": { // fruit hash }
 },
 {
 “person”: { // person hash }
 }
 ]
 }
}
</code></pre>

Each item in the array contains only one key:value pair. The key is the bot that tells me what type of item the value is.

What I'd like to do is iterate the array and run a different function for each type of item.

So I have something like this...

<pre><code>items = data.dig('items')

items.map do |item|
 if person = item.dig('person')
 transform_person(person)
 elsif dog = item.dig('dog')
 transform_dog(dog)
 elsif fruit = item.dig('fruit')
 transform_fruit(fruit)
 end
end
</code></pre>

But I feel like there should be a more elegant way to do this?

Apologies. I appear to have left some ambiguity in my question.

The initial array may contain multiple items with the same key. What I am trying to do is map to an array of items that are transformed into what is required by the front end. The input contains a strange structure and info that is not needed by the front end.

So the output array order must match the input array order.

Sorry for the confusion.

Ruby iterating array of dictionaries

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一个像这样的JSON数据结构...{  "items": [      {        "person": { // person hash }      },      {        "dog": { // dog hash }      },      {        "fruit": { // fru...

问Ruby迭代字典数组
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby迭代字典数组EN