如果哈希键满足条件，ruby do语句

我有：

我正在尝试根据原始设置更改

事件

的键。如果名称包含子字符串，则名称将被更改，并且应添加新的密钥对值，并删除旧的密钥对。我希望得到：

event = {"first_type_a" => 100, "first_type_b" => false, "second_type_a" => "abc", "second_type_b" => false}

更新

事件

最有效的方法是什么

我希望这能奏效：

event = {"important.a_1" => 100, "important.b_1" => false, "second_type_a" => "abc", "second_type_b" => false}

但这带来了一个错误：

event.each_pair { |k, v|
  if !!(/first_type_*/  =~ k) do
        key = "#{["important", k.split("_", 3)[2]].join(".")}";
        event.merge!(key: v);
        event.delete(k)  
  end
}

我想换一种方式来处理：

  simpleLoop.rb:5: syntax error, unexpected keyword_do, expecting keyword_then or ';' or '\n'
  ... if !!(/first_type_*/  =~ k) do
  ...                             ^~
  simpleLoop.rb:9: syntax error, unexpected keyword_end, expecting '}'
    end
    ^~~
  simpleLoop.rb:21: embedded document meets end of file

---

但还是没有运气。我正在计算所有的括号，正如错误所表明的，它是存在的，但我找不到它。顺序重要吗？

如果

启动一个块，例如其他结构
如果。。。其他的结束
执行。。。结束
开始。。。拯救。。。结束

因此，您的第一个示例删除
do
，如果
之后的
，则该块已打开。我还将
每个_对之后的块更改为使用
do。。。结束
而不是大括号，以帮助避免将哈希与块混淆

if result = event.keys.find { |k| k.include? "first_type_" } [
  key = "#{["important", k.split("_", 3)[2]].join(".")}"
  event.merge!(key: v)
  event.delete(k)
]

if
启动一个块，例如其他结构
if。。。其他的结束
执行。。。结束
开始。。。拯救。。。结束

因此，您的第一个示例删除
do
，如果
之后的
，则该块已打开。我还将
每个_对之后的块更改为使用
do。。。结束
而不是大括号，以帮助避免将哈希与块混淆

if result = event.keys.find { |k| k.include? "first_type_" } [
  key = "#{["important", k.split("_", 3)[2]].join(".")}"
  event.merge!(key: v)
  event.delete(k)
]

我将展示如何在Ruby中非常经济地实现这一点。直到最近，当想要修改散列的键时，通常会做以下两件事之一：


创建一个新的空散列，然后向该散列添加键/值对；或
将哈希转换为两个元素数组（键值对）的数组
a
，修改
a
（键）每个元素的第一个元素，然后将
a
转换为所需的哈希

最近（通过MRI v2.4），Ruby monks向我们传授了简便的方法和技巧。我们可以在这里使用第一个。首先，我们需要一个正则表达式来匹配键

event = { 'first_type_a' => 100, 'first_type_b' => false, 'second_type_a' => 'abc', 'second_type_b' => false }
new_event = {}
event.each_pair do |k, v|
  if !!(/first_type_*/  =~ k)
    important_key = ['important', k.split('_', 3)[2]].join('.')
    new_event[important_key] = v
  else
    new_event[k] = v
  end
end

按照惯例，这是书面的

r = /
    \A           # match beginning of string
    first_type_  # match string
    (\p{Lower}+) # match 1+ lowercase letters in capture group 1
    \z           # match the end of the string
    /x           # free-spacing regex definition mode

自由间距模式的使用使得正则表达式可以自我记录。我们现在应用
transform\u keys
方法，以及刚才定义的方法和正则表达式

r = /\Afirst_type_(\p{Lower}+)\z/

在正则表达式中，p{}构造表达式
\p{Lower}
可以替换为
\p{L}
，POSIX括号表达式
[：Lower:]
（两者都匹配Unicode字母）或
[a-z]
，但后者的缺点是它不会匹配带变音符号的字母。这包括从英语文本中使用的其他语言中借用的单词的字母（如葡萄酒rosé）。搜索POSIX和
\p{}
表达式的文档

如果
“first_type.
后面可以跟小写或大写字母，请使用
\p{Alpha}
；如果后面可以跟字母数字字符，请使用
\p{Alnum}
，依此类推。
我将演示如何在Ruby中以非常经济的方式实现这一点。直到最近，当想要修改散列的键时，通常会做以下两件事之一：


创建一个新的空散列，然后向该散列添加键/值对；或
将哈希转换为两个元素数组（键值对）的数组
a
，修改
a
（键）每个元素的第一个元素，然后将
a
转换为所需的哈希

最近（通过MRI v2.4），Ruby monks向我们传授了简便的方法和技巧。我们可以在这里使用第一个。首先，我们需要一个正则表达式来匹配键

event = { 'first_type_a' => 100, 'first_type_b' => false, 'second_type_a' => 'abc', 'second_type_b' => false }
new_event = {}
event.each_pair do |k, v|
  if !!(/first_type_*/  =~ k)
    important_key = ['important', k.split('_', 3)[2]].join('.')
    new_event[important_key] = v
  else
    new_event[k] = v
  end
end

按照惯例，这是书面的

r = /
    \A           # match beginning of string
    first_type_  # match string
    (\p{Lower}+) # match 1+ lowercase letters in capture group 1
    \z           # match the end of the string
    /x           # free-spacing regex definition mode

自由间距模式的使用使得正则表达式可以自我记录。我们现在应用
transform\u keys
方法，以及刚才定义的方法和正则表达式

r = /\Afirst_type_(\p{Lower}+)\z/

在正则表达式中，p{}构造表达式
\p{Lower}
可以替换为
\p{L}
，POSIX括号表达式
[：Lower:]
（两者都匹配Unicode字母）或
[a-z]
，但后者的缺点是它不会匹配带变音符号的字母。这包括从英语文本中使用的其他语言中借用的单词的字母（如葡萄酒rosé）。搜索POSIX和
\p{}
表达式的文档

如果
“first_type.
后面可以跟小写或大写字母，请使用
\p{Alpha}
；如果后面可以跟字母数字字符，请使用
\p{Alnum}
，依此类推。
您可以定义要在转换键调用中使用的方法：

event = {"first_type_a"=>100, "first_type_b"=>false,
         "second_type_a"=>"abc", "second_type_b"=>false}

event.transform_keys { |k| k.sub(r, "important.#{'\1'}_1") }
  #=> {"important.a_1"=>100, "important.b_1"=>false,
  #    "second_type_a"=>"abc", "second_type_b"=>false} 

或用作一个衬垫：

event.each_pair.with_object({}) { |(k, v), h| h[transform(k)] = v }

您可以定义要在转换键调用中使用的方法：

event = {"first_type_a"=>100, "first_type_b"=>false,
         "second_type_a"=>"abc", "second_type_b"=>false}

event.transform_keys { |k| k.sub(r, "important.#{'\1'}_1") }
  #=> {"important.a_1"=>100, "important.b_1"=>false,
  #    "second_type_a"=>"abc", "second_type_b"=>false} 

或用作一个衬垫：

event.each_pair.with_object({}) { |(k, v), h| h[transform(k)] = v }

我仍然有一个错误，这次是
merge！':无法在迭代期间将新密钥添加到哈希中（RuntimeError）
无法使其工作：（你不能在循环中更改你正在迭代的内容。创建第二个变量来收集不同的事件。我将编辑我的答案。如果你只是在学习，试着编写程序而不改变任何变量，总是分配一个新变量。这是一个函数式编程技巧，可以减少混乱的状态完整性。我仍然有一个错误，这是错误的。）me
merge！”：无法在迭代期间将新密钥添加到哈希中（运行时错误）
无法使其工作：（你不能在循环中更改你正在迭代的内容。创建第二个变量来收集不同的事件。我将编辑我的答案。如果你只是在学习，试着编写程序而不改变任何变量，总是分配一个新变量。这是一个函数式编程技巧，可以减少混乱的状态完整性。