Ruby on rails 如果值为true，如何返回哈希键？

给出一个散列

  PLATFORMS = {
      :mac => /(mac)|(macintosh)/i,
      :win => /(win)|(windows)/i,
      :ipad => /(ipad)/i,
      :iphone => /(iphone)/i,
      :ipod => /(ipod)|(ipod touch)/i
  }

我对返回散列键感兴趣，这里的值是regex表达式，返回true

因此，如果给我一系列的窗口，我应该得到返回键：win

到目前为止，我的努力是：

current_platform = BrowserExperience::ExperienceKeeper::PLATFORMS.detect do |platform, regex|        
   regex.match(user_agent_obj.platform)
end[0]

它返回[：win，/win | windows/i]

但是，这只是返回一个数组，其中索引0返回我想要的键值。有更简单的方法吗？

您可以使用select和来检查使用match哪个或哪些键值与传递的字符串匹配：

PLATFORMS = {
  mac: /(mac)|(macintosh)/i,
  win: /(win)|(windows)/i,
  ipad: /(ipad)/i,
  iphone: /(iphone)/i,
  ipod: /(ipod)|(ipod touch)/i
}

def match_regex(string)
  PLATFORMS.select{|_,v| string.match(v)}.keys[0]
end

p match_regex('windows')
# => :win

您可以使用“选择”和“使用匹配”来检查哪些键值与传递的字符串匹配：

PLATFORMS = {
  mac: /(mac)|(macintosh)/i,
  win: /(win)|(windows)/i,
  ipad: /(ipad)/i,
  iphone: /(iphone)/i,
  ipod: /(ipod)|(ipod touch)/i
}

def match_regex(string)
  PLATFORMS.select{|_,v| string.match(v)}.keys[0]
end

p match_regex('windows')
# => :win

---

这不是一个很大的改进，但是您可以只检测键而不是键值对

platform_to_regex = BrowserExperience::ExperienceKeeper::PLATFORMS
current_platform = platform_to_regex.keys.detect do |platform|        
   platform_to_regex[platform].match(user_agent_obj.platform)
end

---

这不是一个很大的改进，但是您可以只检测键而不是键值对

platform_to_regex = BrowserExperience::ExperienceKeeper::PLATFORMS
current_platform = platform_to_regex.keys.detect do |platform|        
   platform_to_regex[platform].match(user_agent_obj.platform)
end

为什么不使用案例陈述？这是一种更常见的方法：

strings = [
  'this is a Windows box',
  'Welcome to Macintosh',
  'My music is on an iPod',
  'My photos are on an iPod Touch',
  'I read books on an iPad'
]

strings.each do |str|
  os = case str
       when /\b(?:mac|macintosh)\b/i
         :mac 
       when /\b(?:win|windows)\b/i
         :win 
       when /\b(?:ipad)\b/i
         :ipad 
       when /\b(?:iphone)\b/i
         :iphone 
       when /\b(?:ipod|ipod\ touch)\b/i
         :ipod 
       end

  os # => :win, :mac, :ipod, :ipod, :ipad

end

也可以这样做：

PLATFORMS = {
  mac:    /\b(?:mac|macintosh)\b/i,
  win:    /\b(?:win|windows)\b/i,
  ipad:   /\b(?:ipad)\b/i,
  iphone: /\b(?:iphone)\b/i,
  ipod:   /\b(?:ipod|ipod\ touch)\b/i
}

strings.each do |str|

  key = nil

  PLATFORMS.each_pair do |k, v|
    if str =~ v
      key = k
      break
    end
  end 

  key # => :win, :mac, :ipod, :ipod, :ipad

end

或最好：

strings.each do |str|

  PLATFORMS.find { |k, v| str =~ v }.first # => :win, :mac, :ipod, :ipod, :ipad

end

如果使用散列和正则表达式，则模式要更简洁\b是单词边界，这是我们告诉Regexp引擎是匹配子字符串还是匹配整单词的方式：

'machine'[/(?:mac|macintosh)/i]     # => "mac"

vs:

还有一点：

'mac'[/\b(?:mac|macintosh)\b/i]           # => "mac"
'macintosh'[/\b(?:mac|macintosh)\b/i]     # => "macintosh"
'win'[/\b(?:win|windows)\b/i]             # => "win"
'windows'[/\b(?:win|windows)\b/i]         # => "windows"
'ipad'[/\b(?:ipad)\b/i]                   # => "ipad"
'iphone'[/\b(?:iphone)\b/i]               # => "iphone"
'ipod touch'[/\b(?:ipod|ipod\ touch)\b/i] # => "ipod"

我可能会这样定义散列：

require 'regexp_trie'

PLATFORMS = {
  mac:    ['mac', 'macintosh'],
  win:    ['win', 'windows'],
  ipad:   ['ipad'],
  iphone: ['iphone'],
  ipod:   ['ipod', 'ipod touch']
}

然后，我会将模式转换为更有效的模式：

PLATFORMS_RE = {}
PLATFORMS.each_pair do |k, v|
  PLATFORMS_RE[k] = /\b(?:#{RegexpTrie.union(v).source})\b/i
end

其结果是：

PLATFORMS_RE
# => {:mac=>/\b(?:mac(?:intosh)?)\b/i,
#     :win=>/\b(?:win(?:dows)?)\b/i,
#     :ipad=>/\b(?:ipad)\b/i,
#     :iphone=>/\b(?:iphone)\b/i,
#     :ipod=>/\b(?:ipod(?:\ touch)?)\b/i}

其工作原理与之前相同：

strings.each do |str|

  PLATFORMS_RE.find { |k, v| str =~ v }.first # => :win, :mac, :ipod, :ipod, :ipad

end

为什么不使用案例陈述？这是一种更常见的方法：

strings = [
  'this is a Windows box',
  'Welcome to Macintosh',
  'My music is on an iPod',
  'My photos are on an iPod Touch',
  'I read books on an iPad'
]

strings.each do |str|
  os = case str
       when /\b(?:mac|macintosh)\b/i
         :mac 
       when /\b(?:win|windows)\b/i
         :win 
       when /\b(?:ipad)\b/i
         :ipad 
       when /\b(?:iphone)\b/i
         :iphone 
       when /\b(?:ipod|ipod\ touch)\b/i
         :ipod 
       end

  os # => :win, :mac, :ipod, :ipod, :ipad

end

也可以这样做：

PLATFORMS = {
  mac:    /\b(?:mac|macintosh)\b/i,
  win:    /\b(?:win|windows)\b/i,
  ipad:   /\b(?:ipad)\b/i,
  iphone: /\b(?:iphone)\b/i,
  ipod:   /\b(?:ipod|ipod\ touch)\b/i
}

strings.each do |str|

  key = nil

  PLATFORMS.each_pair do |k, v|
    if str =~ v
      key = k
      break
    end
  end 

  key # => :win, :mac, :ipod, :ipod, :ipad

end

或最好：

strings.each do |str|

  PLATFORMS.find { |k, v| str =~ v }.first # => :win, :mac, :ipod, :ipod, :ipad

end

如果使用散列和正则表达式，则模式要更简洁\b是单词边界，这是我们告诉Regexp引擎是匹配子字符串还是匹配整单词的方式：

'machine'[/(?:mac|macintosh)/i]     # => "mac"

vs:

还有一点：

'mac'[/\b(?:mac|macintosh)\b/i]           # => "mac"
'macintosh'[/\b(?:mac|macintosh)\b/i]     # => "macintosh"
'win'[/\b(?:win|windows)\b/i]             # => "win"
'windows'[/\b(?:win|windows)\b/i]         # => "windows"
'ipad'[/\b(?:ipad)\b/i]                   # => "ipad"
'iphone'[/\b(?:iphone)\b/i]               # => "iphone"
'ipod touch'[/\b(?:ipod|ipod\ touch)\b/i] # => "ipod"

我可能会这样定义散列：

require 'regexp_trie'

PLATFORMS = {
  mac:    ['mac', 'macintosh'],
  win:    ['win', 'windows'],
  ipad:   ['ipad'],
  iphone: ['iphone'],
  ipod:   ['ipod', 'ipod touch']
}

然后，我会将模式转换为更有效的模式：

PLATFORMS_RE = {}
PLATFORMS.each_pair do |k, v|
  PLATFORMS_RE[k] = /\b(?:#{RegexpTrie.union(v).source})\b/i
end

其结果是：

PLATFORMS_RE
# => {:mac=>/\b(?:mac(?:intosh)?)\b/i,
#     :win=>/\b(?:win(?:dows)?)\b/i,
#     :ipad=>/\b(?:ipad)\b/i,
#     :iphone=>/\b(?:iphone)\b/i,
#     :ipod=>/\b(?:ipod(?:\ touch)?)\b/i}

其工作原理与之前相同：

strings.each do |str|

  PLATFORMS_RE.find { |k, v| str =~ v }.first # => :win, :mac, :ipod, :ipod, :ipad

end

---

对于给定的散列，我将编写以下内容

def attempt_match(str)
  PLATFORMS.keys.find { |k| str.match? PLATFORMS[k] }
end

attempt_match 'windows' #=> :win
attempt_match 'DOS' #=> nil

一种更简单的方法是使用一个更简单的散列并构造动态上非常相似的正则表达式。这可以按如下方式实现1

&最后是Ruby，在v2.3中引入

例如，修改hash add linux=>：linux将是一件简单的事情，而不必担心正则表达式是否正确

---

1观察如果ipod touch匹配，ipod也会匹配。因此，前者是多余的。

对于给定的哈希，我将编写以下内容

def attempt_match(str)
  PLATFORMS.keys.find { |k| str.match? PLATFORMS[k] }
end

attempt_match 'windows' #=> :win
attempt_match 'DOS' #=> nil

一种更简单的方法是使用一个更简单的散列并构造动态上非常相似的正则表达式。这可以按如下方式实现1

&最后是Ruby，在v2.3中引入

例如，修改hash add linux=>：linux将是一件简单的事情，而不必担心正则表达式是否正确

---

---

1观察如果ipod touch匹配，ipod也会匹配。因此，前者是多余的。

我对这个字符串的假设是它只能匹配1个正则表达式。所以我的问题是多余的。我对这个字符串的假设是它只能匹配1个正则表达式。所以我的问题是多余的。作为旁注，您可以简化您的正则表达式。不匹配“mac”就不可能匹配“macintosh”，同样地，“windows”和“ipod touch”也可能不匹配使用单词边界标记的子字符串。作为旁注，您可以简化正则表达式。不匹配“mac”就不可能匹配“macintosh”，同样地，“windows”和“ipod touch”也可能不匹配使用单词边界标记的子字符串。一件小事：要匹配“ipod touch”，ipod将匹配，因此前者可以删除。顺便说一句，你为什么要逃离那里的空间？iPod火柴也是如此。为什么要逃离太空？因为我当时正专注于其他的事情，却没注意到。有趣的是，Regextrie也逃避了它。我想一个原因是它允许你将regex转换为自由语音模式/x，而不会打乱苹果的购物车。做这件事没什么坏处。一件小事：要让“iPodtouch”匹配，ipod将被匹配，所以前者可以被删除。顺便说一句，你为什么要逃离那里的空间？iPod火柴也是如此。为什么要逃离太空？因为我当时正专注于其他的事情，却没注意到。有趣的是，Regextrie也逃避了它。我想一个原因是它允许你将regex转换为自由语音模式/x，而不会打乱苹果的购物车。这样做没什么坏处。我星期一会试试的。这对我来说似乎是最有希望的。至少相当简单。我会在周一试试这个。这对我来说似乎是最有希望的。至少相当简单。