Bu terimleri programlamada her yerde bantlanmış olarak görüyorum ve ne anlama geldiklerine dair belirsiz bir fikrim var. Bir arama bana aslında bu tür şeylerin tüm yığın taşması istendiğini gösteriyor. Bildiğim kadarıyla dillerde Statik / Dinamik yazım, Güçlü / Zayıf yazımdan oldukça farklıdır, ancak bu farkın beni atlatması. Farklı kaynaklar farklı anlamlar kullanıyor, hatta terimleri birbirinin yerine kullanıyor gibi görünüyor. İkisinden de bahseden ve aslında farkı ortaya koyan bir yer bulamıyorum. Güzel olurdu, eğer birisi bana ve dünyanın geri kalanı için bunu açıkça dile getirebilirse.

• Statik / Dinamik Yazma , tür bilgilerinin ne zaman alınacağı ile ilgilidir (derleme zamanında veya çalışma zamanında)

• Güçlü / Zayıf Yazma , türlerin kesin olarak nasıl ayırt edildiğiyle ilgilidir (örneğin, dilin dizelerden sayılara örtük bir dönüştürme yapmaya çalışıp çalışmadığı).

Daha ayrıntılı bilgi için wiki sayfasına bakın .

Amatörlerin programlama dilleri hakkında konuşmak için kullandıkları terminolojide yumuşak bir nokta keşfettiniz. "Güçlü" ve "zayıf" yazım terimlerini kullanmayın , çünkü teknik anlamda evrensel olarak üzerinde anlaşmaya sahip değildirler. Aksine, statik yazma , programların yürütülmeden önce kontrol edildiği ve bir programın başlatılmadan önce reddedilebileceği anlamına gelir . Dinamik yazma , değer türlerinin yürütme sırasında kontrol edildiği ve kötü yazılmış bir işlemin programın durmasına veya çalışma zamanında bir hataya neden olabileceği anlamına gelir . Statik yazmanın birincil nedeni, bu tür "dinamik tür hataları" olabilecek programları devre dışı bırakmaktır.

Güçlü yazım genellikle yazım sisteminde boşlukların bulunmadığı anlamına gelirken zayıf yazım , yazım sisteminin altüst edilebileceği anlamına gelir (garantileri geçersiz kılar). Terimler genellikle statik ve dinamik yazım anlamında yanlış kullanılır. Farkı görmek için C'yi düşünün: dil derleme zamanında tip kontrol edilir (statik yazım), ancak çok sayıda boşluk vardır; herhangi bir türün değerini hemen hemen aynı boyuttaki başka bir türe atabilirsiniz --- özellikle işaretçi türlerini özgürce yayınlayabilirsiniz. Pascal, güçlü bir şekilde yazılması amaçlanan bir dildi, ancak ünlü olarak öngörülemeyen bir boşluk vardı: etiketi olmayan bir varyant kaydı.

Güçlü yazılan dillerin uygulamaları genellikle zaman içinde boşluklar alır, bu nedenle çalışma zamanı sisteminin bir kısmı yüksek düzey dilde uygulanabilir. Örneğin, Objective Caml adlı bir işlev Obj.magic, sadece argümanını döndürmek için çalışma zamanı etkisi olan bir işleve sahiptir, ancak derleme sırasında herhangi bir türün değerini herhangi bir türden birine dönüştürür. En sevdiğim örnek, tasarımcıları tip döküm yapıları olarak adlandıran Modula-3 LOOPHOLE.

Bunu söyledikten sonra, "güçlü" ve "zayıf" kelimelerini aynı şekilde kullanan iki kişiye güvenemezsiniz. Bu yüzden onlardan kaçının.

Basitçe şu şekilde ifade edin: statik olarak yazılmış bir dilde tür statiktir , yani bir türe bir değişken ayarladıktan sonra değiştiremezsiniz. Bunun nedeni, yazmanın, atıfta bulunduğu değer yerine değişkenle ilişkilendirilmesidir.

Örneğin Java'da:

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

Bir Oysa dinamik Yazılan dili türüdür dinamik bir türü için bir değişken ayarladıktan sonra, yani, bunu değiştirmek CAN. Bunun nedeni, yazmanın değişken yerine değerle ilişkilendirilmesidir.

Örneğin Python'da:

str = "Hello" # it is a string
str = 5       # now it is an integer; perfectly OK

Öte yandan, bir dilde güçlü / zayıf yazım , örtük tür dönüşümleriyle ilgilidir (kısmen @ Dario'nun cevabından alınmıştır):

Örneğin Python'da:

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

PHP'de ise:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

Statik yazma, derleme zamanında tür doğruluğunu kontrol etmenizi sağlar. Statik olarak yazılan diller genellikle derlenir ve dinamik olarak yazılan diller yorumlanır. Bu nedenle, dinamik olarak yazılan diller çalışma zamanında yazmayı denetleyebilir.

Zayıf yazma, bir nesnenin türünün bağlama göre değişebileceği anlamına gelir. Örneğin, zayıf yazılan bir dilde "123" dizesi, başka bir sayı eklerseniz 123 sayısı olarak kabul edilebilir. Yazımı zayıf olan dillere örnek olarak bash, awk ve PHP verilebilir.

Başka bir tür zayıf yazılan dil, bir bellek adresindeki verinin döküm yoluyla farklı bir tür olarak ele alınabildiği C'dir.

Güçlü yazılan bir dilde bir nesnenin türü değişmez - int her zaman bir int'tir ve bunu dize olarak kullanmaya çalışmak hataya neden olur. Hem Java hem de Python güçlü bir şekilde yazılmıştır.

Dinamik ve statik yazım arasındaki fark, tür kurallarının uygulanmasıdır. Statik olarak yazılan bir dilde, her değişken ve parametrenin türü kaynakta bildirilmeli ve derleme zamanında uygulanmalıdır. Dinamik olarak yazılan bir dilde, türler yalnızca çalışma zamanında kullanıldıklarında denetlenir. Java statik olarak yazılır ve Python dinamik olarak yazılır.

Ancak sınırlar zaman zaman biraz bulanık olabilir. Örneğin, Java statik olarak yazılsa da, yansıma veya döküm kullandığınızda (örneğin Nesne kapları kullanırken), tür denetimini çalışma zamanına ertelersiniz.

Benzer şekilde, en güçlü şekilde yazılan diller hala tamsayılar ve kayan noktalar arasında otomatik olarak dönüşür (ve bazı dillerde abitrary duyarlık BigInts).

Bugün bu konuyu araştırırken bu harika makaleye rastladım http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Bir sürü şeyi temizledi benim için bir şeyler ve düşündüm.

Güçlü ve Zayıf Yazma:

Muhtemelen en yaygın tip sistemleri sınıflandırmak "güçlü" veya "zayıf" tır. Bu talihsiz bir durum, çünkü bu kelimelerin neredeyse hiç anlamı yok. Sınırlı bir şekilde, çok benzer tip sistemlere sahip iki dili karşılaştırmak ve bu dili, bu iki sistemden daha güçlü olarak tanımlamak mümkündür. Bunun ötesinde, kelimeler hiçbir şey ifade etmiyor.

Statik ve Dinamik Tipler

Bu, neredeyse gerçek anlamda anlamı olan tip sistemlerin tek ortak sınıflandırmasıdır. Nitekim, önemi genellikle az tahmin edilmektedir [...] Dinamik ve statik tip sistemler, amaçları kısmen çakışan iki tamamen farklı şeydir.

Statik tip sistemi, bir derleyicinin kaynak kodunu incelediği ve sözdiziminin parçalarına etiketler ("türler" olarak adlandırılır) atadığı ve daha sonra bunları programın davranışı hakkında bir şey çıkarmak için kullandığı bir mekanizmadır. Dinamik tip sistem, bir derleyicinin program tarafından kullanılan veri türünü (tesadüfen "tip" de denir) takip etmek için kod ürettiği bir mekanizmadır. Bu iki sistemin her birinde aynı "tip" kelimesinin kullanılması elbette tamamen tesadüf değildir; yine de en iyi anlaşılması, bir tür zayıf tarihsel öneme sahip olmasıdır. Büyük karmaşa, "tip" in her iki sistemde de aynı anlama geldiği bir dünya görüşü bulmaya çalışmaktan kaynaklanıyor. Öyle değil.

Açık / Kapalı Türler:

Bu terimler kullanıldığında, bir derleyicinin bir programın statik parça türleri hakkında ne ölçüde akıl yürüteceği anlamına gelir. Tüm programlama dillerinin türler hakkında bir tür mantığı vardır. Bazılarının diğerlerinden daha fazlası var. ML ve Haskell'in örtülü türleri vardır, çünkü hiçbir (veya kullanılan dile ve uzantılara bağlı olarak çok az sayıda) tür bildirimi gerekli değildir. Java ve Ada'nın çok açık türleri vardır ve biri sürekli olarak şey türlerini bildirir. Yukarıdakilerin tümü (örneğin, nispeten C ve C ++ ile karşılaştırıldığında) güçlü statik tip sistemlere sahiptir.

Scott'ın Programlama Dili Pragmatiği , 3. baskı sayfa 291'den,

Tür denetimi, bir programın dilin tür uyumluluk kurallarına uymasını sağlama işlemidir. Kuralların ihlali, tür çatışması olarak bilinir. Bir dilin, dil uygulamasının zorlayabileceği şekilde, herhangi bir işlemin, söz konusu işlemi desteklemesi amaçlanmayan herhangi bir nesneye uygulanmasını yasaklaması halinde, güçlü bir şekilde yazıldığı söylenir . Bir dil, güçlü bir şekilde yazıldıysa ve derleme zamanında tür denetimi yapılabiliyorsa, statik olarak yazıldığı söylenir . Terimin en katı anlamında, birkaç dil statik olarak yazılmıştır. Pratikte, termis çoğu zaman tip kontrolünün derleme zamanında yapılabileceği ve geri kalanının çalışma zamanında gerçekleştirilebildiği dillere uygulanır.

Birkaç örnek: Ada güçlü bir şekilde yazılmıştır ve çoğunlukla statik olarak yazılmıştır (belirli tür kısıtlamaları çalışma zamanında kontrol edilmelidir). Bir Pascal uygulaması da tür denetiminin çoğunu derleme zamanında yapabilir, ancak dil oldukça güçlü bir şekilde yazılmamıştır: etiketsiz varyant kayıtları (Bölüm 7.3.4'te ele alınacaktır) tek boşluktur. C89, önceki lehçelerinden önemli ölçüde daha güçlü bir şekilde yazılmıştır, ancak yine de Pascal'dan önemli ölçüde daha az güçlü bir şekilde yazılmıştır. Onun boşlukları, değişkenler içeren değişkenler ile alt rutinler ve işaretçiler ile dizilerin birlikte çalışabilirliğini içerir (Bölüm 7.7.1'de ele alınacaktır). C uygulamaları çalışma zamanında nadiren herhangi bir şeyi kontrol eder.

Dinamik (çalışma zamanı) türü denetimi geç bağlama biçimidir ve çalışma zamanına kadar diğer sorunları da geciktiren dillerde bulunur. Lisp ve Smalltalk dinamik olarak (güçlü olsa da) yazılır. Çoğu komut dosyası dili de dinamik olarak yazılır; bazıları (örneğin, Python ve Ruby) kuvvetle yazılmıştır. Dinamik kapsam belirleme özelliğine sahip diller genellikle dinamik olarak yazılır (veya hiç yazılmaz): derleyici bir adın başvurduğu nesneyi tanımlayamazsa, genellikle nesnenin türünü de belirleyemez.

Basit bir ifadeyle, statik / dinamik yazım, yazım denetiminin gerçekleştiği zamanı ifade eder: statik yazım için derleme zamanı ve dinamik diller için çalışma zamanı. Benzer şekilde, güçlü / zayıf yazım, bir dilin kendi tür sistemini uygulamada ne kadar agresif olduğunu ifade eder.

Scott'ın açıklamasını aşağıda yayınladığım güzel bir şemaya çevirmeye çalıştım.

Diğer meslektaşların iyi bir iş çıkardığını düşünüyorum. statik ve dinamik yazım arasındaki farkı açıklar. Ancak, güçlü ve zayıf yazım söz konusu olduğunda, farklı anlayışların / görüşlerin olduğu söylenmelidir.

İşte iki örnek:

• Bazıları Haskell'in güçlü bir şekilde yazıldığını söylüyor, çünkü herhangi bir tür dönüşümü yapmanıza izin verilmiyor .

• Diğerleri (örn. Dario'nun görüşü), zımni olarak dizeden sayıya dolaylı olarak dönüştürülmesine izin veren bir dilin zayıf yazıldığını söyler, ancak diğerleri bile buna sadece ördek yazması der.

Her iki ifade de bir tip sistemin zıt uçlarını değil, tamamen farklı yönleri vurgular. Bu yüzden Bay Ramsey'in tip sistemleri ayırt etmek için "güçlü" ve "zayıf" terimlerini kullanmama görüşüne katılıyorum.

Statik olarak v / s dinamik olarak yazılan diller

• Statik olarak yazılan diller, tür denetiminin derleme zamanında yapıldığı dillerdir, bu da statik olarak yazılan dillerde her değişkenin bir türe sahip olduğu ve kurs boyunca değişmediği anlamına gelir. Şimdi, aksine, dinamik olarak yazılan diller, çalışma zamanında tür denetiminin yapıldığı dillerdir ve derleme zamanında tür denetimi yoktur, bu da dinamik olarak yazılan dillerde değişkenlerle ilişkili bir tür olabileceği veya olmayabileceği anlamına gelir. ve bir tür ilişkilendirilmişse, JS'de hem dize hem de sayı için iyi olan “var” gibi genel bir tür olabilir.
  • “Dinamik olarak tür denetlenen dillerin uygulamaları genellikle her çalışma zamanı nesnesini, tür bilgilerini içeren bir tür etiketi (yani bir türe referans) ile ilişkilendirir. Bu çalışma zamanı türü bilgileri (RTTI) dinamik dağıtım, geç bağlama, aşağı döküm, yansıma ve benzer özellikleri uygulamak için de kullanılabilir. ”
• Dil statik olarak yazılsa bile, yine de dinamik olarak yazılan bir özelliğe sahip olabilir, bu da temel olarak çalışma zamanında bir tür yazım denetimi anlamına gelir. Bu tip dökümünde kullanışlıdır.
  • “Aşağı döküm gibi bazı yararlı ve yaygın programlama dili özellikleri statik olarak kontrol edilemez. Böylece, birçok dilde hem statik hem de dinamik tür denetimi olacaktır; statik tip denetleyicisi ne yapabildiğini doğrular ve dinamik kontroller gerisini doğrular. ”
• “Bazı diller, tür güvenli olmayan kodların yazılmasına izin verir. Örneğin, C'de programcılar aynı boyuta sahip iki tür arasında serbestçe bir değer atabilirler. ”
• “Statik” olarak yazılan dillerin avantajı:
  • Tür denetiminin çoğu derleme zamanında yapıldığından, yorumlayıcı veya çalışma zamanı türler hakkında endişelenmeden tam hızda çalışabilir.
  • Tür denetiminin çoğu derleme zamanında yapıldığından, türle ilgili daha az sayıda çalışma zamanı özel durumu veya hataya yol açar.
• “Dinamik” olarak yazılan dillerin avantajı:
  • Son derece hızlı prototiplemede yardımcı olabilirler, çünkü geliştiricinin tür sistemini anlamaması gerekir, böylece geliştiriciler değişkenleri gevşek bir şekilde oluşturabilir ve çalıştırabilir ve bu çok hızlı prototiplemeye yol açar.
• Statik ve dinamik olarak yazılan dillerin listesi :
  • statik olarak:
    • Java
    • C (C, statik olarak yazılmış bir dildir ancak Java ile karşılaştırıldığında daha az “güçlü” olarak yazılmıştır, çünkü daha örtük dönüşümlere izin verir)
    • C ++
    • C #
  • Dinamik:
    • PERL
    • PHP
    • piton
    • JavaScript
    • Yakut
• Tür denetimi önemli bir güvenlik özelliğidir. Varsayalım, tip kontrolü yok ve bir yöntem “bankAccount” tipinde bir nesneyi “creditAccount (BankAccountDetails)” olarak adlandırılan bir yöntemi kabul ediyor, şimdi çalışma zamanında tip kontrolü yoksa o zaman kendime ait bir nesneyi geçebilirim “creditAccount (BankAccountDetails)” ile aynı yönteme sahip bir sınıftır ve nesne yönelimli dilden bahsettiğimiz göz önüne alındığında, OOP “polimorfizmi” desteklediği ve burada tartıştığımız şey “polimorfizm” den başka bir şey olmadığı düşünülür. Bu nedenle, temel olarak güçlü tip kontrolüne sahip olmayan nesne yönelimli bir dil (temelde “polimorfizmi” desteklediği anlamına gelir) güvenlik sorunlarına yol açabilir.

Güçlü v / s zayıf yazılan diller

• Güçlü yazılan diller, kesinlik kaybı varsa örtük dönüşümlere izin verilmeyen dillerdir. Örneğin, Java'da bir “int to long” atayabilirsiniz çünkü kesinlik kaybı olmaz, ancak kesinlikten “long to int” atamazsınız çünkü kesinlik kaybı olacaktır. Bunun aksine, zayıf yazılan dillerde, kesinlik kaybı olsa bile örtük dönüşümlere izin verilir.
• "Çalışma zamanında" hassaslık kaybı olduğu örtülü dönüşümlere izin vermezse, dinamik olarak yazılan dilin de güçlü bir şekilde yazılmış bir dil olabileceğini düşünüyorum.

İyi okumalar

• Type_system
• Strong_and_weak_typing
• Kategori: Statically_typed_programming_languages
• Kategori: Dynamically_typed_programming_languages

Statik olarak yazılan diller genellikle değişken türlerini bildirmenizi gerektirir; bu da hataları azaltmak için derleme zamanında kontrol edilir. "Statik olarak yazılan" ifadesinde "statik" kelimesi, kodu çalıştırmadan önce kodu inceleme süreci olan "statik kod analizi" anlamına gelir. Statik olarak yazılan bir dilin değişkenin türünü bir ifadenin veya gerçek parametrelerin sağ tarafından çıkarması mümkün olsa da, pratikte statik olarak yazılan çoğu dil değişken türlerinin açıkça bildirilmesini gerektirir.

Dinamik olarak yazılan diller genellikle değişkenlere sahip bildirimler gerektirmez ve her atama deyiminin sağ tarafını veya bir işlev çağrısının gerçek parametrelerini değerlendirmenin sonucu olarak hesaplanan türe göre değişken türleri belirler. Değişken ömrü boyunca birden fazla atama verilebildiğinden, türü zaman içinde değişebilir ve bu nedenle "dinamik olarak yazılır" olarak adlandırılır. Ayrıca, çalışma zamanı ortamının her değişken için geçerli türün kaydını tutması gerekir, bu nedenle tür, değişken bildirimi yerine değere bağlıdır. Bu bir çalışma zamanı tipi bilgi (RTTI) sistemi olarak düşünülebilir.

Statik ve dinamik olarak yazılan dillerin öğeleri birleştirilebilir. Örneğin, C # hem statik hem de dinamik olarak yazılan değişkenleri destekler ve nesneye yönelik diller genellikle tür hiyerarşisini aşağıya çevirmeyi destekler. Statik olarak yazılan diller genellikle döküm, yansıma ve dinamik çağırma gibi tür denetimini atlamak için çeşitli yollar sağlar.

Güçlü ve Zayıf Yazma, bir değişkenin gerçekte başka bir türdeymiş gibi bir tür kullanması nedeniyle dilin hataları önlemeye çalıştığı sürekliliği ifade eder. Örneğin, hem C hem de Java statik olarak yazılan dillerdir, ancak Java C'den daha güçlü bir tür denetimi kullanır. Aşağıdaki C kodu derlemek ve çalıştırmaktan mutluluk duyar ve çalışma zamanında b değişkenine rastgele bir değer koyar, büyük olasılıkla bir hata:

char *a = "123";
int b = (int)a;

Eşdeğer Java kodu, genellikle tercih edilen bir derleme hatası üretir:

String a = "123"
int b = (int)a;