Neden örtük dönüşüm olamaz?

Anladığım kadarıyla, örtük dönüşümler hatalara neden olabilir.

Ama bu mantıklı değil - normal dönüşümler de hatalara neden olmamalı mı?

Neden olmasın

len(100)

dil ile çalışarak (veya derleyerek)

len(str(100))

özellikle de çalışmasının tek yolu bu. Dil hatanın ne olduğunu biliyor, neden düzeltmiyorsunuz?

Bu örnekte Python kullandım, ancak bu küçük şey için temelde evrensel olduğunu hissediyorum.

Değeri için len(str(100)), len(chr(100))ve len(hex(100))hepsi farklı. strolduğu değil bir dizeye bir tamsayı gelen Python birden fazla farklı dönüşüm var çünkü o iş yapmak için tek yol. Bunlardan biri en yaygın olanıdır, ancak demek istediğini söylemeye gerek yok. Örtük bir dönüşüm, kelimenin tam anlamıyla "söylemeden geçer" anlamına gelir.

Örtük dönüşümlerle ilgili pratik sorunlardan biri, çeşitli olasılıkların olduğu yerlerde hangi dönüşümün uygulanacağı her zaman açık değildir ve bu, okuyucuların doğru örtülü dönüşümü anlayamadıkları için kodu yorumlamada hata yapmalarına neden olur. Herkes her zaman kastettiklerinin "açık yorum" olduğunu söyler. Bu onlar için açık çünkü onlar demek istedikleri şey. Başka biri için açık olmayabilir.

Bu yüzden (çoğu zaman) Python örtük olarak açık olmayı tercih eder, risk almamayı tercih eder. Python'un zorlama türü yaptığı ana durum aritmetiktir. Bu izin veren 1 + 1.0alternatif yaşamak için çok can sıkıcı olurdu çünkü, ancak izin vermez 1 + "1"size Şunu belirtmek için olmalıdır düşünüyor çünkü int("1"), float("1"), ord("1"), str(1) + "1", ya da başka bir şey. Ayrıca izin vermez (1,2,3) + [4,5,6]o halde olabilir bir sonuç türünü seçmek için kurallar tanımlayabilirsiniz o sonucu türünü seçmek için kurallar tanımlar gibi, 1 + 1.0.

Diğer diller aynı fikirde değildir ve birçok örtük dönüşüm gerçekleştirmiştir. Ne kadar çok içerirlerse, o kadar az belirgin olurlar. Kahvaltıdan önce "tamsayı promosyonları" ve "olağan aritmetik dönüşümler" için C standardındaki kuralları ezberlemeyi deneyin!

Anladığım kadarıyla, örtük dönüşümler hatalara neden olabilir.

Bir kelimeniz eksik: örtük dönüşümler çalışma zamanı hatalarına neden olabilir .

Gösterdiğiniz gibi basit bir vaka için, ne demek istediğinizi gayet açık. Ancak diller vakalarda çalışamaz. Kurallarla çalışmaları gerekiyor. Diğer birçok durumda, programcının bir hata yapıp yapmadığını (yanlış tür kullanarak) veya programcı kodun yapmayı düşündüklerini yapmak istediği açık değildir.

Kod yanlış kabul edilirse, bir çalışma zamanı hatası alırsınız. Takip etmek sıkıcı olduklarından, birçok dil size dağınık olduğunuzu söyleme ve bilgisayara gerçekten ne demek istediğinizi söylemenize izin verme tarafına doğru (hatayı düzeltin veya açık bir şekilde dönüştürme yapın). Diğer diller tahmin yapar, çünkü stilleri hata ayıklaması daha kolay olan hızlı ve kolay koda sahiptir.

Dikkat edilmesi gereken bir şey, örtük dönüşümlerin derleyiciyi biraz daha karmaşık hale getirmesidir. Döngüler hakkında daha dikkatli olmanız gerekir (hadi A'dan B'ye bu dönüşümü deneyelim; işe yaramayan ayy, ama B'den A'ya bir dönüşüm var! Ve sonra C ve D boyutlu döngüler için endişelenmeniz gerekiyor ). örtük dönüşümlerden kaçınmak için küçük bir motivasyon.

Örtük dönüşümler yapmak oldukça mümkündür. Başın belada olduğu durum, bir şeyin hangi şekilde çalışması gerektiğini bilmediğin zamandır.

Bunun bir örneği, +operatörün farklı zamanlarda farklı şekillerde çalıştığı Javascript'te görülebilir .

>>> 4 + 3
7
>>> "4" + 3
43
>>> 4 + "3"
43

Bağımsız değişkenlerden biri bir dize ise, +işleç bir dize birleşimidir, aksi takdirde ekleme yapılır.

Bir bağımsız değişken verilirse ve bunun bir dize mi yoksa tamsayı mı olduğunu bilmiyorsanız ve buna bir ekleme yapmak istiyorsanız, biraz karışıklık olabilir.

Bununla başa çıkmanın bir başka yolu, Temel mirastır (perl'in izlediği - bkz. Programlama Zor, Komut Dosyasına Girelim ... )

Basic'te, lenişlev yalnızca bir String'de çağrılmayı gerektirir ( visual basic için dokümanlar : "Geçerli herhangi bir String ifadesi veya değişken adı. İfade Object türündeyse, Len işlevi boyutu dosyaya FilePut işlevi. ").

Perl bu bağlam kavramını takip eder. İçin tiplerinin örtük dönüşüm ile JavaScript var karışıklık +operatörü bazen ilave olarak bazen birleştirme perl'de olmaz çünkü +olduğunu her zaman ekleme ve .olduğunu her zaman birleştirme.

Skaler bağlamda bir şey kullanılırsa, bu bir skalerdir (örneğin, bir listeyi skaler olarak kullanmak, liste uzunluğuna karşılık gelen bir sayı gibi davranır). Bir dize operatörü kullanırsanız ( eqeşitlik testi cmpiçin, dize karşılaştırması için) skaler, bir dizemiş gibi kullanılır. Benzer şekilde, bir matematik bağlamında bir şey kullanılmışsa ( ==eşitlik testi ve <=>sayısal karşılaştırma için), skaler sanki bir sayıymış gibi kullanılır.

Tüm programlama için temel kural "kişiyi en az şaşırtan şeyi yapın" dır. Bu, orada sürprizlerin olmadığı anlamına gelmez, ancak çaba kişiye en az sürpriz yapmaktır.

Perl - php'nin yakın bir kuzenine giderken, bir operatörün dize veya sayısal bağlamlarda bir şey üzerinde hareket edebileceği ve davranışın insanlar için şaşırtıcı olabileceği durumlar vardır. ++Operatör buna bir örnektir. Rakamlarda, tam olarak beklendiği gibi davranır. Bir dizge üzerinde "aa"çalışırken, dizeyi artırır ( $foo = "aa"; $foo++; echo $foo;yazdırır ab). Aynı zamanda o kadar devredilir azartırılır zaman olur ba. Bu henüz şaşırtıcı değil.

$foo = "3d8";
echo "$foo\n";
$foo++;
echo "$foo\n";
$foo++;
echo "$foo\n";
$foo++;
echo "$foo\n";

^{( ideone )}

Bu çıktı:

3d8
3d9
3e0
4

Örtük dönüşümlerin ve aynı dizede farklı davranan operatörlerin tehlikelerine hoş geldiniz. (Kod biraz farklı blok Perl kolları - bu karar "3d8"zaman ++operatör uygulanır baştan sayısal bir değerdir ve gider 4hemen ( ideone ) - bu davranışı, anlatılan perlop: Otomatik arttırma ve Otomatik eksiltme )

Şimdi, neden bir dil bir şekilde bir şey yapıyor, diğeri ise başka bir şekilde tasarımcıların tasarım düşüncelerine ulaşıyor. Perl'in felsefesi: Bunu yapmanın birden fazla yolu var - ve bu işlemlerden bazılarını yapmanın birkaç yolunu düşünebilirim. Öte yandan, Python'un PEP 20 - Python'un Zen'i (diğer şeylerin yanı sıra) şunları ifade eden bir felsefesi vardır: "Bunu yapmanın tek ve tercihen tek bir yolu olmalı."

Bu tasarım farklılıkları farklı dillere yol açmıştır. Python'da bir sayının uzunluğunu almanın bir yolu vardır. Örtük dönüşüm bu felsefeye aykırıdır.

İlgili okuma: Ruby neden Fixnum'u String'e dönüştürmüyor?

ColdFusion bunların çoğunu yaptı. Örtük dönüşümlerinizi işlemek için bir dizi kural tanımlar, tek bir değişken türüne sahiptir ve işte gidiyorsunuz.

Sonuç, 6'ya "4a" eklemenin 6.16667 olduğu toplam anarşi.

Neden? İki değişkenin ilki bir sayı olduğu için sonuç sayısal olacaktır. "4a" bir tarih olarak ayrıştırılır ve "04:00" olarak görülür. 04:00, 4: 00/24: 00 veya günün 1 / 6'sıdır (0.16667). 6'ya ekleyin ve 6.16667 olsun.

Listelerde virgülün varsayılan ayırıcı karakterleri bulunur, bu nedenle virgül içeren bir listeye öğe eklerseniz, yalnızca iki öğe eklersiniz. Ayrıca, listeler gizlice dizgidir, bu nedenle yalnızca 1 öğe içeriyorlarsa tarih olarak ayrıştırılabilirler.

Dize karşılaştırması, her iki dizenin önce tarihlere ayrıştırılıp ayrıştırılamayacağını denetler. Tarih türü olmadığından bunu yapar. Rakamlar, sekizli gösterim ve booleans ("doğru" ve "evet" vb.) İçeren sayılar ve dize için aynı şey

Hızlı başarısız olmak ve bir hata bildirmek yerine, ColdFusion sizin için veri tipi dönüşümlerini işleyecektir. Ve iyi bir şekilde değil.

Tabii ki, DateCompare gibi açık işlevleri çağırarak örtük dönüşümleri düzeltebilirsiniz ... ancak daha sonra örtük dönüştürmenin "faydalarını" kaybettiniz.

ColdFusion için bu, geliştiricilerin güçlendirilmesine yardımcı olmanın bir yoludur. Özellikle tüm bu geliştiriciler HTML olduğunda (ColdFusion etiketlerle çalışır, buna CFML denir, daha sonra komut dosyası eklediler <cfscript>, burada her şey için etiket eklemenize gerek yoktur). Ve sadece bir şeyin çalışmasını istediğinizde iyi çalışır. Ancak, olayların daha kesin bir şekilde gerçekleşmesi gerektiğinde, bir hata olmuş gibi görünen herhangi bir şey için örtük dönüşümler yapmayı reddeden bir dile ihtiyacınız vardır.

Örtük dönüşümlerin, açıkça aramadan önce int'i bir dizeye dönüştürmeyi int a = 100; len(a)düşündüğünüz açık olan işlemler için iyi bir fikir olabileceğini söylüyorsunuz .

Ama bu aramalar olabileceğini unutuyorsun sözdizimsel kesin ama geçmek anlamına programcı tarafından yapılan bir yazım hatası temsil edebilir a1, hangi olan bir dize. Bu tartışmalı bir örnektir, ancak değişken adlar için otomatik tamamlama sağlayan IDE'lerle bu hatalar meydana gelir.

Tür sistemi, hatalardan kaçınmamıza yardımcı olmayı amaçlar ve daha katı tür denetlemeyi seçen diller için örtük dönüşümler bunu zayıflatır.

== tarafından gerçekleştirilen tüm örtük dönüşümlerle Javascript'in sıkıntılarını kontrol edin, o kadar ki çoğu artık no-implicit-conversion === operatörüne bağlı kalmanızı öneriyor.

Bir an için ifadenizin bağlamını düşünün. Bunun işe yarayabileceği "tek yol" olduğunu söylüyorsunuz, ancak bunun böyle çalışacağından gerçekten emin misiniz? Peki buna ne dersin:

def approx_log_10(s):
    return len(s)
print approx_log_10(3.5)  # "3" is probably not what I'm expecting here...

Diğerlerinin de belirttiği gibi, çok özel örneğinizde, derleyicinin ne demek istediğini sezmesi basit görünüyor. Ancak daha karmaşık programların daha geniş bir bağlamında, bir dize girmek mi, yoksa başka bir değişken için bir değişken adı yazmak mı, yoksa yanlış işlev veya düzinelerce diğer potansiyel mantık hatasından herhangi birini yazmak mı istediğiniz genellikle açık değildir. .

Tercüman / derleyicinin ne demek istediğini tahmin etmesi durumunda, bazen sihirli bir şekilde çalışır ve daha sonra diğer zamanlarda gizemli bir şekilde işe yaramayan bir şeyi hata ayıklamak için saatlerce harcıyorsun. Ortalama bir durumda, ifadenin mantıklı olmadığı ve gerçekte kastettiğiniz şeyi düzeltmek için birkaç saniye harcadığınız söylenmesi çok daha güvenlidir.

Örtük dönüşümler, çalışmak için gerçek bir acı olabilir. PowerShell'de:

$a = $(dir *.xml) # typeof a is a list, because there are two XML files in the folder.
$a = $(dir *.xml) # typeof a is a string, because there is one XML file in the folder.

Aniden iki kat daha fazla test gerekli ve örtük dönüşüm olmadan iki kat daha fazla hata var.

Niyetinizi açıkça ortaya koydukları için açık dökümler önemlidir. Her şeyden önce açık dökümler kullanmak, kodunuzu okuyan birine bir hikaye anlatır. Yaptıklarınızı kasıtlı olarak yaptığınızı ortaya koyarlar. Üstelik aynı şey derleyici için de geçerlidir. Örneğin, C # 'da geçersizdir

double d = 3.1415926;
// code elided
int i = d;

Oyuncular, kolayca bir hata olabilecek gevşek hassasiyeti sağlayacaktır. Bu nedenle derleyici derlemeyi reddeder. Açık bir kadro kullanarak derleyiciye: "Hey, ne yaptığımı biliyorum." Ve gidecek: "Tamam!" Ve derleyin.

Örtük dönüşümleri / yayınları veya bazen belirtildiği gibi zayıf yazmayı destekleyen diller, sizin için her zaman amaçladığınız veya beklediğiniz davranışla eşleşmeyen varsayımlar yapar. Dil tasarımcıları, belirli bir dönüşüm veya dönüşüm dizisi için yaptığınızla aynı düşünce sürecine sahip olmuş olabilirler ve bu durumda asla bir sorun görmezsiniz; ancak yapmadılarsa, programınız başarısız olur.

Ancak, başarısızlık belli olabilir veya olmayabilir. Bu örtülü yayınlar çalışma zamanında oluştuğundan, programınız mutlu bir şekilde çalışır ve yalnızca programınızın çıktısına veya sonucuna baktığınızda bir sorun görürsünüz. Açık dökümler gerektiren bir dil (bazıları bunu güçlü yazma olarak ifade eder), program yürütmeye başlamadan önce size bir hata verir;

Geçen gün bir arkadaşım 2 yaşındaki çocuğuna 20 + 20'nin ne olduğunu sordu ve 2020'yi yanıtladı. Arkadaşıma "O bir Javascript programcısı olacak" dedim.

Javascript'te:

20+20
40

20+"20"
"2020"

Böylece örtülü kalıpların yaratabileceği sorunları ve bunun neden düzeltilebilecek bir şey olmadığını görebilirsiniz. Tartışacağım düzeltme açık dökümler kullanmaktır.