奇异的ruby逻辑&&；运算符结果

我在Pry玩的时候遇到了这样一个问题：

20] pry(main)> ('X' && 'O') == 'X'
=> false
[22] pry(main)> ('O' && 'X') == 'X'
=> true

有了这个，我试图检查括号内的两个值是否与右边的值相同。 第二次的结果告诉我我遗漏了什么

它似乎返回了上一次比较的值（'X'='X'），但我的印象是&&一旦发现第一个错误就会停止

我可以理解为什么顺序在一般情况下很重要，但我认为通过将它们包装在（）中，它们将作为一个条件进行检查

但我的印象是&&一旦发现第一个错误就会停止

你说得对。但这两个例子中的任何一个都没有发生

在您的示例中，

'O'

和

'X'

都是字符串对象，具有真实值

在示例

（'X'&&'O'）=='X'

，

（'X'&&'O'）

给出

“O”

，并将其与

“X”

进行比较，这当然是

错误的。因此，您得到了
false

在另一个
（'O'和&'X'）=='X'
，
（'O'和&'X'）
给出
“X”
，然后将其与
“X”
进行比较，当然它应该是
真的
。因此，您在
PRY
中得到了
true

注意：在Ruby中，除了
nil
和
false
之外，所有对象都有truthy值

当使用
&&
时，它将继续计算其所有表达式，直到得到一个计算为falsy的表达式

但我的印象是&&一旦发现第一个错误就会停止

你说得对。但这两个例子中的任何一个都没有发生

在您的示例中，
'O'
和
'X'
都是字符串对象，具有真实值

在示例
（'X'&&'O'）=='X'
，
（'X'&&'O'）
给出
“O”
，并将其与
“X”
进行比较，这当然是
错误的。因此，您得到了
false

在另一个
（'O'和&'X'）=='X'
，
（'O'和&'X'）
给出
“X”
，然后将其与
“X”
进行比较，当然它应该是
真的
。因此，您在
PRY
中得到了
true

注意：在Ruby中，除了
nil
和
false
之外，所有对象都有truthy值

当使用
&
时，它将继续计算其所有表达式，直到得到一个计算结果为falsy的表达式。
在ruby
&&
中，
和
将检查第一个值，如果它在那里，它将转到下一个值，第一个值
false
或
nil
它将返回该值

foo = :foo
bar = nil

a = foo and bar
# => nil
a
# => :foo

a = foo && bar
# => nil 
a
# => nil

a = (foo and bar)
# => nil
a
# => nil

(a = foo) && bar
# => nil
a
# => :foo
> a = true && false
=> false 
> a
=> false 
> a = true and false
=> false 
> a
=> true   

在ruby
和&
中，
和
将检查第一个值，如果它在那里，它将转到下一个值，第一个值
false
或
nil
它将返回该值

foo = :foo
bar = nil

a = foo and bar
# => nil
a
# => :foo

a = foo && bar
# => nil 
a
# => nil

a = (foo and bar)
# => nil
a
# => nil

(a = foo) && bar
# => nil
a
# => :foo
> a = true && false
=> false 
> a
=> false 
> a = true and false
=> false 
> a
=> true   

谢谢你，奥雅纳。我知道真实和虚假的价值观，我只是把操作搞混了：）谢谢奥雅纳。我知道真实和虚假的价值观，我只是把操作搞混了：）