Ruby：为什么这个WHEN语句不'；你不能在两个条件下工作吗？

我的Ruby代码中有一个

大小写

，它基本上尝试以几种方式匹配字符串，并相应地对其执行不同的操作，有点像这样：

case inst
when Rx_inst1
  (some function)
when Rx_inst2
  (some other function)
end

这工作得很好（我没有发布正则表达式，因为它非常、非常长而且工作得很好）。但是，当我尝试实现以下修改时，即使正则表达式与字符串匹配，如果它包含子字符串，也不会执行该条件：

case inst
when Rx_inst1
  (some function)
when Rx_inst2 && !/dom\./
  (some other function)
end

当它等于

Nm时，它停止匹配
inst
。Friese=Fryzyjczyk、końfryzyjski

或它之前匹配的任何其他类型的字符串

---

我用

&/dom\./

和

&&inst.include？（'dom'）

得到了完全相同的结果，根据其他答案，这是正确的语法。我做错了什么？

很明显，

Rx\u inst2&/dom\./

返回（由于短路计算）第二个操作数的值，即

/dom\/

（提供的

Rx_inst2

实际上是一个

Regexp

，因此是真实的）。您可能需要在

Rx_inst2

中修改此regexp，没有简短的答案

或者，您可以稍微更改所有的

大小写
表达式，如下所示：

case
when inst =~ Rx_inst1
  # (some function)
when inst =~ Rx_inst2 && !(inst =~ /dom\./)
  # (some other function)
end

但在我看来，它的形式并不特别优雅。
很明显，
Rx_inst2&/dom\./
返回（由于短路计算）第二个操作数的值，即
/dom\/
（提供的
Rx_inst2
实际上是一个
Regexp
，因此是真实的）。您可能需要在
Rx_inst2
中修改此regexp，没有简短的答案

或者，您可以稍微更改所有的
大小写
表达式，如下所示：

case
when inst =~ Rx_inst1
  # (some function)
when inst =~ Rx_inst2 && !(inst =~ /dom\./)
  # (some other function)
end

但在我看来，它并不是特别优雅的形式。
好吧，所以结果是我让它这样工作：

case inst
when Rx_inst1
  (some function)
when Rx_inst2
  (some other function)
end

when（！inst.include？（'dom.'）和Rx_inst2）

我仍然不明白为什么我要做以下三件事：

改变操作顺序
将整个表达式括起来
显式调用第一个，隐式调用第二个
好吧，结果证明我是这样做的：

case inst
when Rx_inst1
  (some function)
when Rx_inst2
  (some other function)
end

when（！inst.include？（'dom.'）和Rx_inst2）

我仍然不明白为什么我要做以下三件事：

改变操作顺序
将整个表达式括起来
显式调用第一个，隐式调用第二个
case转换成一组if/elsif/else语句，并带有==运算符
因此，您的代码与

if Rx_inst1 === inst
  (some function)
elsif (Rx_inst2 && !/dom\./) === inst
  (some other function)
end

而
（Rx_inst2&&！/dom\./）==inst
的工作原理如下：

case
when inst =~ Rx_inst1
  # (some function)
when inst =~ Rx_inst2 && !(inst =~ /dom\./)
  # (some other function)
end

（Rx_inst2&！/dom\./）
零件计算结果为
/dom\./
（Rx_inst2是一个正则表达式，不是nil或false）
/dom\./==inst
给出结果
所以
当Rx_inst2&&/dom\./
在
时匹配/dom\./==inst
匹配

case转换成一组if/elsif/else语句，并带有==运算符
因此，您的代码与

if Rx_inst1 === inst
  (some function)
elsif (Rx_inst2 && !/dom\./) === inst
  (some other function)
end

而
（Rx_inst2&&！/dom\./）==inst
的工作原理如下：

case
when inst =~ Rx_inst1
  # (some function)
when inst =~ Rx_inst2 && !(inst =~ /dom\./)
  # (some other function)
end

（Rx_inst2&！/dom\./）
零件计算结果为
/dom\./
（Rx_inst2是一个正则表达式，不是nil或false）
/dom\./==inst
给出结果
所以
当Rx_inst2&&/dom\./
在
时匹配/dom\./==inst
匹配
@Darigazz很好地解释了
案例
的工作原理以及代码出错的原因。以下是你写案例陈述的几种方法

#1

case inst
when Rx_inst1
  m1  
when Rx_inst2
  m2 if inst.match? /dom\./
end

如果指令匹配，则返回
nil
/如果指令匹配，则在
m2中的dom\./#=>false
/dom\./
。根据要求，
if
可能会替换为
，除非

#2

case inst
when Rx_inst1
  m1  
when /(?=.*dom\.)#{Rx_inst2}/
  m2
end

其中，
（？=.*dom\）
是一个积极的前瞻。比如说,

Rx_inst2 = /Bubba|Trixie/
/(?=.*dom\.)#{Rx_inst2}/
   #=> /(?=.*dom\.)(?-mix:Bubba|Trixie)/

根据不同的需求，
（？=.*dom\）
可能会被反向前瞻
（？！.*dom\）
@Darigazz已经很好地解释了
案例的工作原理以及代码出错的原因。以下是你写案例陈述的几种方法

#1

case inst
when Rx_inst1
  m1  
when Rx_inst2
  m2 if inst.match? /dom\./
end

如果指令匹配，则返回
nil
/如果指令匹配，则在
m2中的dom\./#=>false
/dom\./
。根据要求，
if
可能会替换为
，除非

#2

case inst
when Rx_inst1
  m1  
when /(?=.*dom\.)#{Rx_inst2}/
  m2
end

其中，
（？=.*dom\）
是一个积极的前瞻。比如说,

Rx_inst2 = /Bubba|Trixie/
/(?=.*dom\.)#{Rx_inst2}/
   #=> /(?=.*dom\.)(?-mix:Bubba|Trixie)/

根据要求，
（？=.*dom\）
可能会被负前瞻
（？！.*dom\）
您能详细说明为什么短路评估在这里很明显吗？好吧，请处理
Rx_inst2&/dom\./
作为一个单独的表达式（它就是这样的）。它是如何评估的？顺便说一句，在Ruby中，所有这些操作符：
&&&、| |和，或
都使用短路求值。它们都分别返回
true
，因此作为一个整体，当两个元素都是
true
时，它不应该是
true吗？不，首先，在Ruby中，二进制逻辑操作符只返回布尔值。我编辑了我的答案，以提供一种有点黑客味的替代方法来做你想做的事情。@M词汇哦，对不起，我在我的黑客解决方案代码中犯了一个错误，修复了它，现在它应该可以按照你的要求工作，并且可读性更强。你能详细解释一下为什么短路评估在这里很明显吗？嗯，治疗
Rx_inst2&/dom\./
作为一个单独的表达式（它就是这样的）。它是如何评估的？顺便说一句，在Ruby中，所有这些操作符：
和&&、| |和，或
都使用短路求值。它们都分别返回
true
，所以作为一个整体，当两个元素都是
true
时，它不应该是
true吗？不，首先，在Ruby中，二进制逻辑操作符只返回b