Was ist der Unterschied zwischen statisch typisierten und dynamisch typisierten Sprachen?

Question

Ich höre oft, dass neue Programmiersprachen dynamisch typisiert sind, aber was bedeutet es eigentlich, wenn wir sagen, eine Sprache sei dynamisch typisiert im Gegensatz zu statisch typisiert?

Answer 1

Statisch typisierte Sprachen

Eine Sprache ist statisch typisiert, wenn der Typ einer Variablen zur Kompilierzeit bekannt ist. Bei einigen Sprachen bedeutet dies, dass Sie als Programmierer angeben müssen, welchen Typ jede Variable hat; andere Sprachen (z. B. Java, C, C++) bieten eine Form von Typenzuweisung die Fähigkeit des Typsystems, den Typ einer Variablen abzuleiten (z. B.: OCaml, Haskell, Scala, Kotlin).

Der Hauptvorteil besteht darin, dass alle Arten von Prüfungen vom Compiler durchgeführt werden können und daher viele triviale Fehler in einem sehr frühen Stadium erkannt werden.

Beispiele: C, C++, Java, Rust, Go, Scala

Dynamisch typisierte Sprachen

Eine Sprache ist dynamisch typisiert, wenn der Typ mit Laufzeitwerten verknüpft ist und nicht mit benannten Variablen/Feldern/etc. Das bedeutet, dass Sie als Programmierer etwas schneller schreiben können, weil Sie nicht jedes Mal Typen angeben müssen (es sei denn, Sie verwenden eine statisch typisierte Sprache mit Typenzuweisung ).

Beispiele: Perl, Ruby, Python, PHP, JavaScript, Erlang

Die meisten Skriptsprachen verfügen über diese Funktion, da es ohnehin keinen Compiler gibt, der eine statische Typüberprüfung durchführt. Dennoch kann es vorkommen, dass Sie nach einem Fehler suchen, der darauf zurückzuführen ist, dass der Interpreter den Typ einer Variablen falsch interpretiert. Glücklicherweise sind Skripte in der Regel klein, so dass Bugs nicht so viele Möglichkeiten haben, sich zu verstecken.

Die meisten dynamisch typisierten Sprachen erlauben zwar die Angabe von Typinformationen, verlangen sie aber nicht. Eine Sprache, die derzeit entwickelt wird, Rascal verfolgt einen hybriden Ansatz, der die dynamische Typisierung innerhalb von Funktionen erlaubt, aber die statische Typisierung für die Funktionssignatur erzwingt.

Answer 2

Statisch typisierte Programmiersprachen führen die Typüberprüfung (d. h. den Prozess der Überprüfung und Durchsetzung der Einschränkungen von Typen) bei Kompilierzeit im Gegensatz zu Laufzeit .

Dynamisch typisierte Programmiersprachen führen eine Typüberprüfung bei Laufzeit im Gegensatz zu Kompilierzeit .

Beispiele für statisch typisierte Sprachen sind: Java, C, C++

Beispiele für dynamisch typisierte Sprachen sind: Perl, Ruby, Python, PHP, JavaScript

Answer 3

Hier ein Beispiel, das zeigt, wie Python (dynamisch typisiert) und Go (statisch typisiert) einen Typfehler behandeln:

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

Python führt eine Typüberprüfung zur Laufzeit durch, und daher:

silly(2)

Läuft einwandfrei und erzeugt die erwartete Ausgabe Hi . Der Fehler wird nur ausgelöst, wenn die problematische Zeile getroffen wird:

silly(-1)

Erzeugt

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

weil die betreffende Zeile tatsächlich ausgeführt wurde.

Go hingegen führt eine Typüberprüfung zur Kompilierzeit durch:

package main

import ("fmt"
)

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

func main() {
    silly(2)
}

Das obige Beispiel lässt sich nicht kompilieren und führt zu folgendem Fehler:

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

Answer 4

Einfach ausgedrückt: In einem statisch typisierte Sprache Die Typen der Variablen sind statisch d. h., wenn Sie eine Variable einmal auf einen Typ festgelegt haben, können Sie sie nicht mehr ändern. Das liegt daran, dass die Typisierung mit der Variablen und nicht mit dem Wert verbunden ist, auf den sie sich bezieht.

Zum Beispiel in Java:

String str = "Hello";  // variable str statically typed as string
str = 5;               // would throw an error since str is
                       // supposed to be a string only

Auf der anderen Seite: in einem dynamisch typisierte Sprache Die Typen der Variablen sind dynamisch d.h. nachdem Sie eine Variable auf einen Typ gesetzt haben, können Sie sie ändern. Das liegt daran, dass die Typisierung mit dem Wert verbunden ist, den sie annimmt, und nicht mit der Variablen selbst.

Zum Beispiel in Python:

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

Daher ist es am besten, sich Variablen in dynamisch typisierten Sprachen als nur allgemeine Anhaltspunkte auf getippte Werte.

Zusammengefasst, Typ beschreibt (oder hätte beschreiben sollen) die Variablen in der Sprache und nicht die Sprache selbst. Sie hätte besser verwendet werden können als eine Sprache mit statisch typisierten Variablen gegen eine Sprache mit dynamisch typisierten Variablen IMHO.

Statisch typisierte Sprachen sind in der Regel kompilierte Sprachen, d. h. die Compiler überprüfen die Typen (was durchaus sinnvoll ist, da die Typen zur Laufzeit nicht mehr geändert werden dürfen).

Dynamisch typisierte Sprachen werden im Allgemeinen interpretiert, so dass die Typüberprüfung (wenn überhaupt) zur Laufzeit erfolgt, wenn sie verwendet werden. Dies geht natürlich zu Lasten der Leistung und ist einer der Gründe, warum dynamische Sprachen (z. B. Python, Ruby, PHP) nicht so gut skalieren wie typisierte Sprachen (Java, C# usw.). Aus einem anderen Blickwinkel betrachtet, haben statisch typisierte Sprachen höhere Anlaufkosten: Man muss in der Regel mehr und schwierigeren Code schreiben. Aber das zahlt sich später aus.

Das Gute daran ist, dass beide Seiten Funktionen von der anderen Seite übernehmen. Typisierte Sprachen enthalten mehr dynamische Funktionen, z. B. Generika und dynamische Bibliotheken in c#, und dynamische Sprachen enthalten mehr Typüberprüfungen, z. B. Typ-Annotationen in Python oder die HACK-Variante von PHP, die normalerweise nicht zum Kern der Sprache gehören und bei Bedarf verwendet werden können.

Wenn es um die Auswahl von Technologien geht, ist keine der beiden Seiten per se der anderen überlegen. Es ist lediglich eine Frage der Vorliebe, ob Sie von vornherein mehr Kontrolle oder mehr Flexibilität wünschen. Wählen Sie einfach das richtige Werkzeug für die jeweilige Aufgabe und prüfen Sie, was auf der anderen Seite verfügbar ist, bevor Sie einen Wechsel in Betracht ziehen.

Answer 5

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

Statische Typisierung

Von einer Programmiersprache wird gesagt, dass sie statische Typisierung, wenn die Typüberprüfung während der Kompilierzeit durchgeführt wird als und nicht zur Laufzeit. Bei statischer Typisierung, sind Typen mit Variablen verbunden nicht mit Werten. Statisch typisierte Sprachen sind Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (in Bezug auf die Unterscheidung von Skalare, Arrays, Hashes und Unterroutinen) und Scala. Statische Typisierung ist eine begrenzte Form der Programm Verifikation (siehe Typsicherheit): Dementsprechend ermöglicht sie es, viele Typ Typfehler schon früh im Entwicklungszyklus Entwicklungszyklus erkannt werden. Statische Typ Prüfer werten nur die Typ Informationen, die zur Kompilierzeit ermittelt werden können Kompilierzeit ermittelt werden können, aber sie können überprüfen dass die geprüften Bedingungen gelten für alle möglichen Ausführungsarten des Programms gelten, wodurch die Notwendigkeit entfällt Typprüfungen bei jeder Ausführung des Programm ausgeführt wird. Die Programmausführung kann auch effizienter gestaltet werden (d. h. schneller oder mit weniger Speicherplatz), indem Auslassen von Typprüfungen zur Laufzeit und andere Optimierungen aktiviert werden.

Weil sie Typinformationen auswerten während der Kompilierung auswerten, und daher keine Typinformationen, die nur zur Laufzeit verfügbar sind, sind statische Typ Prüfer konservativ. Sie werden einige Programme zurückweisen, die zwar sich zur Laufzeit gut verhalten, die aber nicht statisch bestimmt werden können, dass sie gut getippt sind. Zum Beispiel, selbst wenn ein Ausdruck immer zur Laufzeit immer als wahr ausgewertet wird, kann ein Programm, das den Code

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

wird als schlecht getippt zurückgewiesen, weil eine statische Analyse nicht feststellen kann dass der else-Zweig nicht ausgeführt wird genommen wird.[1] Das konservative Verhalten von statischen Typüberprüfern ist vorteilhaft, wenn nur selten zu falsch ausgewertet wird: A statischer Typprüfer kann Typfehler Fehler in selten benutzten Codepfaden erkennen. Ohne statische Typprüfung können selbst Codeabdeckungstests mit 100%iger Code Abdeckung nicht in der Lage sein, solche Typfehler zu finden. Codeabdeckungstests können nicht in der Lage sein, solche Typfehler zu erkennen weil die Kombination aus allen Stellen wo Werte erzeugt werden und allen Stellen, an denen ein bestimmter Wert verwendet wird berücksichtigt werden muss.

Die am weitesten verbreitete statisch typisierte Sprachen sind nicht formell typsicher. Sie haben "Schlupflöcher" in der Spezifikation der Programmiersprache die es Programmierern ermöglichen, Code zu schreiben der die Überprüfung umgeht einer statischen Typprüfung umgeht und und so ein breiteres Spektrum von Problemen zu lösen. Zum Beispiel Java und die meisten C-Sprachen Sprachen haben Type Punning, und Haskell hat solche Funktionen wie unsafePerformIO: solche Operationen können zur Laufzeit unsicher sein, da sie unerwünschtes Verhalten verursachen können aufgrund von Typisierung von Werten zur Laufzeit des Programm läuft.

Dynamisches Tippen

Eine Programmiersprache gilt als dynamisch typisiert, oder einfach nur 'dynamisch', wenn der Großteil der Typüberprüfung zur Laufzeit durchgeführt wird, im Gegensatz zu zur Kompilierzeit. Bei dynamischer Typisierung, werden Typen mit Werten und nicht mit Variablen. Dynamisch typisierte Sprachen gehören Groovy, JavaScript, Lisp, Lua, Objective-C, Perl (in Bezug auf benutzerdefinierte Typen, aber nicht eingebaute Typen), PHP, Prolog, Python, Ruby, Smalltalk und Tcl. Im Vergleich zur statischen Typisierung kann die dynamische Typisierung mehr flexibler sein (z. B. indem sie Programmen erlaubt Typen und Funktionalität zu generieren, die auf Laufzeitdaten), allerdings auf Kosten auf Kosten von weniger A-priori-Garantien. Dies liegt daran, dass eine dynamisch typisierte Sprache akzeptiert und versucht einige Programme auszuführen, die bei einer einer statischen Typprüfung als ungültig Prüfer als ungültig eingestuft werden.

Dynamische Typisierung kann zur Laufzeit führen Typisierungsfehlern führen, d.h. zur Laufzeit kann ein Wert einen unerwarteten Typ haben kann, und eine für diesen Typ unsinnige Operation angewendet wird. Diese Operation kann auftreten lange nach der Stelle, an der der Programmierfehler begangen wurde - das heißt, der Stelle, an der der falsche Datentyp Daten an eine Stelle gelangten, die sie nicht hätte. Das macht es schwierig, den Fehler lokalisieren.

Dynamisch typisierte Sprachsysteme, im Vergleich zu ihren statisch typisierten Vettern, weniger "Kompilierzeit"-Prüfungen Überprüfungen des Quellcodes (aber prüfen zum Beispiel, ob das Programm syntaktisch korrekt ist). Während der Laufzeit Überprüfungen können potenziell mehr sein anspruchsvoller sein, da sie sowohl dynamische Informationen sowie alle Informationen, die während der Kompilierung vorhanden waren Kompilierung vorhanden waren. Auf der anderen Seite, Laufzeitprüfungen nur feststellen, dass Bedingungen in einer bestimmten Ausführung des Programms gelten, und diese Prüfungen werden bei jeder Ausführung des Programms wiederholt.

Entwicklung in dynamisch typisierten Sprachen wird oft unterstützt durch Programmierpraktiken wie Unit-Tests Testen. Testen ist eine wichtige Praxis in der professionellen Softwareentwicklung, und ist besonders wichtig bei dynamisch typisierten Sprachen. Unter der Praxis kann das Testen, das zur Sicherstellung korrekten Programmablaufs kann eine eine viel breitere Palette von Fehlern als die statische Typprüfung, kann aber umgekehrt nicht so umfassend nach den Fehlern suchen Fehlern suchen, die sowohl das Testen als auch die statische Typprüfung in der Lage sind, zu erkennen. Das Testen kann in den Software-Erstellungszyklus integriert werden, in diesem Fall als eine "Kompilierzeit"-Prüfung angesehen werden kann Prüfung angesehen werden, da der Programmbenutzer solche Tests nicht manuell ausführen muss.

Referenzen

1. Pierce, Benjamin (2002). Typen und Programmiersprachen. MIT Press. ISBN 0-262-16209-1.