Neden x + = y gibi kısayollar iyi uygulama olarak kabul edilir?

Bunların gerçekte ne dendiği hakkında hiçbir fikrim yok, ama onları her zaman görüyorum. Python uygulaması şöyle bir şey:

x += 5için bir kestirme notasyon olarak x = x + 5.

Peki bu neden iyi bir uygulama olarak kabul edilir? Python, C, R vb. İçin okuduğum hemen hemen her kitapta veya programlama dersinde rastladım . Boşluklar da dahil olmak üzere üç tuşa basarak tasarruf etmenin uygun olduğunu anladım. Ama kod okurken her zaman beni gezdirecek gibi görünüyorlar ve en azından aklımda daha az okunabilir hale geliyorlar .

Bunların her yerde kullanılmasının açık ve açık bir nedenini özlüyor muyum?

Bu steno değil.

+=: Açıkça farklı makine talimat ve adresleme moduna uygun "akıllı assembler" C fikri ile - sembol 1970'lerde C dilinde göründü ve

" i=i+1", "i+=1"Ve" ++i" gibi şeyler , soyut düzeyde aynı etkiyi yaratsa da, düşük seviyede işlemcinin farklı çalışma şekillerine karşılık gelir.

Özellikle bu üç ifadeler, varsayarak ideğişken bir işlemci kayıt içine depolanmış olan bellek adresi bulunur (en bunun adı izin Dve - "int pointer" olarak düşünmek) ALU işlemcinin bir parametre alır ve bir de bir sonuca dönmek "akümülatör" (hadi A diyelim - bunu bir int olarak düşünün).

Bu kısıtlamalarla (bu dönemin tüm mikroişlemcilerinde çok yaygın), çeviri büyük olasılıkla olacaktır.

;i = i+1;
MOV A,(D); //Move in A the content of the memory whose address is in D
ADD A, 1;  //The addition of an inlined constant
MOV (D) A; //Move the result back to i (this is the '=' of the expression)

;i+=1;
ADD (D),1; //Add an inlined constant to a memory address stored value

;++i;
INC (D); //Just "tick" a memory located counter

Bunu yapmanın ilk yolu disoptimaldir, ancak sabit ( ADD A, Bveya ADD A, (D+x)) yerine değişkenlerle çalışırken veya daha karmaşık ifadeler çevrildiğinde (hepsi bir yığında düşük öncelikli işlem sırasında aşağı kayıyorlarsa, yüksek öncelikli çağrı yapın, ve tüm argümanlar ortadan kalkana kadar tekrarlayın).

İkincisi “durum makinesi” için daha tipiktir: artık bir ifadeyi “değerlendirmiyoruz”, ancak “bir değeri işletiyoruz”: yine de ALU kullanıyoruz, ancak sonucun parametrenin yerine geçmesine izin verilmesini engelliyoruz. Bu tür talimatlar, daha karmaşık ifadelerin gerekli olduğu yerlerde kullanılamaz: i = 3*i + i-2yerinde çalıştırılamaz, çünkü idaha çok kez gereklidir.

Üçüncü-on basit, "toplama" fikrini bile düşünmez, fakat bir sayaç için daha "ilkel" (hesaplamalı anlamda) bir devre kullanır. Yönerge kısaltılır, daha hızlı yüklenir ve derhal yürütülür, çünkü bir tezgahın daha küçük olması için bir kaydın güçlendirilmesi için gerekli olan kombinatoryal ağ tam bir toplayıcıdan daha hızlıdır ve bu nedenle tam bir toplayıcıdan daha hızlıdır.

Çağdaş derleyicilerde (şimdiye kadar C'ye bakın), derleyici optimizasyonunu mümkün kılan yazışmalar, uygunluğa dayalı olarak değiştirilebilir, ancak anlambilimde hala kavramsal bir fark vardır.

x += 5 anlamına geliyor

• X ile tanımlanan yeri bulun
• Buna 5 ekle

Ancak şu x = x + 5anlama gelir:

• Değerlendirin x + 5
  • X ile tanımlanan yeri bulun
  • X'i bir akümülatöre kopyala
  • Aküye 5 ekleyin
• Sonucu x olarak sakla
  • X ile tanımlanan yeri bulun
  • Akümülatörü buna kopyalayın

Tabii ki, optimizasyon olabilir

• "x bulma" nın hiçbir yan etkisi yoksa, iki "bulma" bir kez yapılabilir (ve x bir işaretçi kaydında saklanan bir adres olur)
• &xakü yerine ADD uygulanırsa iki kopya seçilebilir

Böylece optimize edilmiş kod bir birine çakışıyor x += 5.

Ancak bu sadece "x bulma" nın yan etkisi yoksa yapılabilir.

*(x()) = *(x()) + 5;

ve

*(x()) += 5;

anlamsal olarak farklıdır, çünkü x()yan etkiler (kabul etmek x()garip şeyler yapan ve geri dönen bir işlevdir int*) iki veya bir kez üretilecektir.

Arasında eşdeğerlik x = x + yve x += ynedeniyle özel durumda dolayısıyla olan +=ve =doğrudan L-değeri uygulanır.

Python'a geçmek için, C'nin sözdizimini miras aldı; ancak, yorumlanmış dillerde yürütmeden ÖNCE çeviri / optimizasyon olmadığından, işler mutlaka yakından ilişkili değildir (çünkü daha az bir ayrıştırma adımı vardır). Bununla birlikte, bir tercüman, ifadenin nasıl oluştuğuna ve değerlendirme bağlamına bağlı olarak farklı makine kodundan yararlanarak, üç ifade tipi için farklı yürütme rutinlerine başvurabilir.

Daha fazla ayrıntıyı sevenler için ...

Her CPU, özünde, girişleri ve çıktısı talimatların koduna bağlı olarak kayıt defterlerine ve / veya hafızaya "takılı" olan bir birleştirme ağına sahip olan bir ALU'ya (aritmetik-mantıksal birime) sahiptir.

İkili işlemler tipik olarak "bir yerde" girişi alınmış bir girişe sahip bir akümülatör kaydının değiştiricisi olarak gerçekleştirilir, burada bir yerde - komut akışının içinde (açık değişken için tipik: ADD A 5) - başka bir kayıt içinde (ifade hesaplaması için tipik geçici değerler: örn. ADD AB) - hafızanın içinde, bir yazmaç tarafından verilen adreste (tipik olarak veri toplama örneği: örn. ADD A (H)) - H, bu durumda bir referans gösterici gibi çalışır.

Bu sözde kod x += 5ile

ADD (X) 5

süre x = x+5olduğu

MOVE A (X)
ADD A 5
MOVE (X) A

Yani, x + 5, daha sonra atanacak bir geçici verir. x += 5doğrudan x üzerinde çalışır.

Gerçek uygulama işlemcinin gerçek talimat setine bağlıdır: Eğer bir ADD (.) copcode yoksa, ilk kod ikinci olur: olmaz.

Böyle bir opcode varsa ve optimizasyon etkinleştirilirse, ikinci ifade, geriye doğru hareketleri ortadan kaldırdıktan ve kayıt opcode'unu ayarladıktan sonra, ilk ifadedir.

Nasıl düşündüğünüze bağlı olarak, anlaşılması daha kolay çünkü daha kolay. Mesela:

x = x + 5 "x'i al, ona beş ekle ve sonra bu yeni değeri x'e geri koy" un zihinsel işlemesini çağırır.

x += 5 "5 x x artırmak" olarak düşünülebilir

Yani, sadece kısa yol değil, aslında işlevselliği daha doğrudan tarif ediyor. Gobra kodlarını okurken, kavraması çok daha kolaydır.

En azından Python , x += yve x = x + ytamamen farklı şeyler yapabilirsiniz.

Örneğin, yaparsak

a = []
b = a

daha sonra a += [3]sonuçlanır a == b == [3], süre ve a = a + [3]sonuçlanır . Yani, nesneyi yerinde değiştirir (yani, yapabilir, istediğiniz herhangi bir şeyi yapma yöntemini tanımlayabilirsiniz ), yeni bir nesne oluşturur ve değişkeni ona bağlar.a == [3]b == []+=__iadd__=

NumPy ile sayısal çalışma yaparken , bir dizinin farklı bölümlerine sıklıkla yapılan birden fazla referansla sona erdiğiniz için bu çok önemlidir ve bir dizinin diğer referanslarını içeren bir bölümünü istemeden değiştirmemenizi sağlamak önemlidir. veya gereksiz yere dizileri kopyalayın (bu çok pahalı olabilir).

Deyim denir . Programlama deyimleri, belirli bir programlama yapısını tutarlı bir şekilde yazmaları nedeniyle yararlıdır.

Birisi yazıyor zaman x += ybunu biliyor xtarafından artırılır ediliyor y(en iyi uygulama olarak, genellikle daha karmaşık işlemler ve bu sözdizimi kestirme karıştırmak olmaz) biraz daha karmaşık operasyonu değil. Bu 1 ile artış yaparken en anlamlı olanıdır.

@ Pubby'nin amacını biraz daha netleştirmek için someObj.foo.bar.func(x, y, z).baz += 5

+=Operatör olmadan gitmek için iki yol vardır:

1. someObj.foo.bar.func(x, y, z).baz = someObj.foo.bar.func(x, y, z).baz + 5. Bu sadece çok fazla gereksiz ve uzun değil, aynı zamanda daha yavaş. Bu nedenle bir
2. Geçici değişken kullanın: tmp := someObj.foo.bar.func(x, y, z); tmp.baz = tmp.bar + 5. Bu tamam, ama basit bir şey için çok fazla gürültü. Bu aslında çalışma zamanında olanlara gerçekten çok yakın, ancak yazmak çok zahmetli ve sadece +=işiniz derleyici / tercümana geçecek.

Bu +=tür operatörlerin ve diğer operatörlerin avantajı inkar edilemez, onlara alışmak sadece zaman meselesidir.

Daha kısa ve daha kolay olduğu doğrudur ve bunun altında yatan derleme dilden ilham almış olması doğrudur, ancak en iyi uygulamasının nedeni , bütün bir hata sınıfını engellemesi ve kodu incelemeyi kolaylaştırması ve bundan emin olması gerektiğidir. bu ne yapar.

İle

RidiculouslyComplexName += 1;

Tek bir değişken adı bulunduğundan, ifadenin ne yaptığından emin olabilirsiniz.

İle RidiculouslyComplexName = RidiculosulyComplexName + 1;

İki tarafın tamamen aynı olduğundan her zaman şüphe vardır. Hatayı gördün mü? Abonelikler ve elemeler mevcut olduğunda daha da kötüleşir.

+ = Notasyonu deyimsel ve daha kısa olsa da, bunlar okunmasının daha kolay olmasının sebepleri değildir. Okuma kodunun en önemli kısmı, sözdiziminin anlamla eşleştirilmesidir ve bu nedenle sözdizimi programcının düşünce süreçleriyle ne kadar yakınsa o kadar okunabilir (o da aynı zamanda bülbül kodunun kötü olmasının nedenidir: düşüncenin bir parçası değildir) işlem, ancak yine de kod işlevini yapmak için gerekli). Bu durumda, düşünce "x'in 5'i arttırdığı değişkendir", "x'in x artı 5'in değeri olmasına izin vermeyin" dir.

Daha kısa bir gösterimin okunabilirlik için kötü olduğu başka durumlar da vardır, örneğin bir ififadenin daha uygun olacağı bir üçlü operatör kullanırken .

Bu operatörlerin neden 'C tarzı' dillerde olduklarına dair bir içgörü için , 34 yıl önce K&R 1st Edition (1978) ' den bir alıntı var :

Kısa olmanın yanı sıra, atama operatörleri insanların düşündükleriyle daha iyi uyuşma avantajına sahiptir. "İ'ye 2 ekle" ya da "i'yi 2'ye kadar artır," değil "al, 2 ekle, sonra sonucu i" ye koyuyoruz. Böylece i += 2. Ayrıca, gibi karmaşık bir ifade için

yyval[yypv[p3+p4] + yypv[p1+p2]] += 2

atama operatörü kodu anlamayı kolaylaştırır, çünkü okuyucunun iki uzun ifadenin gerçekten aynı olduğunu ya da neden olmadığını merakla kontrol etmesi gerekmez. Ve bir atama operatörü, derleyicinin daha verimli kod üretmesine bile yardımcı olabilir.

Sanırım bu bölümden Brian Kernighan ve Dennis Ritchie'nin (K&R), bileşik tahsis operatörlerinin kod okunabilirliğine yardımcı olduğuna inandıkları açık.

K & R'nin bunu yazmasından bu yana uzun zaman geçti ve insanların nasıl kod yazması gerektiğine ilişkin 'en iyi uygulamaların' çoğu o zamandan beri değişti veya gelişti. Ama bu programmers.stackexchange sorusu ilk defa, bileşik ödevlerin okunabilirliği hakkında bir şikayeti dile getiren birini hatırlayabildiğim için, pek çok programcının onları bir sorun olarak bulup bulmadığını merak ediyorum. Sonra tekrar, bunu yazarken sorunun 95 oyu vardır, bu yüzden belki de insanlar kod okurken onları sıkıntılı bulurlar.

Okunabilirliğin yanı sıra, aslında farklı şeyler yaparlar: +=sol operandını iki kere değerlendirmek zorunda değildir.

Mesela, iki kere expr = expr + 5dağılır expr(varsayımsız expr).

Başkalarının çok iyi tanımladığı bariz özelliklerin yanı sıra, çok uzun isimleriniz olduğunda daha kompakt.

  MyVeryVeryVeryVeryVeryLongName += 1;

veya

  MyVeryVeryVeryVeryVeryLongName =  MyVeryVeryVeryVeryVeryLongName + 1;

Özlü.

Yazması çok daha kısa. Daha az sayıda operatör içerir. Daha az yüzey alanına ve daha az karışıklığa neden olur.

Daha spesifik bir operatör kullanıyor.

Bu tartışmalı bir örnektir ve gerçek derleyiciler bunu uygulayıp uygulamadığından emin değilim. x + = y aslında bir argüman ve bir işleç kullanır ve x'i yerinde değiştirir. x = x + y, z = x + y olan x = z'nin ara temsiline sahip olabilir. İkincisi iki operatör, toplama ve atama ve geçici bir değişken kullanır. Tek operatör, değer tarafının y dışında bir şey olamayacağını ve yorumlanması gerekmediğini açıkça ortaya koymaktadır. Ve teorik olarak artı bir operatörden ve seri olarak bir atama operatöründen daha hızlı çalışan bir artı eşittir operatöre sahip olan bazı fantezi CPU'lar olabilir.

Güzel bir deyim. Daha hızlı olup olmaması dile bağlıdır. C de daha hızlıdır, çünkü değişkeni sağ tarafa arttırmak için bir talimatı çevirir. Python, Ruby, C, C ++ ve Java gibi modern dillerin tümü op = sözdizimini destekler. Kompakt ve çabuk alışırsın. Diğer insanların kodunda (OPC) bir sürü göreceğiniz için, buna alışabilir ve kullanabilirsiniz. İşte birkaç başka dilde olan şey.

Python'da, yazmak x += 5hala tam sayı nesnesinin 1 (bir havuzdan çizilebilmesine rağmen) ve 5 içeren tam sayı nesnesinin oluşturulmasına neden olur.

Java'da tam bir döküm oluşmasına neden olur. Yazmayı dene

int x = 4;
x = x + 5.2  // This causes a compiler error
x += 5.2     // This is not an error; an implicit cast is done.

Gibi operatörler +=, bir akümülatör olarak bir değişkeni , yani toplam çalışmayı kullanırken çok yararlıdır

x += 2;
x += 5;
x -= 3;

Okumak için çok daha kolay mı:

x = x + 2;
x = x + 5;
x = x - 3;

İlk durumda, kavramsal olarak, içindeki değeri değiştiriyorsunuz x. İkinci durumda, yeni bir değer hesaplıyor ve xher seferinde atarsınız . Muhtemelen asla bu kadar basit kod yazmazken, fikir aynı kalır ... odak noktası, yeni bir değer yaratmak yerine mevcut bir değere yaptığınız şeydir.

Bunu düşün

(some_object[index])->some_other_object[more] += 5

D0 gerçekten yazmak istiyorsun

(some_object[index])->some_other_object[more] = (some_object[index])->some_other_object[more] + 5

Diğer cevaplar daha yaygın vakaları hedef alır, ancak başka bir neden daha vardır: Bazı programlama dillerinde aşırı yüklenebilir; örneğin, Scala .

Küçük Ölçek dersi:

var j = 5 #Creates a variable
j += 4    #Compiles

val i = 5 #Creates a constant
i += 4    #Doesn’t compile

Bir sınıf sadece +operatörü tanımlarsa x+=y, aslında kısayoldan ibarettir x=x+y.

Bir sınıf aşırı +=yüklenirse, bunlar:

var a = ""
a += "This works. a now points to a new String."

val b = ""
b += "This doesn’t compile, as b cannot be reassigned."

val c = StringBuffer() #implements +=
c += "This works, as StringBuffer implements “+=(c: String)”."

Ek olarak, işleçler +ve +=iki ayrı işleçtir (ve yalnızca bunlar değil: + a, ++ a, a ++, a + ba + = b de farklı işleçlerdir); Operatör aşırı yüklenmesinin mevcut olduğu dillerde, ilginç durumlar ortaya çıkabilir. Yukarıda açıklandığı gibi - +ekleme işlemini yapmak için operatörü aşırı yükleyecekseniz, aşırı yüklenmesinin de gerekli olduğunu unutmayın +=.

Bir kere ve sadece bir kere söyle: in x = x + 1, iki kere 'x' diyorum.

Ama 'a = b + = 1' yazmayın, yoksa 10 yavru kedi, 27 fare, bir köpek ve bir hamster öldürmek zorunda kalacağız.

Bir değişkenin değerini asla değiştirmemelisiniz, çünkü kodun doğru olduğunu ispatlamayı kolaylaştırır - işlevsel programlamaya bakın. Ancak yaparsanız, o zaman sadece bir kez şeyler söylemek daha iyidir.