Чому Ruby не підтримує i ++ або i-- (оператори збільшення / зменшення)?

Оператор до / після збільшення / зменшення ( ++і --) є досить стандартним синтаксисом мови програмування (як мінімум для процедурних та об'єктно-орієнтованих мов).

Чому Рубі їх не підтримує? Я розумію, ви могли б зробити те ж саме +=і з -=, але, як не дивно довільно, виключати щось подібне, тим більше, що це так стисло і звичайно.

Приклад:

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і встановити його, чому б не зробити те ж саме для ++?

Чи узгодженість завдань із =символом є єдиною причиною цього, чи я щось пропускаю?

Ось як Матц (Юкіхіро Мацумото) пояснює це в старій нитці :

Hi,

In message "[ruby-talk:02706] X++?"
    on 00/05/10, Aleksi Niemelä <aleksi.niemela@cinnober.com> 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.

Однією з причин є те, що до цього часу кожен оператор призначення (тобто оператор, який змінює змінну) має =в ньому. Якщо додати ++і --, це вже не так.

Ще одна причина полягає в тому, що поведінка ++і --часто бентежить людей. Справа в точці: повернене значення i++у вашому прикладі фактично було б 1, а не 2 ( iоднак нове значення було б 2).

Це не є звичайним для мов ОО. Насправді, ++у Smalltalk немає мови, яка ввела термін "об'єктно-орієнтоване програмування" (і на мову Ruby найбільш сильно впливає). Що ви маєте на увазі, це те, що це звичайно в мові С та мовах, що імітують C. Рубі має синтаксис, схожий на С, але він не є рабським у дотриманні традицій С.

Щодо того, чому його немає в Рубі: Матц цього не хотів. Це дійсно кінцева причина.

Причина відсутності подібного в Smalltalk полягає в тому, що це частина переважаючої філософії мови, що призначення змінної є принципово іншим видом , ніж надсилання повідомлення об'єкту - це на іншому рівні. Таке мислення, ймовірно, вплинуло на Маца при розробці Рубі.

Включити його в Ruby було б неможливо - ви могли легко написати препроцесора, який перетворює все ++на +=1. але, очевидно, Матсу не сподобалася ідея оператора, який зробив "приховане завдання". Дещо дивно здається, що оператор із прихованим цілим операндом всередині нього. Жоден інший оператор мови не працює таким чином.

Я думаю, що є ще одна причина: ++Ruby не може бути віддалено корисною, як у C та його прямих наступників.

Причина, forключове слово: хоча це важливо для C, воно в основному зайве в Ruby. Більшість ітерацій в Ruby робиться за допомогою численних методів, таких як eachі mapколи ітерація через деяку структуру даних, і Fixnum#timesметод, коли вам потрібно провести певну кількість разів.

Насправді, наскільки я бачив, більшу частину часу +=1використовують люди, щойно переселилися на Рубі з мов С-стилю.

Коротше кажучи, це дійсно під питанням , якщо методи ++і --будуть використовуватися на всіх.

Я думаю, що міркування Маца про те, що їм не подобається, полягає в тому, що він фактично замінює змінну новою.

колишній:

a = SomeClass.new
def a.go
  'Здравствуйте'
кінець
# у цей момент ви можете зателефонувати на a.go
# але якщо ви зробили ++
# це насправді означає a = a + 1
# тому ви більше не можете телефонувати на a.go
# як ви втратили оригінал

Тепер, якщо хтось міг переконати його, що він повинен просто зателефонувати #succ! чи що ні, це мало б більше сенсу і уникне проблеми. Можна запропонувати його на рубіновому ядрі.

Ви можете визначити .+оператор самонаростання:

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 ".

І словами Девіда Блека з його книги "Добре заземлений рубіст":

Деякі об'єкти в Ruby зберігаються в змінних як безпосередні значення. До них відносяться цілі числа, символи (які виглядають так: це) та спеціальні об'єкти true, false та nil. Коли ви присвоюєте одне з цих значень змінній (x = 1), змінна містить саме значення, а не посилання на нього. На практиці це не має значення (і це часто залишатиметься як мається на увазі, а не повторюється в обговоренні посилань та суміжних тем у цій книзі). Ruby обробляє перенаправлення посилань на об'єкти автоматично; не потрібно робити зайвих робіт, щоб надсилати повідомлення об’єкту, який містить, скажімо, посилання на рядок, на відміну від об'єкта, який містить безпосереднє ціле значення. Але правило представлення негайних цінностей має кілька цікавих наслідків, особливо якщо мова йде про цілі числа. З одного боку, будь-який об'єкт, який представляється як безпосереднє значення, завжди є точно тим самим об'єктом, незалежно від того, скільки змінних йому призначено. Є лише один об'єкт 100, лише один об'єкт помилковий тощо. Безпосередня, унікальна природа цілочисленних змінних полягає в тому, що Рубі не вистачає операторів до і після збільшення, тобто, в Ruby цього не можна робити: x = 1 x ++ # Немає такого оператора. Причина тому до негайної присутності 1 в x, x ++ було б як 1 ++, це означає, що ви будете змінювати число 1 на число 2 - і це не має сенсу. незалежно від того, скільки змінних йому призначено. Є лише один об'єкт 100, лише один об'єкт помилковий тощо. Безпосередня, унікальна природа цілочисленних змінних полягає в тому, що Рубі не вистачає операторів до і після збільшення, тобто, в Ruby цього не можна робити: x = 1 x ++ # Немає такого оператора. Причина тому до негайної присутності 1 в x, x ++ було б як 1 ++, це означає, що ви змінили б число 1 на число 2 - і це не має сенсу. незалежно від того, скільки змінних йому призначено. Є лише один об'єкт 100, лише один об'єкт помилковий тощо. Безпосередня, унікальна природа цілочисленних змінних полягає в тому, що Рубі не вистачає операторів до і після збільшення, тобто, в Ruby цього не можна робити: x = 1 x ++ # Немає такого оператора. Причина тому до негайної присутності 1 в x, x ++ було б як 1 ++, це означає, що ви змінили б число 1 на число 2 - і це не має сенсу.

Не вдалося цього досягти, додавши новий метод до класу fixnum або Integer?

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

повертає 2

"Деструктивні" методи, здається, додаються, !щоб попередити можливих користувачів, тому додавання нового методу, який називається next!, в значній мірі зробить те, що було запропоновано, тобто.

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

повертає 2 (з моменту збільшення нуля)

Звичайно, next!метод повинен був би перевірити, що об'єкт був цілою змінною, а не дійсне число, але це повинно бути доступним.

Перевірте цих операторів із сімейства C у irb і перевірте їх на собі:

x = 2    # x is 2
x += 2   # x is 4
x++      # x is now 8
++x      # x reverse to 4