Ruby neden i ++ veya i-- (artırma / azaltma operatörlerini) desteklemiyor?

Ön / son artırma / azaltma operatörü ( ++ve --) oldukça standart programlama dili sözdizimidir (en azından prosedürel ve nesne yönelimli diller için).

Ruby neden onları desteklemiyor? Sana aynı şeyi başarabileceğini anlamaya +=ve -=, ama sadece o kadar özlü ve konvansiyonel, özellikle beri böyle bir şey dışlamak için tuhaf keyfi görünmektedir.

Misal:

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

Anladığım kadarıyla Fixnumdeğişmez, ama +=yenisini deneyip kurabiliyorsa Fixnum, neden aynısını yapmayalım ++?

=Bunun tek nedeni karakteri içeren ödevlerde tutarlılık mı yoksa bir şeyi mi kaçırıyorum?

Matz (Yukihiro Matsumoto) bunu eski bir başlıkta şöyle açıklıyor :

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.

Bunun bir nedeni, şimdiye kadar her atama operatörünün (yani bir değişkeni değiştiren bir operatörün) içinde bir a =sahip olmasıdır. Eğer eklerseniz ++ve --bu artık durum bu.

Diğer bir neden de insanların davranışları ++ve --çoğu zaman kafa karıştırmasıdır. Örnek olay: Örneğinizdeki dönüş değeri i++aslında 2 değil 1 olur (yeni değeri i2 olur).

OO dillerinde geleneksel değildir. Aslında, ++Smalltalk'ta "nesne yönelimli programlama" terimini (ve Ruby'nin en güçlü şekilde etkilediği dil) bulan dil yoktur. Demek istediğin, C'de geleneksel olduğu ve C'yi yakından taklit eden diller olduğudur. Ruby'nin bir şekilde C benzeri bir sözdizimi vardır, ancak C geleneklerine bağlı kalarak kölece değildir.

Ruby'de neden olmadığına gelince: Matz istemedi. Bu gerçekten nihai neden.

Smalltalk'ta böyle bir şeyin olmamasının nedeni, dilin bir değişken atamanın temelde bir nesneye mesaj göndermekten farklı bir şey olması felsefesinin bir parçası olmasıdır - farklı bir seviyededir. Bu düşünce muhtemelen Ruby'yi tasarlarken Matz'ı etkiledi.

Bunu Ruby'ye dahil etmek imkansız olmazdı - kolayca hepsini ++dönüştüren bir önişlemci yazabilirsiniz +=1. ama belli ki Matz, "gizli bir görev" yapan bir operatör fikrini beğenmedi. Ayrıca içinde gizli bir tamsayı işleneni olan bir operatörün olması biraz garip görünüyor. Dildeki başka hiçbir operatör bu şekilde çalışmaz.

Bence başka bir neden daha var: ++Ruby'de C ve onun doğrudan halefleri gibi uzaktan kullanışlı olmayacaktı.

Bunun nedeni, foranahtar kelime: C için gerekli olsa da, Ruby'de çoğunlukla gereksizdir. Ruby'deki yinelemenin çoğu, belirli bir sayıda döngü yapmanız gerektiğinde, bazı veri yapıları ve yöntemlerde yinelendiğinde eachve bunlar gibi Numaralandırılabilir yöntemlerle yapılır .mapFixnum#times

Aslında gördüğüm kadarıyla çoğu zaman +=1Ruby'ye C tarzı dillerden yeni göç etmiş insanlar tarafından kullanılıyor.

Yöntemler Kısacası, gerçekten şüpheli olduğunu ++ve --hiç kullanılacaktır.

Bence Matz'ın onları beğenmemesinin nedeni aslında değişkeni yenisiyle değiştirmesidir.

örn:

a = SomeClass.new
def a.go
  'Merhaba'
son
# bu noktada a.go'yu arayabilirsiniz
# ama bir a ++ yaptıysanız
# bu gerçekten a = a + 1 anlamına gelir
# böylece artık a.go'yu arayamazsınız
# aslını kaybettiğin gibi

Şimdi eğer birisi onu # succ diye çağırması gerektiğine ikna edebilirse! ya da ne değil, bu daha mantıklı olur ve problemi önler. Ruby core'da önerebilirsiniz.

Kendi .+kendini artırma operatörü tanımlayabilirsiniz :

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

"Sınıf Değişkeni" hakkında daha fazla bilgi " Fixnum nesnelerini artırmak için Sınıf Değişkeni " bölümünde mevcuttur .

Ve David Black'in "The Well-Grounded Rubyist" kitabındaki sözleriyle:

Ruby'deki bazı nesneler değişkenler içinde anlık değerler olarak saklanır. Bunlar arasında tamsayılar, semboller (buna benzer) ve true, false ve nil özel nesneleri bulunur. Bu değerlerden birini bir değişkene (x = 1) atadığınızda, değişken bir referans yerine değerin kendisini tutar. Pratik anlamda, bu önemli değildir (ve bu kitaptaki referanslar ve ilgili konuların tartışmalarında tekrar tekrar ifade edilmek yerine genellikle ima edildiği gibi bırakılacaktır). Ruby, nesne referanslarının referanslarının kaldırılmasını otomatik olarak gerçekleştirir; anlık bir tamsayı değeri içeren bir nesnenin aksine, örneğin bir dizgeye referans içeren bir nesneye mesaj göndermek için fazladan bir iş yapmanız gerekmez. Ancak anlık değer gösterimi kuralının birkaç ilginç sonucu vardır. özellikle tamsayılar söz konusu olduğunda. Birincisi, anlık değer olarak gösterilen herhangi bir nesne, kaç değişkene atanmış olursa olsun, her zaman tam olarak aynı nesnedir. Yalnızca bir nesne 100 vardır, yalnızca bir nesne yanlıştır, vb. Tamsayıya bağlı değişkenlerin anlık, benzersiz doğası, Ruby'nin artırma öncesi ve sonrası işleçlerinin olmamasının arkasındadır - yani bunu Ruby'de yapamazsınız: x = 1 x ++ # Böyle bir operatör yok Sebep şu ki x'de 1'in hemen var olması durumunda, x ++ 1 ++ gibi olur, bu da 1 rakamını 2 rakamına değiştireceğiniz anlamına gelir - ve bu hiç mantıklı değil. kaç değişkene atanmış olursa olsun. Yalnızca bir nesne 100 vardır, yalnızca bir nesne yanlıştır, vb. Tamsayıya bağlı değişkenlerin anlık, benzersiz doğası, Ruby'nin artırma öncesi ve sonrası işleçlerinin olmamasının arkasındadır - yani bunu Ruby'de yapamazsınız: x = 1 x ++ # Böyle bir operatör yok Sebep şu ki x'de 1'in hemen var olması durumunda, x ++ 1 ++ gibi olur, bu da 1 rakamını 2 rakamına değiştireceğiniz anlamına gelir - ve bu hiç mantıklı değil. kaç değişkene atanmış olursa olsun. Yalnızca bir nesne 100 vardır, yalnızca bir nesne yanlıştır, vb. Tamsayıya bağlı değişkenlerin anlık, benzersiz doğası, Ruby'nin artırma öncesi ve sonrası işleçlerinin olmamasının arkasındadır - yani bunu Ruby'de yapamazsınız: x = 1 x ++ # Böyle bir operatör yok Sebep şu ki x'de 1'in hemen var olması durumunda, x ++ 1 ++ gibi olur, bu da 1 rakamını 2 rakamına değiştireceğiniz anlamına gelir - ve bu hiç mantıklı değil.

Fixnum veya Integer sınıfına yeni bir yöntem eklenerek bu başarılamaz mı?

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

2 döndürür

!Olası kullanıcıları uyarmak için "yıkıcı" yöntemler eklenmiş gibi görünmektedir , bu nedenle adı verilen yeni bir yöntemin eklenmesi, yani next!istenen şeyi hemen hemen yapacaktır.

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

2 döndürür (uyuşma arttığından beri)

Elbette, next!yöntemin nesnenin bir tam sayı değişkeni olduğunu ve gerçek bir sayı olmadığını kontrol etmesi gerekir , ancak bu mevcut olmalıdır .

Ruby's irb'deki C ailesinden bu operatörleri kontrol edin ve bunları kendiniz test edin:

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