Statik olarak yazılan ve dinamik olarak yazılan diller arasındaki fark nedir?

Yeni programlama dillerinin dinamik olarak yazıldığını çok duyuyorum, ancak bir dilin dinamik olarak yazıldığına veya statik olarak yazıldığına karar verdiğimizde aslında ne anlama geliyor?

Statik olarak yazılan diller

Derleme zamanında bir değişkenin türü biliniyorsa, bir dil statik olarak yazılır. Bazı diller için bu, programcı olarak her değişkenin ne tür olduğunu belirtmeniz gerektiği anlamına gelir (örn: Java, C, C ++); diğer diller bir tür çıkarsama şekli sunarlar , tür sisteminin bir değişkenin türünü çıkarma kabiliyeti (örneğin: OCaml, Haskell, Scala, Kotlin)

Buradaki ana avantaj, her türlü kontrolün derleyici tarafından yapılabilmesidir ve bu nedenle çok erken aşamada birçok önemsiz hata yakalanmaktadır.

Örnekler: C, C ++, Java, Rust, Go, Scala

Dinamik olarak yazılan diller

Tür, çalışma zamanı değerleriyle ilişkilendirilmişse ve değişkenler / alanlar / vb. Olarak adlandırılmamışsa, bir dil dinamik olarak yazılır. Bu, bir programcı olarak biraz daha hızlı yazabileceğiniz anlamına gelir çünkü her seferinde tür belirtmeniz gerekmez ( tür çıkarımlı statik olarak yazılmış bir dil kullanmadıkça ).

Örnekler: Perl, Ruby, Python, PHP, JavaScript

Çoğu komut dosyası dili bu özelliğe sahiptir, çünkü yine de statik tür denetimi yapacak bir derleyici yoktur, ancak bir değişkenin türünü yanlış yorumlayan yorumlayıcının neden olduğu bir hata ararken kendinizi bulabilirsiniz. Neyse ki, komut dosyaları küçük olma eğilimindedir, bu nedenle hataların gizlenecek çok yeri yoktur.

Dinamik olarak yazılan dillerin çoğu, tür bilgisi sağlamanıza izin verir, ancak bunu gerektirmez. Halen geliştirilmekte olan bir dil olan Rascal , işlevler içinde dinamik yazmaya izin veren ancak işlev imzası için statik yazmayı zorunlu kılan karma bir yaklaşım benimser.

Statik olarak yazılan programlama dilleri derleme zamanında çalışma zamanı yerine yazım denetimi yapar (yani türlerin kısıtlamalarını doğrulama ve uygulama süreci) .

Dinamik olarak yazılan programlama dilleri , derleme süresinin aksine çalışma zamanında tür denetimi yapar .

Statik olarak yazılan dillere örnekler: - Java, C, C ++

Dinamik olarak yazılan dillere örnekler: - Perl, Ruby, Python, PHP, JavaScript

Python'un (dinamik olarak yazılan) ve Go'nun (statik olarak yazılan) bir tür hatasını nasıl ele aldığını gösteren bir örnek:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

Python çalışma zamanında yazım denetimi yapar ve bu nedenle:

silly(2)

Mükemmel çalışır ve beklenen çıktıyı üretir Hi. Hata yalnızca sorunlu çizgiye isabet edildiğinde ortaya çıkar:

silly(-1)

üretir

TypeError: unsupported operand type(s) for +: 'int' and 'str'

çünkü ilgili satır gerçekte yürütüldü.

Öte yandan derleme zamanında tip kontrolü yapar:

package main

import ("fmt"
)

func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}

func main() {
    silly(2)
}

Yukarıdakiler aşağıdaki hatayla derlenmeyecektir:

invalid operation: "3" + 5 (mismatched types string and int)

Basitçe şu şekilde ifade edin: statik olarak yazılan bir dilde, değişkenlerin türleri statiktir , yani bir değişkeni bir türe 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";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

Diğer yandan: dinamik olarak yazılan bir dilde değişkenlerin türleri dinamiktir , yani bir türe bir değişken ayarladıktan sonra onu değiştirebilirsiniz. Bunun nedeni, yazmanın değişkenin kendisinden ziyade üstlendiği değerle ilişkili olmasıdır.

Örneğin Python'da:

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

Bu nedenle, dinamik olarak yazılan dillerdeki değişkenleri yalnızca yazılan değerlere genel işaretçiler olarak düşünmek en iyisidir .

Özetle, tip yerine dil dilin kendisi değişkenler açıklanmaktadır (ya da tarif olmalıdır). Dinamik olarak yazılan değişkenlere sahip bir dile karşı IMHO ile statik olarak yazılan değişkenlere sahip bir dil olarak daha iyi kullanılabilirdi .

Statik olarak yazılan diller genellikle derlenmiş dillerdir, bu nedenle derleyiciler türleri kontrol eder (tiplerin daha sonra çalışma zamanında değiştirilmesine izin verilmediğinden doğru mantıklı mı?).

Dinamik olarak yazılan diller genellikle yorumlanır, bu nedenle tür denetimi (varsa) kullanıldıkları zaman çalışma zamanında gerçekleşir. Bu elbette bazı performans maliyetleri getirir ve dinamik dillerin (örneğin, python, ruby, php) yazılanlar kadar iyi ölçeklenmemesinin nedenlerinden biridir (java, c #, vb.). Başka bir perspektiften bakıldığında, statik olarak yazılan diller daha fazla başlangıç ​​maliyetine sahiptir: genellikle daha fazla kod, daha zor kod yazmanızı sağlar. Ama bu daha sonra işe yarar.

İyi olan şey, her iki tarafın diğer taraftan borçlanma özellikleri olmasıdır. Yazılan diller, c # içindeki jenerikler ve dinamik kütüphaneler gibi daha dinamik özellikler içerir ve dinamik diller daha fazla tür denetimi içerir, örneğin, python'daki tür ek açıklamaları veya genellikle dilin çekirdeği olmayan ve üzerinde kullanılabilen HACK varyantı talep ediyoruz.

Teknoloji seçimi söz konusu olduğunda, her iki tarafın diğerine göre içsel bir üstünlüğü yoktur. Daha fazla kontrolün başlamasını veya esnekliğini istemek sadece bir tercih meselesidir. sadece iş için doğru aleti seçin ve bir anahtarı düşünmeden önce tam tersi olarak neyin mevcut olduğunu kontrol ettiğinizden emin olun.

http://en.wikipedia.org/wiki/Type_system

Statik yazma

Bir programlama dilinin çalışma zamanı yerine derleme zamanı sırasında tip denetimi yapıldığında statik yazmayı kullandığı söylenir. Statik yazımda, türler değerlerle değil değişkenlerle ilişkilendirilir. Statik olarak yazılan diller arasında Ada, C, C ++, C #, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (skaler, diziler, karma ve alt rutinleri ayırt etme açısından) ve Scala bulunur. Statik yazım sınırlı bir program doğrulaması biçimidir (tür güvenliğine bakın): buna göre, birçok tür hatasının geliştirme döngüsünde erken yakalanmasına izin verir. Statik tip denetleyicileri yalnızca derleme zamanında belirlenebilen tür bilgilerini değerlendirir, ancak denetlenen koşulların programın tüm olası yürütmeleri için geçerli olduğunu doğrulayabilir, bu da program her yürütüldüğünde tip kontrollerinin tekrarlanması ihtiyacını ortadan kaldırır. Program yürütme, çalışma zamanı türü denetimlerini atlayarak ve diğer optimizasyonları etkinleştirerek de daha verimli hale getirilebilir (yani daha hızlı veya daha az bellek alarak).

Derleme sırasında tür bilgilerini değerlendirdikleri ve bu nedenle yalnızca çalışma zamanında kullanılabilen tür bilgilerinin bulunmadığı için statik tür denetleyicileri muhafazakar. Çalışma zamanında iyi davranmış olabilecek, ancak iyi yazıldığı statik olarak belirlenemeyen bazı programları reddedeceklerdir. Örneğin, bir ifade çalışma zamanında her zaman true olarak değerlendirilse bile, kodu içeren bir program

if <complex test> then 42 else <type error>

statik bir analiz diğer dalın alınmayacağını belirleyemediğinden, kötü yazılan olarak reddedilir. [1] Statik tip denetleyicilerin konservatif davranışı, seyrek olarak yanlış değerlendirildiğinde avantajlıdır: Statik tip denetleyici, nadiren kullanılan kod yollarındaki tür hatalarını algılayabilir. Statik tip kontrolü olmadan,% 100 kod kapsamına sahip kod kapsam testleri bile bu tür hataları bulamayabilir. Kod kapsamı testleri, türlerin oluşturulduğu tüm yerlerin ve belirli bir değerin kullanıldığı tüm yerlerin kombinasyonu dikkate alındığından, bu tür hataları algılayamayabilir.

En yaygın olarak kullanılan statik olarak yazılan diller resmi olarak güvenli değildir. Programlama dili belirtimlerinde programcıların statik tip denetleyicisi tarafından gerçekleştirilen doğrulamayı çevreleyen kod yazmalarını ve böylece daha geniş bir yelpazedeki sorunları ele almalarını sağlayan "boşluklar" vardır. Örneğin, Java ve çoğu C stili dilde punning türü vardır ve Haskell, unsafePerformIO gibi özelliklere sahiptir: bu tür işlemler, program çalışırken değerlerin yanlış yazılması nedeniyle istenmeyen davranışlara neden olabilmeleri için çalışma zamanında güvensiz olabilir.

Dinamik yazma

Bir programlama dilinin dinamik olarak yazıldığı ya da tür denetiminin çoğunun derleme zamanında aksine çalışma zamanında gerçekleştirildiği zaman sadece 'dinamik' olduğu söylenir. Dinamik yazarken, türler değişkenlerle değil değerlerle ilişkilendirilir. Dinamik olarak yazılan diller arasında Groovy, JavaScript, Lisp, Lua, Objective-C, Perl (kullanıcı tanımlı türlere göre ancak yerleşik türlere göre), PHP, Prolog, Python, Ruby, Smalltalk ve Tcl bulunur. Statik yazmayla karşılaştırıldığında, dinamik yazma daha esnek olabilir (örneğin, programların çalışma zamanı verilerine dayalı türler ve işlevsellik üretmesine izin vererek), ancak daha az a priori garantisi pahasına. Bunun nedeni, dinamik olarak yazılan bir dilin statik tür denetleyicisi tarafından geçersiz olarak yönetilebilecek bazı programları kabul etmesi ve yürütmeye çalışmasıdır.

Dinamik yazım, çalışma zamanı türü hatalarına neden olabilir; yani çalışma zamanında bir değer beklenmeyen bir türe sahip olabilir ve bu tür için saçma bir işlem uygulanır. Bu işlem, programlama hatasının yapıldığı yerden, yani yanlış türde verinin olmaması gereken bir yere geçtiği yerden çok sonra gerçekleşebilir. Bu, hatanın bulunmasını zorlaştırır.

Dinamik olarak yazılan dil sistemleri, statik olarak yazılan kuzenleriyle karşılaştırıldığında, kaynak kodunda daha az "derleme zamanı" denetimi yapar (ancak örneğin programın sözdizimsel olarak doğru olup olmadığını kontrol eder). Çalışma zamanı denetimleri potansiyel olarak daha karmaşık olabilir, çünkü derleme sırasında mevcut olan bilgilerin yanı sıra dinamik bilgileri de kullanabilirler. Öte yandan, çalışma zamanı denetimleri yalnızca programın belirli bir yürütmesinde koşulların geçerli olduğunu iddia eder ve bu denetimler programın her yürütülmesi için tekrarlanır.

Dinamik olarak yazılan dillerde geliştirme, genellikle birim testi gibi programlama uygulamaları tarafından desteklenir. Test, profesyonel yazılım geliştirmede önemli bir uygulamadır ve özellikle dinamik olarak yazılmış dillerde önemlidir. Uygulamada, doğru program çalışmasını sağlamak için yapılan testler, statik tip kontrolünden çok daha geniş bir hata aralığını tespit edebilir, ancak tersine, hem testin hem de statik tip kontrolünün tespit edebileceği hataları kapsamlı bir şekilde arayamaz. Test, yazılım oluşturma döngüsüne dahil edilebilir, bu durumda program kullanıcısının bu tür testleri manuel olarak yürütmesi gerekmeyecek şekilde "derleme zamanı" kontrolü olarak düşünülebilir.

Referanslar

1. Pierce, Benjamin (2002). Türleri ve Programlama Dilleri. MIT tuşuna basın. ISBN 0-262-16209-1.

"Dinamik olarak yazılan" terminolojisi ne yazık ki yanıltıcıdır. Tüm diller statik olarak yazılmıştır ve türleri ifadelerin özellikleridir (bazılarının düşündüğü gibi değerlerden değil). Ancak, bazı dillerin yalnızca bir türü vardır. Bunlara tek tip diller denir. Böyle bir dilin bir örneği türlenmemiş lambda hesabıdır.

Türlenmemiş lambda hesabında, tüm terimler lambda terimleridir ve bir terim üzerinde gerçekleştirilebilecek tek işlem, onu başka bir terime uygulamaktır. Bu nedenle, tüm işlemler daima sonsuz özyineleme veya lambda terimi ile sonuçlanır, ancak asla bir hataya işaret etmez.

Bununla birlikte, o zaman saçma işlemleri gerçekleştirebilir, ilkel sayı ve aritmetik işlemlerle Türlenmemiş lambda taşı takviye edildi, bu arada iki lambda terimler ekleyerek: (λx.x) + (λy.y). Yapılması gereken tek akıllıca şeyin bu olduğunda bir hataya işaret etmek olduğunu iddia edebilir, ancak bunu yapabilmek için her bir değerin, terimin lambda terimi mi yoksa sayı mı olduğunu gösteren bir gösterge ile etiketlenmesi gerekir. Toplama operatörü daha sonra her iki argümanın da sayı olarak etiketlendiğini kontrol eder ve eğer değilse, bir hata sinyali verir. Bu etiketlerin tür olmadığına dikkat edin , çünkü türler programların özellikleri, bu programlar tarafından üretilen değerlerin değil.

Bunu yapan benzersiz bir dile dinamik olarak yazılır.

JavaScript, Python ve Ruby gibi tüm diller tek tiplidir. Yine, typeofJavaScript'teki işleç ve typePython'daki işlevin yanıltıcı isimleri vardır; türleriyle değil, işlenenlerle ilişkili etiketleri döndürürler. Benzer şekilde, dynamic_castC ++ ve instanceofJava do not tip kontrolleri yapmak.

Derlenmiş ve Yorumlanmış

"Kaynak kodu çevrildiğinde"

• Kaynak Kod : Orijinal kod (genellikle bir insan tarafından bilgisayara yazılır)
• Çeviri : Kaynak kodunu bilgisayarın okuyabileceği bir şeye dönüştürme (yani makine kodu)
• Çalışma Zamanı : Programın komutları yürütme süresi (derlendikten sonra, derlenmişse)
• Derlenen Dil : Çalışma zamanından önce çevrilen kod
• Yorumlanan Dil : Uygulama sırasında anında tercüme edilen kod

Yazıyor

"Türler kontrol edildiğinde"

5 + '3'Go ve Python gibi güçlü yazılan dillerde bir yazım hatası örneğidir , çünkü "tür baskısı" na izin vermezler -> iki türün birleştirilmesi gibi belirli bağlamlarda bir değerin türü değiştirme yeteneği. JavaScript gibi zayıf yazılan diller tür hatası vermez (sonuç verir '53').

• Statik : Çalışma zamanından önce kontrol edilen türler
• Dinamik : Çalıştırma sırasında anında kontrol edilen türler

"Statik ve Derlenmiş" ve "Dinamik ve Yorumlanmış" tanımları oldukça benzerdir ... ancak kaynak kodları çevrildiğinde "türler kontrol edildiğinde" vs. "olduğunu unutmayın.

Dilin derlenmesine veya yorumlanmasına bakılmaksızın aynı tür hatalar alırsınız ! Bu terimleri kavramsal olarak ayırmanız gerekir.

Python Örneği

Dinamik, Yorumlanmış

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

silly(2)

Python hem yorumlandığında hem de dinamik olarak yazıldığından, yalnızca yürütmekte olduğu kodu çevirir ve yazım denetimi yapar. elseYürütür asla blok, bu yüzden 5 + '3'bile baktı asla!

Statik olarak yazılmış olsaydı ne olurdu?

Kod çalıştırılmadan önce bir tür hatası atılır. Yorumlanmasına rağmen çalışma zamanından önce hala tip denetimi gerçekleştirir.

Derlenmişse ne olacak?

elseBlok / tercüme çalışma saatinden önce baktım ama dinamik yazılan çünkü o hata atmak olmaz olurdu! Dinamik olarak yazılan diller yürütme yapılana kadar türleri denetlemez ve bu satır hiçbir zaman yürütülmez.

Git Örneği

Statik, Derlenmiş

package main

import ("fmt"
)

func silly(a int) {
  if (a > 0) {
      fmt.Println("Hi")
  } else {
      fmt.Println("3" + 5)
  }
}

func main() {
  silly(2)
}

Tipler çalıştırmadan önce kontrol edilir (statik) ve tip hatası hemen yakalanır! Türler, aynı sonuca sahip olarak yorumlanırsa, çalışma zamanından önce hala kontrol edilir. Dinamik olsaydı, derleme sırasında koda bakılsa bile herhangi bir hata atmazdı.

Verim

Derlenmiş bir dil, statik olarak yazıldıysa (dinamik olarak) çalışma zamanında daha iyi performans gösterir; tür bilgisi makine kodu optimizasyonu sağlar.

Statik olarak yazılan diller, yürütme sırasında türleri dinamik olarak kontrol etmeleri gerekmediği için çalışma zamanında kendinden daha iyi performansa sahiptir (çalıştırmadan önce kontrol eder).

Benzer şekilde, derlenmiş diller çalışma sırasında daha hızlıdır, çünkü kod anında tercüme edilmiş / tercüme edilmesine gerek yoktur.

Hem derlenmiş hem de statik olarak yazılan dillerin, çeviri ve yazım denetimi için çalıştırmadan önce bir gecikme olacağını unutmayın.

Daha Fazla Fark

Statik yazım, yürütme sırasında bulmak yerine hataları erken yakalar (özellikle uzun programlar için yararlıdır). Programınızın hiçbir yerinde yazım hatalarına izin vermeyeceği ve değişkenlerin tür değiştirmesini önlediği için istenmeyen hatalara karşı daha fazla savunması daha katıdır.

num = 2
num = '3' // ERROR

Dinamik yazma daha esnektir, bazıları takdir eder. Genellikle değişkenlerin türleri değiştirmesine izin verir, bu da beklenmedik hatalara neden olabilir.

Statik olarak yazılan diller : her değişken ve ifade derleme zamanında zaten bilinir.

( int a;a çalışma zamanında yalnızca tamsayı türü değerleri alabilir)

Örnekler: C, C ++, Java

Dinamik olarak yazılan diller : değişkenler çalışma zamanında farklı değerler alabilir ve türleri çalışma zamanında tanımlanır.

( var a;a çalışma zamanında her türlü değeri alabilir)

Örnekler: Ruby, Python.

Statik olarak yazılan diller derleme zamanında yazım denetimi yapar ve tür DEĞİŞTİRİLEMEZ. (Yazım yorumlarıyla sevimli olmayın, yeni bir değişken / referans oluşturulur).

Dinamik olarak yazılan diller çalışma zamanında yazım denetimi ve bir değişkenin türü çalışma zamanında değiştirilebilir.

Tatlı ve basit tanımlar, ancak ihtiyaca cevap verir: Statik olarak yazılan diller, türü tüm kapsamı için bir değişkene bağlar (Seg: SCALA) Dinamik olarak yazılan diller, türü bir değişkenin başvurduğu gerçek değere bağlar.

• Statik olarak yazılan bir dilde, bir değişken derleme zamanında bilinen bir türle ilişkilendirilir ve bu tür bir programın yürütülmesi boyunca değişmeden kalır. Aynı şekilde, değişkene yalnızca bilinen / belirtilen türün bir örneği olan bir değer atanabilir.
• Dinamik olarak yazılan bir dilde, bir değişkenin türü yoktur ve yürütme sırasında değeri herhangi bir şekil ve biçimde olabilir.

C ++, Java gibi statik olarak yazılan diller ve Python gibi dinamik olarak yazılan diller yalnızca değişken türünün yürütülmesi açısından farklılık gösterir. Statik olarak yazılan diller burada veri türü ayıklama çok daha kolaydır böylece oysa ... derleme sırasında kontrol edilir, değişkenin statik veri türüne sahip Dinamik yazdığınız aynı yapmayın dilleri, veri tipi kontrol edildiği dolayısıyla program ve yürütme hata ayıklama biraz zor.

Dahası, çok küçük bir farkları vardır ve kuvvetli ve zayıf tiplerle ilişkilendirilebilirler. dillerle ilişkilendirilebilirler. Güçlü yazılan bir dil bir türü diğeri gibi kullanmanıza izin vermez. C ve C ++ ... zayıf yazılan diller örn.

Statik Olarak Yazılmış

Türler çalışma zamanından önce kontrol edilir, böylece hatalar daha erken yakalanabilir.

Örnekler = c ++

Dinamik Olarak Yazılmış

Türler yürütme sırasında kontrol edilir.

Örnekler = Python

Statik yazılan diller (derleyici yöntem çağrılarını çözer ve başvuruları derler):

• genellikle daha iyi performans
• daha hızlı derleme hatası geri bildirimi
• daha iyi IDE desteği
• tanımlanmamış veri formatlarıyla çalışmaya uygun değil
• zaman modeli tanımlanmadığında bir geliştirme başlatmak daha zor
• daha uzun derleme süresi
• çoğu durumda daha fazla kod yazmayı gerektirir

Dinamik yazılan diller (çalışan programda alınan kararlar):

• düşük performans
• daha hızlı gelişme
• bazı hatalar ancak daha sonra çalışma zamanında tespit edilebilir
• tanımlanmamış veri formatları için iyi (meta programlama)

dinamik olarak yazılan dil , hangi değişken türlerinin kullanılması gerektiğini düşünmeden ( statik olarak yazılan dilde bir zorunluluktur) algoritma kavramlarını hızlı bir şekilde prototiplemeye yardımcı olur .

Statik Yazma: Java ve Scala gibi diller statik yazılmıştır.

Değişkenler bir kodda kullanılmadan önce tanımlanmalı ve başlatılmalıdır.

örneğin. int x; x = 10;

System.out.println (x);

Dinamik Yazma: Perl dinamik yazılan bir dildir.

Değişkenlerin kodda kullanılmadan önce başlatılması gerekmez.

y = 10; kodun sonraki bölümünde bu değişkeni kullan