Was ist der Unterschied zwischen statisch typisiert und dynamisch typisierte Sprachen?

StackOverflow https://stackoverflow.com/questions/1517582

Frage

Ich höre viel, dass neue Programmiersprachen sind dynamisch typisierte, aber was bedeutet es eigentlich, wenn wir sagen, dass eine Sprache ist dynamisch typisierte vs.statisch typisiert?

War es hilfreich?

Lösung

Statisch typisierte Sprachen

Eine Sprache eingegeben werden statisch, wenn der Typ einer Variablen zum Zeitpunkt der Kompilierung bekannt ist. Für einige Sprachen Dies bedeutet, dass Sie als der Programmierer angeben, welche jede Variable eingeben muss, ist (z .: Java, C, C ++); andere Sprachen bieten irgendeine Form von Typinferenz , die Fähigkeit des Typs System den Typ einer Variablen (z .: OCaml, Haskell, Scala, Kotlin)

abzuleiten

Der Hauptvorteil dabei ist, dass alle Arten der Überprüfung durch den Compiler durchgeführt werden, und daher viele trivialen Fehler sind in einem sehr frühen Stadium gefangen.

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

dynamisch typisierten Sprachen

Eine Sprache eingegeben werden dynamisch, wenn der Typ mit Laufzeitwerten zugeordnet ist, und nicht die Variablen mit dem Namen / Felder / etc. Dies bedeutet, dass Sie als ein Programmierer ein wenig schneller schreiben kann, weil Sie müssen nicht Typen jedes Mal angeben (es sei denn, eine statisch typisierte Sprache mit mit Typinferenz ).

Beispiele: Perl, Ruby, Python, PHP, JavaScript

Die meisten Skriptsprachen haben diese Funktion, da es keinen Compiler statische Typ-Überprüfung trotzdem zu tun, aber Sie können sich finden Suche für einen Fehler, der dem Interpreter gebührt den Typ einer Variablen falsch interpretiert. Glücklicherweise neigt Skripte klein zu sein, damit Fehler nicht so viele Orte zu verbergen haben.

Die meisten dynamisch typisierten Sprachen erlauben Sie Typinformationen zur Verfügung zu stellen, aber erfordert es nicht. Eine Sprache, die derzeit entwickelt werden, Rascal , nimmt einen hybriden Ansatz ermöglicht dynamische Typisierung innerhalb von Funktionen, sondern die Durchsetzung statischen Typisierung für die Funktion Signatur.

Andere Tipps

Statisch typisierte Sprachen Programmierung Typprüfung zu tun (dh der Prozess der Überprüfung und Durchsetzung der Beschränkungen der Typen) bei Übersetzungszeit im Gegensatz zu Laufzeit .

Dynamisch typisierte Programmiersprachen Art tut Überprüfung in Laufzeit im Gegensatz zu Übersetzungszeit .

Hier ist ein Beispiel kontras wie Python (dynamisch typisierten) und Go (statisch typisiert) einen Typfehler behandeln: 

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

Python tut Typüberprüfung zur Laufzeit, und deshalb: 

silly(2)

Läuft völlig in Ordnung und erzeugt die erwartete Ausgabe Hi. Fehler werden nur ausgelöst, wenn die problematische Zeile getroffen wird: 

silly(-1)

Erzeugt 

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

, da die entsprechende Zeile tatsächlich ausgeführt wurde.

Gehen Sie auf der anderen Seite tut Typ-Prüfung bei der Kompilierung: 

package main

import ("fmt"
)

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

func main() {
    silly(2)
}

Das oben wird nicht kompiliert, mit dem folgenden Fehler: 

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

Es wird einfach so: in einem statisch typisierte Sprache Variablen Typen sind statisch , was bedeutet, wenn Sie eine Variable auf einen Typ festgelegt, Sie können es nicht ändern. Das ist, weil die Eingabe mit der Variablen verbunden ist, eher als der Wert, den es 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

Wo auf der anderen Seite: in einem dynamisch typisierte Sprache Variablen Typen sind dynamische , was bedeutet, wenn Sie eine Variable auf einen Typ festgelegt, Sie können es ändern. Das ist, weil die Eingabe mit dem Wert zugeordnet ist, nimmt sich eher als die Variable selbst.

Zum Beispiel in Python: 

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

So ist es am besten in dynamisch typisierten Sprachen von Variablen zu denken, wie nur generische Zeiger zu typisierten Werten.

Um es zusammenzufassen, Typ beschreibt (oder sollte beschrieben haben), um die Variablen in der Sprache eher als die Sprache selbst. Es besser als eine Sprache mit statisch typisierte Variablen im Vergleich zu eine Sprache mit dynamisch typisierten Variablen IMHO verwendet werden können.

Statisch typisierte Sprachen werden in der Regel Sprachen übersetzt, damit die Compiler die Typen überprüfen (absolut Sinn richtig machen? Als Typen werden später nicht mehr zur Laufzeit geändert werden erlaubt).

Dynamisch typisierte Sprachen im Allgemeinen interpretiert werden, die Überprüfung so geben Sie (falls vorhanden) während der Laufzeit passiert, wenn sie verwendet werden. Dies bringt natürlich einige Performance-Kosten, und ist einer der Gründe, dynamische Sprachen (zum Beispiel Python, Ruby, PHP) nicht so gut wie die typisierte diejenigen skalieren (Java, C #, etc.). Aus einer anderen Perspektive haben statisch typisierten Sprachen mehr von einem Start-up-Kosten: macht in der Regel Sie mehr Code schreiben, härtere Code. Aber das zahlt sich später aus.

Das Gute ist, beide Seiten Features von der anderen Seite borgen. Typisierten Sprachen sind enthalten dynamische Funktionen, zum Beispiel Generika und dynamische Bibliotheken in C # und dynamischen Sprachen sind mehr Typprüfung einschließlich zB Typenannotationen in Python oder HACK Variante von PHP, die in der Regel nicht zum Kern der Sprache und verwendbar Nachfrage.

Wenn es um die Auswahl der Technologie kommt, hat keine der beiden Seiten eine innere Überlegenheit über die andere. Es ist nur eine Frage der Präferenz, ob Sie mehr Kontrolle zu beginnen oder Flexibilität wünschen. Wählen Sie einfach das richtige Werkzeug für den Job, und stellen Sie sicher, zu überprüfen, was in Bezug auf die entgegengesetzte verfügbar ist, bevor ein Schalter unter Berücksichtigung.

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

Statische Typisierung

Eine Programmiersprache ist, sagte zu benutzen die statische Typisierung bei der Typprüfung durchgeführt während der compile-Zeit als im Gegensatz zu run-time.In der statischen Typisierung Typen sind im Zusammenhang mit Variablen nicht Werte.Statisch typisierte Sprachen include Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, Perl (mit Bezug auf die Unterscheidung Skalare, arrays, hashes und Subroutinen) und Scala.Statische Typisierung ist eine eingeschränkte form des Programms überprüfung (siehe Typ Sicherheit):entsprechend, es können viele Art Fehler werden früh gefangen in der Entwicklung Zyklus.Statische Typ Dame bewerten nur die Art Informationen, die bestimmt werden kann compile-Zeit, aber in der Lage sind zu überprüfen , dass die geprüften Bedingungen halten für alle möglichen Ausführungen der Programm, die beseitigt die Notwendigkeit, wiederholen Sie die Art prüft jedes mal die Programm ausgeführt wird.Programm-Ausführung kann auch effizienter gemacht werden (D. H.schneller oder Einnahme reduziert Speicher) durch weglassen-runtime-Typ-Prüfungen und damit andere Optimierungen.

Weil Sie auszuwerten Typ Informationen während der Kompilierung und daher ein Mangel an geben Sie Informationen, die nur zur Laufzeit verfügbar ist, statische Typ Steine sind konservativ.Sie werden lehnen manche Programme, well-behaved at run-time, aber das nicht statisch bestimmt sein gut getippt.Zum Beispiel, auch wenn ein Ausdruck immer zu true ausgewertet wird zur Laufzeit ein das Programm mit dem code

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

abgelehnt werden krank-geschrieben, weil eine statische Analyse kann nicht bestimmen, dass der else-Zweig nicht genommen.[1] Die konservative Verhalten der statische Typ Dame vorteilhaft ist, wenn false selten:Ein static type checker kann erkennen geben Fehler in selten genutzten code-Pfade.Ohne statische Typ-Prüfung, auch code-coverage-tests mit 100% - code Abdeckung möglicherweise nicht in der Lage zu finden, wie geben Sie Fehler.Code-coverage-tests können scheitern, Sie zu erkennen, wie Typ-Fehler weil die Kombination aller Orte wo Werte geschaffen werden und alle Orte, an denen eine bestimmte Wert verwendet wird berücksichtigt werden müssen.

Die am meisten verbreitete statisch typisiert Sprachen sind formal nicht typsicher ist.Sie haben die "Schlupflöcher" in den programming language specification ermöglicht Programmierern, code zu schreiben, das umgeht die überprüfung durchgeführt von einem statischen type checker also-Adresse ein breiteres Spektrum von Problemen.Zum Beispiel, Java und die meisten C-Stil Sprachen haben geben Zweideutigkeiten, und Haskell hat solche Eigenschaften wie unsafePerformIO:solche Operationen kann unsicher bei der Laufzeit,, dass Sie können die Ursache unerwünschten Verhaltens durch fehlerhafte Eingabe von Werten, wenn die Programm läuft.

Dynamische Typisierung

Eine Programmiersprache ist sagte zu werden dynamisch typisierte, oder einfach nur "dynamisch", wenn die Mehrheit der Typ-Prüfung ausgeführt zur Laufzeit, im Gegensatz zu zur compile-Zeit.In der dynamischen Typisierung Typen zugeordnet sind Werte, die nicht Variablen.Dynamisch typisierte Sprachen gehören Groovy, JavaScript, Lisp, Lua, Objective-C, Perl (mit Bezug auf Benutzer-definierte Typen, aber nicht gebaut-in Arten), PHP, Prolog, Python, Ruby, Smalltalk und Tcl.Im Vergleich zu statischen Typisierung, dynamische Typisierung kann mehr flexibel (z.B.indem Programme zu generieren Typen und Funktionen basiert auf run-time-Daten), obwohl bei den Kosten weniger a priori garantiert.Dies ist, weil eine dynamisch typisierte Sprache akzeptiert und versucht, die Ausführung mancher Programme, die können werden regierte als ungültig, die von einem statischen Typ checker.

Dynamische Typisierung kann Ergebnis in runtime Typ Fehler—das ist, wird zur Laufzeit ein Wert kann eine unerwartete Art, und eine operation unsinnige Art angewendet wird.Diese operation kann auftreten lange nach der Stelle, wo die Programmierung Fehler gemacht wurde—, dass ist, der Ort, wo die falsche Art von Daten an einem Ort, sollte es nicht haben.Dies macht die Fehler schwer zu suchen.

Dynamisch typisierte Sprache-Systeme, im Vergleich zu Ihren statisch typisiert cousins, machen Sie weniger "compile-Zeit" Kontrollen auf den source-code (aber wird prüfen Sie beispielsweise, dass das Programm ist syntaktisch korrekt).Run-time Schecks können potentiell mehr anspruchsvoll, denn Sie verwenden können dynamische Informationen sowie alle Informationen, die anwesend war, während Zusammenstellung.Auf der anderen Seite, Laufzeit überprüft nur geltend machen, dass Bedingungen halten, die in einer bestimmten die Ausführung des Programms, und diese Prüfungen wiederholt sich für jede Ausführung des Programms.

Entwicklung in dynamisch typisierten Sprachen ist oft unterstützt von Programmierung Praktiken, wie das Gerät testen.Testen ist ein wichtiger Praxis professionelle software-Entwicklung und besonders wichtig ist in dynamisch typisierte Sprachen.In Praxis-Tests durchgeführt, um sicherzustellen, richtige Arbeit mit dem Programm erkennen kann, die einen viel breitere Palette von Fehlern, die als statische Typ-Prüfung, aber nicht Umgekehrt Suche möglichst umfassend für die Fehler, die sowohl die Prüfung und statische Typ-Prüfung sind in der Lage zu erkennen.Test können integriert werden in die software-build-Zyklus, in welchem Fall es gedacht werden kann, wie ein "compile-Zeit" überprüfen Sie, dass das Programm Benutzer nicht haben, um manuell ausführen von tests.

Referenzen

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

Der Begriff „dynamisch typisierte“ ist leider irreführend. Alle Sprachen sind statisch typisiert und Typen sind Eigenschaften von Ausdrücken (nicht von Werten wie einige denken). Allerdings haben einige Sprachen nur einen Typ. Diese sind uni-typisierten Sprachen genannt. Ein Beispiel für eine solche Sprache ist nicht typisierten Lambda-Kalkül.

In dem nicht typisierten Lambda-Kalkül, alle Begriffe sind Lambda-Ausdrücke, und die einzige Operation, die auf einer Laufzeit durchgeführt werden kann, wird es auf einem anderen Begriff Anwendung. Somit ist alle Operationen zur Folge hat immer in beide unendlichen Rekursion oder einem Lambda-Ausdruck, aber nie ein Fehlersignal.

Wir waren aber die nicht typisierten Lambda-Kalkül mit primitiven Zahlen und arithmetischen Operationen zu erweitern, dann könnten wir unsinnige Operationen durchführen, wie das Hinzufügen von zwei Lambda-Ausdrücke zusammen: (λx.x) + (λy.y). Man könnte argumentieren, dass die einzige vernünftige Sache zu tun ist, um einen Fehler zu signalisieren, wenn dies der Fall ist, aber in der Lage sein, dies zu tun, hat jeder Wert mit einem Indikator markiert werden, der angibt, ob der Begriff eine Lambda-Begriff oder eine Zahl ist. Der Zusatz Betreiber wird dann prüfen, ob in der Tat sind beide Argumente als Zahlen markiert, und wenn sie nicht sind, signalisieren einen Fehler. Beachten Sie, dass diese Tags sind nicht Typen, weil Typen Eigenschaften von Programmen sind, nicht von Werten von diesen Programmen erzeugt werden.

Eine uni-typisierte Sprache, die tut dies genannt wird dynamisch typisiert.

Sprachen wie JavaScript, Python und Ruby sind alle uni-getippt. Auch hier haben die typeof Operator in JavaScript und die type Funktion in Python Namen irreführend; sie kehren die Tags mit den Operanden zugeordnet ist, nicht ihre Typen. In ähnlicher Weise dynamic_cast in C ++ und instanceof in Java tun nicht tun Typprüfungen.

Zusammengestellt vs. Ausgelegt

"Wenn Quellcode übersetzt"

  • Source Code : Original-Code (in der Regel durch einen Menschen in einen Computer eingegeben)
  • Übersetzung : Konvertieren von Quellcode in etwas einen Computer lesen kann (das heißt Maschinencode)
  • Run-Time : Zeitraum, wenn Programm Befehle ausführen (nach der Kompilierung, wenn kompiliert)
  • kompilierte Sprache : Code übersetzt, bevor die Laufzeit
  • interpretierte Sprache : Code on the fly übersetzt, während der Ausführung

Typing

"Wenn Typen geprüft"

5 + '3' ist ein Beispiel eines Typs Fehler in stark typisiert Sprachen wie Go und Python, weil sie nicht zulassen, nicht für „Art Zwang“ -> die Möglichkeit, für einen Wert Änderungstyp in bestimmte Zusammenhänge, wie beispielsweise zwei Arten verschmelzen. schwach typisiert Sprachen wie JavaScript, um nicht einen Typfehler (Ergebnisse in '53') werfen.

  • Static : Typen überprüft, bevor die Laufzeit
  • Dynamische : Typen on the fly geprüft, während der Ausführung

Die Definitionen von „Static & Compiled“ und „Dynamic & Ausgelegt“ sind ziemlich ähnlich ... aber nicht vergessen, es ist „wenn Typen geprüft“ vs. „wenn Quellcode übersetzt“.

Hier finden Sie die gleiche Art Fehler, unabhängig davon, ob die Sprache kompiliert oder interpretiert ! Sie müssen diese Begriffe begrifflich trennen.

Python-Beispiel

Dynamisch, interpretiert 

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

silly(2)

Da Python beide interpretiert und dynamisch typisierte, übersetzt sie nur und Typprüfungen Code es die Ausführung auf. Der else Block nie ausgeführt wird, so wird 5 + '3' noch nie sah!

Was passiert, wenn es wurde statisch typisiert?

Eine Art Fehler würde geworfen werden, bevor der Code selbst ausgeführt wird. Es führt nach wie vor Typ-Prüfung vor der Laufzeit, obwohl es interpretiert wird.

Was passiert, wenn es kompiliert wurde?

Der else Block übersetzt werden würde / sieht vor der Laufzeit, sondern weil es dynamisch typisiert ist wäre es nicht wirft einen Fehler! Dynamisch typisierte Sprachen nicht überprüfen Typen bis zur Ausführung, und diese Linie nie ausgeführt wird.

Go Beispiel

Static, Zusammengestellt 

package main

import ("fmt"
)

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

func main() {
  silly(2)
}

Die Typen werden überprüft vor der Ausführung (statisch) und die Art Fehler wird sofort gefangen! Die Typen würden noch vor der Laufzeit überprüft werden, wenn sie interpretiert wurde, das gleiche Ergebnis haben. Wenn es dynamisch ist, wäre es keine Fehler werfen, obwohl der Code würde während der Kompilierung auf betrachtet werden.

Performance

Eine kompilierte Sprache wird eine bessere Leistung zur Laufzeit haben, wenn sie statisch typisiert ist (im Vergleich zu dynamisch); Kenntnis der Arten ermöglicht Maschinencode-Optimierung.

Statisch typisierte Sprachen eine bessere Leistung zur Laufzeit haben intrinsisch aufgrund benötigen keine Typen dynamisch zu überprüfen, während der Ausführung (es prüft vor der Ausführung).

Ebenso sind kompilierten Sprachen zur Laufzeit schneller als der Code bereits übersetzt wurde statt der Notwendigkeit zu „interpretieren“ / übersetzen on the fly.

Beachten Sie, dass beide kompiliert und statisch typisierten Sprachen wird eine Verzögerung, bevor die Übersetzung ausgeführt und Typüberprüfung sind.

Weitere Unterschiede

Statische Typisierung fängt Fehler früh, anstatt sie während der Ausführung (besonders nützlich für lange Programme) zu finden. Es ist mehr „streng“, dass sie nicht für Typ Fehler überall in Ihrem Programm ermöglicht und verhindert oft Variablen aus wechselnden Typen, die weiter verteidigt gegen unbeabsichtigte Fehler. 

num = 2
num = '3' // ERROR

Dynamische Typisierung ist flexibler, was einige zu schätzen wissen. Es erlaubt der Regel für Variablen Änderungsarten, die in unerwarteten Fehlern führen kann.

Statisch typisierte Sprachen Typprüfung bei der Kompilierung und der Typ kann nicht geändert werden. (Do not nett bekommt mit Typ-Casting Kommentaren, eine neue Variable / Referenz erstellt wird).

Dynamisch typisierte Sprachen Typprüfung zur Laufzeit und der Typ einer Variablen kann zur Laufzeit geändert werden.

Statisch typisierte Sprachen : jede Variable und Ausdruck bereits zum Zeitpunkt der Kompilierung bekannt sind.

(int a; a nur Integer-Typ Werte zur Laufzeit erfolgen kann)

Beispiele: C, C ++, Java

Dynamisch typisierte Sprachen : Variablen unterschiedliche Werte zur Laufzeit erhalten und ihre Art wird zur Laufzeit festgelegt.

(var a; a kann jede Art von Werten zur Laufzeit übernehmen)

. Beispiele: Ruby, Python

Sweet und einfache Definitionen, aber passend die Notwendigkeit: Statisch Sprachen bindet den Typ einer Variablen für die gesamte Umfang getippt (Seg: SCALA) Dynamisch typisierten Sprachen binden die Art auf die durch einen variablen referenzierten Istwert.

  • In einer statisch typisierten Sprache wird eine Variable mit einer Art zugeordnet, die zum Zeitpunkt der Kompilierung bekannt ist, und diese Art bleibt während der Ausführung eines Programms unverändert. In äquivalenter Weise kann die Variable nur einen Wert zugewiesen werden, die eine Instanz des bekannten / angegebenen Typs ist.
  • In einer dynamisch typisierte Sprache, eine Variable keinen Typen hat, und ihr Wert während der Ausführung kann alles von jeder Form und Form sein.

Statisch Sprachen wie C getippt ++, Java und dynamisch typisierten Sprachen wie Python unterscheiden sich nur in Bezug auf die Ausführung des Typs der Variablen.     Statisch typisiert Sprachen statischen Datentyp für die Variable, hier der Datentyp beim Kompilieren so Debuggen aktiviert ist viel einfacher ... während dynamisch typisiert Sprachen nicht tun der gleich, wird der Datentyp die Ausführung des Programms überprüft und damit die Fehlersuche ist etwas schwierig.

Darüber hinaus haben sie einen sehr kleinen Unterschied und können mit stark typisiert und schwach typisiert Sprachen verwendet werden. Eine stark typisierte Sprache ermöglicht es Ihnen nicht einen Typen als ein anderes Beispiel zu verwenden. C und C ++ ... während schwach typisierten Sprachen erlauben eg.python

dynamisch typisierte Sprache hilft ohne den Overhead über das Denken Algorithmus Konzepte schnell zum Prototyp, welche Variablentypen verwendet werden müssen (das ist eine Notwendigkeit in statisch typisiert languag e) .

Static typisierten Sprachen (Compiler Entschlüssen Methodenaufrufe und Kompilierung Referenzen):

  • in der Regel eine bessere Leistung
  • schneller Kompilierungsfehler Feedback
  • bessere IDE-Unterstützung
  • nicht geeignet für nicht definierten Datenformaten arbeiten
  • schwieriger, eine Entwicklung zu starten, wenn das Modell nicht definiert, wenn
  • mehr Kompilierung
  • in vielen Fällen erfordert mehr Code schreiben

Dynamische typisierten Sprachen (Entscheidungen in laufendem Programm):

  • geringere Leistung
  • schnellere Entwicklung
  • einige Fehler möglicherweise erst später in der Laufzeit erfasst werden
  • gut für nicht definierte Datenformate (Meta-Programmierung)

statische Typisierung: Die Sprachen wie Java und Scala sind statisch typisierten.

haben die Variablen definiert und initialisiert werden, bevor sie in einen Code verwendet werden.

für ex. int x; x = 10;

System.out.println (x);

Dynamische Typisierung:  Perl ist eine dynamische typisierte Sprache.

Variablen müssen nicht initialisiert werden, bevor sie in Code verwendet werden.

y = 10; Verwenden Sie diese Variable im späteren Teil des Codes

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top