准确地说，||= b意味着“如果a是未定义的或假的(false或nil)，将a设置为b并求值为(即返回)b，否则求值为a”。

其他人经常试图用||= b等价于|| a = b或a = a || b来说明这一点。这些等价有助于理解这个概念，但要注意，它们并非在所有条件下都是准确的。请允许我解释:

a ||= b ⇔ a || a = b? The behavior of these statements differs when a is an undefined local variable. In that case, a ||= b will set a to b (and evaluate to b), whereas a || a = b will raise NameError: undefined local variable or method 'a' for main:Object. a ||= b ⇔ a = a || b? The equivalency of these statements are often assumed, since a similar equivalence is true for other abbreviated assignment operators (i.e. +=,-=,*=,/=,%=,**=,&=,|=,^=,<<=, and >>=). However, for ||= the behavior of these statements may differ when a= is a method on an object and a is truthy. In that case, a ||= b will do nothing (other than evaluate to a), whereas a = a || b will call a=(a) on a's receiver. As others have pointed out, this can make a difference when calling a=a has side effects, such as adding keys to a hash. a ||= b ⇔ a = b unless a?? The behavior of these statements differs only in what they evaluate to when a is truthy. In that case, a = b unless a will evaluate to nil (though a will still not be set, as expected), whereas a ||= b will evaluate to a. a ||= b ⇔ defined?(a) ? (a || a = b) : (a = b)???? Still no. These statements can differ when a method_missing method exists which returns a truthy value for a. In this case, a ||= b will evaluate to whatever method_missing returns, and not attempt to set a, whereas defined?(a) ? (a || a = b) : (a = b) will set a to b and evaluate to b.

好的，好的，那么||= b等于什么?有办法在Ruby中表达这一点吗?

好吧，假设我没有忽略任何东西，我相信||= b在功能上等价于……(击鼓声)

begin
  a = nil if false
  a || a = b
end

坚持住!这不是第一个前面有noop的例子吗?嗯，不完全是。还记得我之前说的||= b只有当a是一个未定义的局部变量时，||= b才不等于|| a = b吗?如果为false，则a = nil确保a永远没有定义，即使这一行永远不会执行。Ruby中的局部变量是词法范围的。

简而言之，||=b意味着:如果a是undefined、nil或false，则将b赋值给a。否则，保持a不变。

这是默认的赋值表示法

例如:x ||= 1 这将检查x是否为nil。如果x确实为nil，那么它就会赋给它一个新值(在我们的例子中是1)

更明确的表示: 如果x == nil X = 1 结束

X ||= y表示

如果x有任何值，不要改变它的值，否则 将x设为y

A ||= b和A = b是一样的如果A。nil?或者a = b，除非a

但是所有3个选项都能显示相同的性能吗?在Ruby 2.5.1中

1000000.times do
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
  a ||= 1
end

在我的电脑上花费0.099秒，而

1000000.times do
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
  a = 1 unless a
end

用时0.062秒。这几乎快了40%。

然后我们还有:

1000000.times do
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
  a = 1 if a.nil?
end

这需要0.166秒。

并不是说这将在一般情况下产生重大的性能影响，但是如果您确实需要最后一点优化，那么可以考虑这个结果。 顺便说一下:a = 1，除非a对新手来说更容易理解，否则它是不言自明的。

注1:重复分配行多次的原因是为了减少循环在测量时间上的开销。

注2:如果我在每次赋值前执行a=nil，结果是类似的。

a ||= b

等于

a || a = b

而不是

a = a || b

因为您使用默认值定义哈希(对于任何未定义的键，哈希将返回默认值)

a = Hash.new(true) #Which is: {}

如果你使用:

a[10] ||= 10 #same as a[10] || a[10] = 10

A仍然是:

{}

但如果你这样写

a[10] = a[10] || 10

一个变成了:

{10 => true}

因为你已经在键10处赋值了它自己的值，默认为true，所以现在哈希是为键10定义的，而不是一开始就不执行赋值。