Ruby 为什么'；t带有<；在布尔表达式中首先求值？

我对Ruby运算符的引用是根据这个引用，以及我所看到的其他引用，相等运算符优先于逻辑and（

&&

，而不是Ruby的

和

）

我有以下资料：

foo = nil
foo < 5 # NoMethodError: undefined method `<' for nil:NilClass

但这是可行的：

foo && foo < 5 # why does this work?

foo&&foo<5#为什么这样做？

---

由于运算符的优先级，

foo<5

应首先发生，从而导致在计算和之前发生错误。我遗漏了什么吗？

&&

和

|

从左到右计算运算符。一旦知道陈述的真假，评估就停止<代码>foo<5将永远不会得到评估。这就是第二种方法有效的原因

---

而且，

&&

和

|

具有更高的优先级。它们不同于

和
和
或
&
和
|
从左到右评估运算符。一旦知道陈述的真假，评估就停止<代码>foo<5
将永远不会得到评估。这就是第二种方法有效的原因

而且，
&&
和
|
具有更高的优先级。它们与
和
和
或
不同。优先级是关于绑定的，不一定是操作顺序。如果
&&
的LHS计算结果为false，则根本不需要计算RHS

Ruby旨在实现某种功能性，因此我将向您介绍一些Haskell，以更详细地说明这一点：

true && x = x
false && x = false

因为左手边是假的，它永远不会继续计算右手边，所以它会崩溃。这是一个非常简单的惰性评估。在第二行，
x
的值是不相关的，因此它不需要费心计算它。这就是懒惰的美。：）
 优先级是关于绑定的，不一定是操作顺序。如果
&&
的LHS计算结果为false，则根本不需要计算RHS

Ruby旨在实现某种功能性，因此我将向您介绍一些Haskell，以更详细地说明这一点：

true && x = x
false && x = false

因为左手边是假的，它永远不会继续计算右手边，所以它会崩溃。这是一个非常简单的惰性评估。在第二行，
x
的值是不相关的，因此它不需要费心计算它。这就是懒惰的美。：）
 以下内容有助于我理解这个问题：

我可以重写

foo && foo < 5

您希望首先计算
foo
，然后才计算
foo.偶？
。当在
foo之前对
foo
进行评估时，情况也是如此。以下内容有助于我理解这个问题：

我可以重写

foo && foo < 5

您希望首先计算
foo
，然后才计算
foo.偶？
。当在
foo.TL之前对
foo
进行评估时，情况也是如此；博士
[：程序，
#[:binary，
#[：vcall，[：@ident，“foo”，[1,0]]，
#   :"&&",
#[：二进制，[：vcall，[：@ident，“foo”，[1,7]]，：TL；DR
[：程序，
#[:binary，
#[：vcall，[：@ident，“foo”，[1,0]]，
#   :"&&",
#[：binary，[：vcall，[：@ident，“foo”，[1,7]]，：短路，如果
foo
为
nil
或
false
，则不会计算右侧

解析器当然会按照下面描述的方式进行操作，但是计算会在这一步之后进行

使用
parser
gem检查代码，我们可以得到一些关于Ruby解析器正在做什么的提示

我有两个文件：

foo1.rb

foo = nil
foo && foo < 5

foo = nil
foo && (foo < 5)

foo=nil
foo&foo<5

AST表示：

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (send
      (lvar :foo) :<
      (int 5))))

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (begin
      (send
        (lvar :foo) :<
        (int 5)))))

（开始
（lvasgn:foo
（零）
（及
（lvar:foo）
（发送
（lvar:foo）：<
（int 5）

foo2.rb

foo=nil
foo&&（foo<5）

AST表示：

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (send
      (lvar :foo) :<
      (int 5))))

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (begin
      (send
        (lvar :foo) :<
        (int 5)))))

（开始
（lvasgn:foo
（零）
（及
（lvar:foo）
（开始
（发送
（lvar:foo）：<
（int 5(()))

我不知道这是否澄清或混淆。
短路，如果
foo
为
nil
或
false
，则不会评估右侧

解析器当然会按照下面描述的方式进行操作，但是计算会在这一步之后进行

使用
parser
gem检查代码，我们可以得到一些关于Ruby解析器正在做什么的提示

我有两个文件：

foo1.rb

foo = nil
foo && foo < 5

foo = nil
foo && (foo < 5)

foo=nil
foo&foo<5

AST表示：

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (send
      (lvar :foo) :<
      (int 5))))

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (begin
      (send
        (lvar :foo) :<
        (int 5)))))

（开始
（lvasgn:foo
（零）
（及
（lvar:foo）
（发送
（lvar:foo）：<
（int 5）

foo2.rb

foo=nil
foo&&（foo<5）

AST表示：

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (send
      (lvar :foo) :<
      (int 5))))

(begin
  (lvasgn :foo
    (nil))
  (and
    (lvar :foo)
    (begin
      (send
        (lvar :foo) :<
        (int 5)))))

（开始
（lvasgn:foo
（零）
（及
（lvar:foo）
（开始
（发送
（lvar:foo）：<
（int 5(()))

我不知道这是澄清还是混淆。
我仍然不完全相信……在我链接的引用中，
&
的优先级低于
，也许这会有所帮助。&&&and | |在ruby中与其他语言有点不同