为什么 Ruby 不支持 i++或者我——​ （递增/递减运算符）？

Question

前/后递增/递减运算符（++ 和 --）是非常标准的编程语言语法（至少对于过程语言和面向对象语言而言）。

为什么 Ruby 不支持它们？我知道您可以使用 += 和 -= 完成同样的事情，但排除类似的东西似乎很奇怪，特别是因为它是如此简洁和传统。

示例：

i = 0    #=> 0
i += 1   #=> 1
i        #=> 1
i++      #=> expect 2, but as far as I can tell, 
         #=> irb ignores the second + and waits for a second number to add to i

我知道 Fixnum 是不可变的，但如果 += 可以实例化一个新的 Fixnum 并设置它，为什么不对 += 执行相同的操作代码>++？

包含 = 字符的赋值的一致性是造成这种情况的唯一原因，还是我遗漏了什么？

Answer 1

以下是 Matz（Yukihiro Matsumoto）在旧线程中的解释：

Hi,

In message "[ruby-talk:02706] X++?"
    on 00/05/10, Aleksi Niemelä <[email protected]> writes:

|I got an idea from http://www.pragprog.com:8080/rubyfaq/rubyfaq-5.html#ss5.3
|and thought to try. I didn't manage to make "auto(in|de)crement" working so
|could somebody help here? Does this contain some errors or is the idea
|wrong?

  (1) ++ and -- are NOT reserved operator in Ruby.

  (2) C's increment/decrement operators are in fact hidden assignment.
      They affect variables, not objects.  You cannot accomplish
      assignment via method.  Ruby uses +=/-= operator instead.

  (3) self cannot be a target of assignment.  In addition, altering
      the value of integer 1 might cause severe confusion throughout
      the program.

                            matz.

Answer 2

原因之一是到目前为止，每个赋值运算符（即更改变量的运算符）中都有一个=。如果添加 ++ 和 --，情况就不再是这样了。

另一个原因是++和--的行为经常让人感到困惑。举个例子：在您的示例中，i++ 的返回值实际上是 1，而不是 2（但是，i 的新值将是 2）。

Answer 3

这在 OO 语言中并不常见。事实上，Smalltalk 中没有 ++，Smalltalk 是创造“面向对象编程”一词的语言（也是受 Ruby 影响最强烈的语言）。您的意思是，它在 C 和密切模仿 C 的语言中是约定俗成的。Ruby 确实有一些类似 C 的语法，但它并不盲目地遵守 C 传统。

至于为什么它不在 Ruby 中：Matz 不想要它。这确实是最终的原因。

Smalltalk 中不存在这样的事情的原因是，它是该语言最重要哲学的一部分，即分配变量与向对象发送消息本质上是不同的事情 - 它处于不同的级别。这种想法可能影响了 Matz 设计 Ruby。

将它包含在 Ruby 中并非不可能 - 您可以轻松编写一个预处理器，将所有 ++ 转换为 +=1。但显然马茨不喜欢操作员执行“隐藏任务”的想法。拥有一个内部隐藏整数操作数的运算符似乎也有点奇怪。该语言中没有其他运算符以这种方式工作。

Answer 4

我认为还有另一个原因：Ruby 中的 ++ 不会像 C 及其直接后继者那样有用。

原因是 for 关键字：虽然它在 C 中很重要，但在 Ruby 中却是多余的。 Ruby 中的大部分迭代都是通过 Enumerable 方法完成的，例如迭代某些数据结构时的 each 和 map 以及 Fixnum#times 方法，当您需要循环精确的次数时。

实际上，据我所知，大多数时候 +=1 是由刚从 C 风格语言迁移到 Ruby 的人使用的。

简而言之，是否会使用 ++ 和 -- 方法确实值得怀疑。

Answer 5

您可以定义 .+ 自增运算符：

class Variable
  def initialize value = nil
    @value = value
  end
  attr_accessor :value
  def method_missing *args, &blk
    @value.send(*args, &blk)
  end
  def to_s
    @value.to_s
  end

  # pre-increment ".+" when x not present
  def +(x = nil)
    x ? @value + x : @value += 1
  end
  def -(x = nil)
    x ? @value - x : @value -= 1
  end
end

i = Variable.new 5
puts i                #=> 5

# normal use of +
puts i + 4            #=> 9
puts i                #=> 5

# incrementing
puts i.+              #=> 6
puts i                #=> 6

有关“类变量”的更多信息，请参阅“用于递增 Fixnum 对象的类变量"。

Answer 6

我认为 Matz 不喜欢它们的原因是它实际上用一个新变量替换了变量。

例如：

a = SomeClass.new
def a.go
  'hello'
end
# at this point, you can call a.go
# but if you did an a++
# that really means a = a + 1
# so you can no longer call a.go
# as you have lost your original

现在如果有人能说服他应该只调用#succ！或者什么不是，这会更有意义，并避免问题。你可以在 ruby​​ core 上推荐它。

Answer 7

用 David Black 在他的书《The Well-Grounded Rubyist》中的话来说：

Ruby 中的某些对象作为立即值存储在变量中。这些包括
整数、符号（看起来像 :this）以及特殊对象 true、false 和
零。当您将这些值之一分配给变量 (x = 1) 时，该变量保存
值本身，而不是对其的引用。
实际上，这并不重要（并且通常会被隐含地保留，而不是
在本书的参考文献和相关主题的讨论中反复阐明）。
Ruby 自动处理对象引用的取消引用；你不必
做任何额外的工作来将消息发送到包含对的引用的对象
字符串，而不是包含立即整数值的对象。
但是立即值表示规则有一些有趣的后果，
尤其是当涉及到整数时。一方面，任何表示的对象
因为立即值总是完全相同的对象，无论有多少个
它分配给的变量。只有一个对象 100，只有一个对象 false，并且
很快。
整数绑定变量的直接、独特性质是 Ruby 缺乏
前置和后置自增运算符——也就是说，你不能在 Ruby 中执行此操作：
x = 1
x++ # 没有这样的运算符
原因是由于 x 中直接存在 1，x++ 将类似于 1++，
这意味着您要将数字 1 更改为数字 2，这使得
没有意义。

Answer 8

Ruby 中的某些对象作为立即值存储在变量中。其中包括整数、符号（看起来像 :this）以及特殊对象 true、false 和 nil。当您将这些值之一分配给变量 (x = 1) 时，该变量保存该值本身，而不是对其的引用。

任何表示为立即值的对象始终是完全相同的对象，无论分配给多少个变量。只有一个对象 100，只有一个对象为 false，依此类推。

整数绑定变量的直接、唯一性质是 Ruby 缺乏前置和后置增量运算符的原因 - 也就是说，您无法在 Ruby 中执行此操作：

x=1

x++ # 没有这样的运算符

原因是，由于 x 中直接存在 1，x++ 将类似于 1++，这意味着您将把数字 1 更改为数字 2，并且没有任何意义。

Answer 9

难道不能通过向 fixnum 或 Integer 类添加新方法来实现吗？

$ ruby -e 'numb=1;puts numb.next'

返回 2 个

“破坏性”方法似乎附加了 ! 来警告可能的用户，因此添加一个名为 next! 的新方法几乎可以完成所请求的操作，即。

$ ruby -e 'numb=1; numb.next!; puts numb' 

返回 2（因为 numb 已递增）

当然，next! 方法必须检查该对象是否是整型变量而不是实数，但这应该可用。