Ruby 如何做散列算法_Ruby_Hash

Ruby 如何做散列算法

ruby hash

Ruby 如何做散列算法,ruby,hash,Ruby,Hash,我想从散列中的startOn时间中减去ackedOns时间，得到确认警报所需的历元秒数代码如下： url = "https://xyz" uri = URI(url) http = Net::HTTP.new(uri.host, 443) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE req = Net::HTTP::Get.new(uri.request_uri) response = http.reques

我想从散列中的startOn时间中减去ackedOns时间，得到确认警报所需的历元秒数

代码如下：

url = "https://xyz"
uri = URI(url)
http = Net::HTTP.new(uri.host, 443)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
req = Net::HTTP::Get.new(uri.request_uri)
response = http.request(req)
jsonResponse = JSON.parse(response.body)
#troubelshooting step to see how many total alerts there are
total = jsonResponse['data']['total']
pp total

# create the collected_alerts hash
collected_alerts = { 'hosts'=> [],'dataPoints' => [], 'startOns' => [], 'ackedOns' => [], 'timeToAcks' => []  }

# iterate through the json
jsonResponse['data']['alerts'].each do |alerts|
   # store the interested json values into the appropriate hash
   collected_alerts['hosts'] << alerts['host']
   collected_alerts['dataPoints'] << alerts['dataPoint']
   collected_alerts['startOns'] << alerts['startOn']
   collected_alerts['ackedOns'] << alerts['ackedOn']

   # Calculate mins it took to acknowledge alert and store it in timeToAcks
   # Formula is Ack time - Start time which would give us seconds / 60 to give mins.             
   alerts['timeToAcks'] = alerts['ackedOn'].zip(alerts['startOn']).map{|a,s| a-s/60}    
end
pp collected_alerts

CSV.open("data.csv", "wb") {|csv| collected_alerts.to_a.each {|elem| csv << elem} }

有点像

 alerts['tta'] = alerts['ackedOns'].zip(alerts['startOns']).map{|a,s| a-s/60}

根据您的数据，您只需执行以下操作：

collected_alerts['timeToAcks'] << (alerts['ackedOn'] - alerts['startOn'])/60

此外，我会这样做，而不是一次循环一个警报并取出碎片：

alerts = jsonResponse['data']['alerts']
collected_alerts = {}
%w[host dataPoint startOn ackedOn].each do |field|
  collected_alerts[field] = alerts.map{ |alert| alert[field] }
end

或者更好：

alert_fields = %w[host dataPoint startOn ackedOn]
collected_alerts = Hash[ alert_fields.map{ |f| [f,alerts.map{|a| a[f] }] } ]

解释，大致按照执行顺序

```
alert\u fields=%w[…]
```
-创建一个引用字符串值数组（在源代码中用空格分隔）的变量，即
```
[“ackedOn”、“host”、…]
```
```
alerts.map{a |…}
```
-通过获取
```
alerts
```
数组中的每个值创建一个新数组，创建一个名为
```
a
```
的变量引用该值，并将块的结果用作新数组中的值。
- ```
a[f]
```
  对于
```
警报
```
  数组中的每个警报，请查找值为
```
f
```
  的键。例如，当
```
f
```
  是
```
“ackedOn”
```
  时，它会查找
```
a[“ackedOn”]
```
  的值
```
alert_fields.map{| f |…}
```
-为数组中的每个元素创建一个名为
```
f
```
（用于“field”）的变量，并运行此块的内容。创建一个新数组，其中每个条目的内容都是块的最终值。
- ```
[f，…]
```
  -为所有警报中的特定字段创建一个包含所有值的数组后，此块的结果是一个两元素数组，即字段名称后跟这些值。例如，
```
[“ackedOn”，[1,3,16,4,44,7]
```
```
Hash[…]
```
-给定一个由两个值数组组成的数组，创建一个哈希，将每对数组中的第一个值映射到第二个值，即
```
{“ackedOn”=>[1,3,16,4,44,7]}
```
- 同样的
```
Hash[…]
```
  方法也可以接受偶数个参数，将每个偶数个参数与下面的参数配对

举例来说：

alert_fields = %w[ackedOn host dataPoint startOn]
#=> ["ackedOn", "host", "dataPoint", "startOn" ]

alerts.map{|a| a[f] }
#=> [5,3,4,5,1,6,8,2,…]

[f,alerts.map{|a| a[f] }]
#=> ["ackedOn",[5,3,4,5,1,6,8,2,…]]

alert_fields.map{ |f| [f,alerts.map{|a| a[f] }] }
#=> [
#=>   ["host",['foo','bar',…]], 
#=>   …
#=>   ["ackedOn",[5,3,4,5,1,6,8,2,…]]
#=> ]

Hash[ alert_fields.map{ |f| [f,alerts.map{|a| a[f] }] } ]
#=> {
#=>   "host" => ['foo','bar',…], 
#=>   …
#=>   "ackedOn" => [5,3,4,5,1,6,8,2,…]
#=> }

我尝试了该语法并得到了以下错误：alerts.rb:61:in

block in:：undefined method

zip'for 1392240941:Fixnum（NoMethodError）您的第一行指示alerts['ackedOns']是一个数组，但您的错误显示它是一个数字。您需要发布更多的代码。由于您没有向我们展示

警报

对象的数据结构，因此您得到的具体错误很难确定。我猜这是一个单值条目的散列，您编写了

警报['startOn']

（复数），而您的意思是

警报['startOn']

（单数）。或者你写了

警报['ackedOn']

（单数），意思是

警报['ackedOns']

（复数）。你还没有向我们显示

警报中的数据。请尝试pp-alerts，然后编辑您的帖子，将输出放在您的代码下面。请参阅我的编辑，以了解用较少的键入来实现相同目标的方法。谢谢您的评论的第一部分修复了我的问题。至于评论的第二部分，我理解第一部分。我试图理解：alert|fields=%w[ackedOn host dataPoint startOn ackedOn]collected|alerts=Hash[alert|fields.map{f |[f，alerts.map{a | a[f]}]第一行是创建一个名为alert|fields的数组，我不明白的是第二行中的a和f来自哪里。@achan请参阅我的编辑以获得解释。去读一读关于和。
alert_fields = %w[ackedOn host dataPoint startOn]
#=> ["ackedOn", "host", "dataPoint", "startOn" ]

alerts.map{|a| a[f] }
#=> [5,3,4,5,1,6,8,2,…]

[f,alerts.map{|a| a[f] }]
#=> ["ackedOn",[5,3,4,5,1,6,8,2,…]]

alert_fields.map{ |f| [f,alerts.map{|a| a[f] }] }
#=> [
#=>   ["host",['foo','bar',…]], 
#=>   …
#=>   ["ackedOn",[5,3,4,5,1,6,8,2,…]]
#=> ]

Hash[ alert_fields.map{ |f| [f,alerts.map{|a| a[f] }] } ]
#=> {
#=>   "host" => ['foo','bar',…], 
#=>   …
#=>   "ackedOn" => [5,3,4,5,1,6,8,2,…]
#=> }