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

Statisch typisierte Sprachen

Eine Sprache ist statisch typisiert, wenn der Typ einer Variablen zur Kompilierzeit bekannt ist. Für einige Sprachen dies bedeutet, dass Sie als Programmierer muss angeben, welchen Typ die einzelnen Variablen ist (z.B.: Java, C, C++); andere Sprachen bieten irgendeine form von Typ-Inferenzwird die Fähigkeit des Typ-Systems, Rückschlüsse auf die Art einer variable (z.B.: OCaml, Haskell, Scala, Kotlin)

Der Hauptvorteil ist hier, dass alle Arten von Prüfung erfolgt durch den compiler, und daher viele triviale Fehler sind gefangen in einem sehr frühen Stadium.

Dynamisch typisierte Sprachen

Einer Sprache ist dynamisch typisiert, wenn der Typ verbunden ist mit der run-time-Werte, und nicht benannte Variablen/Felder/usw. Dies bedeutet, dass Sie als Programmierer schreiben, ein wenig schneller, da Sie nicht angeben, Arten jeder Zeit (es sei denn Sie verwenden eine statisch typisierte Sprache mit Typ-Inferenz).
Beispiel: Perl -, Ruby -, Python -

Meisten scripting-Sprachen haben dieses feature, da es keine compiler eine statische Typprüfung sowieso, aber Sie können finden sich auf der Suche nach einem Fehler, der aufgrund der interpreter falsch interpretiert den Typ einer Variablen. Zum Glück, Skripte tendenziell zu klein sein, damit bugs haben nicht so viele Orte zu verstecken.

Meisten dynamisch typisierte Sprachen können Sie bieten geben Informationen, aber nicht erforderlich. Eine Sprache, die zurzeit entwickelt werden, Rackernimmt einen hybrid-Ansatz ermöglicht dynamische Typisierung innerhalb der Funktionen, sondern die Durchsetzung der statischen Typisierung wird für die Funktion Unterschrift.

InformationsquelleAutor der Antwort NomeN

Hier ist ein Beispiel kontrastierenden wie Python (dynamisch typisiert) und Gehen (statisch typisiert) Griff eine Art Fehler:

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

Python macht die Typüberprüfung zur Laufzeit, und daher:

silly(2)

Läuft einwandfrei, und erzeugt die erwartete Ausgabe Hi. Fehler werden nur erhoben, wenn Sie die problematische Zeile ist der hit:

silly(-1)

Produziert

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

weil die entsprechende Zeile tatsächlich ausgeführt wird.

Gehen auf der anderen Seite hat Typprüfung zur compile-Zeit:

package main

import ("fmt"
)

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

func main() {
    silly(2)
}

Die oben nicht kompilieren, mit folgender Fehlermeldung:

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

InformationsquelleAutor der Antwort Akavall

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

Statische Typisierung

Einer Programmiersprache ist sagte
die statische Typisierung bei der Typprüfung
erfolgen während der compile-Zeit als
im Gegensatz zu run-time. In der statischen Typisierung
Arten sind mit Variablen assoziiert
nicht Werte. Statisch typisierte Sprachen
gehören 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
Prüfung (type safety):
entsprechend, es erlaubt viele
Fehler werden früh gefangen in der
Entwicklungszyklus. Statischen Typ
Steine bewerten nur die Art
Informationen, die bestimmt werden kann
compile-Zeit, sondern sind in der Lage, um zu überprüfen,
dass die geprüften Bedingungen halten
alle möglichen Ausführungen der
das Programm, die beseitigt die Notwendigkeit zu
wiederholen Sie die Typ-Prüfungen jedes mal die
das Programm wird ausgeführt. Die Ausführung des Programms
kann auch effizienter gemacht werden (D. H.
schneller oder Einnahme reduziert Speicher) von
weglassen Laufzeit typüberprüfungen und
Ermöglichung anderer Optimierungen.

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

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

werden abgelehnt, wie schlecht getippt, weil
eine statische Analyse kann nicht bestimmen
dass der else-Zweig nicht
genommen.[1] Die konservative Verhalten
der statische Typ-checker ist
vorteilhaft ist, wenn
zu false ausgewertet selten: Ein
statische type checker können 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
Typ Fehler. Code-coverage-tests können
scheitern, um zu erkennen, wie Typ-Fehler
weil die Kombination aller Orten
wo Werte geschaffen werden und alle
Orte, an denen ein bestimmter Wert verwendet wird
muss berücksichtigt werden.

Die am meisten verbreitet sind statisch typisiert
Sprachen sind formal nicht Typ-sicher.
Sie haben "Lücken" in der
programming language specification
ermöglicht Programmierern, um code zu schreiben
das umgeht die überprüfung
durchgeführt durch eine statische type checker und
so-Adresse ein breiteres Spektrum von Problemen.
Zum Beispiel, Java und die meisten C-Stil
Sprachen vom Typ Zweideutigkeiten, und
Haskell hat solche Eigenschaften wie
unsafePerformIO: solche Operationen kann
unsicher bei der Laufzeit, dass Sie
unerwünschte Verhalten aufgrund von
inkorrekte Eingabe von Werten bei der
Programm läuft.

Dynamische Typisierung

Einer Programmiersprache ist gesagt zu werden
dynamisch typisierte, oder einfach nur "dynamisch",
wenn die Mehrheit der Typ-überprüfung
erfolgt zur Laufzeit im Gegensatz zu
zur compile-Zeit. In dynamischen Typisierung
Typen sind die zugeordneten Werte nicht
Variablen. Dynamisch typisierte Sprachen
zählen Groovy, JavaScript, Lisp, Lua,
Objective-C, Perl (mit Bezug auf
Benutzer-definierte Typen, aber nicht gebaut-in
Typen), PHP, Prolog, Python, Ruby,
Smalltalk und Tcl. Im Vergleich zu statischen
Typisierung dynamische Typisierung kann mehr
flexibel (z.B. durch zulassen von Programmen auf
generieren Typen und Funktionalität, basierend
auf run-time-Daten), obwohl an der
Kosten von weniger a priori garantiert.
Dies ist, weil eine dynamisch typisierte
Sprache akzeptiert und versucht zu
die Ausführung mancher Programme, die möglicherweise
regierte als ungültig von einem statischen Typ
checker.

Dynamische Typisierung kann Ergebnis in runtime
geben Sie Fehler zu—das heißt, zur Laufzeit ein
Wert kann eine unerwartete Art und
eine operation unsinnig für diesen Typ
angewendet wird. Dieser Vorgang kann auftreten
lange nach dem Ort, wo die
Programmierung Fehler gemacht wurde—das ist,
der Ort, wo die falschen Datentyp
an einem Ort, es sollte nicht
haben. Dies macht den Fehler schwer zu
suchen.

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

Entwicklung in dynamisch typisierten
Sprachen wird oft unterstützt durch
Programmierung Praktiken wie unit
testen. Testen ist ein wichtiger Praxis
professionelle software-Entwicklung und
besonders wichtig ist in
dynamisch typisierte Sprachen. In
Praxis werden die Tests durchgeführt, um sicherzustellen,
richtige Arbeit mit dem Programm erkennen kann eine
viel breitere Palette von Fehlern, die als statische
Typ-geprüft werden, aber Umgekehrt nicht
Suche möglichst umfassend für die
Fehler, die beiden Tests und statische
Typ-überprüfung in der Lage sind, zu erkennen.
Tests können eingebaut werden
software-build-Zyklus, in welchem Fall es
kann gedacht werden als ein "compile-Zeit"
überprüfen Sie, daß der Programm-Benutzer wird
nicht manuell ausführen eines solchen tests.

Referenzen

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

InformationsquelleAutor der Antwort Jacob

Statisch typisierte Sprachen Typ-check zur compile-Zeit und der Typ kann sich NICHT ändern. (Don ' T get cute mit Typ-casting-Kommentare, eine neue variable/Referenz wird erstellt).

Dynamisch typisierte Sprachen Typ-check zur Laufzeit und der Typ einer Variablen KANN zur Laufzeit geändert werden.

InformationsquelleAutor der Antwort RESTfulGeoffrey

Kompiliert vs. Interpretiert

", Wenn source-code übersetzt wird"

• Quellcode: Original-code (in der Regel typisierte, von einem Menschen in einen computer)
• Übersetzung: Konvertierung von source-code in etwas, das ein computer Lesen kann (also Maschinencode)
• Laufzeit: Zeitraum, wenn das Programm ausgeführt wird, Befehle (nach dem kompilieren, wenn zusammengestellt)
• Kompilierte Sprache: Code übersetzt, bevor der run-time -
• Interpretierte Sprache: Code übersetzt on-the-fly während der Ausführung

Eingabe

"Wenn Arten überprüft werden"

5 + '3' ist ein Beispiel für eine Art Fehler in stark typisierte Sprachen wie Go und Python, weil Sie nicht zulassen, für "Art Zwang" -> die Fähigkeit, einen Wert zu ändern, geben Sie in bestimmten Kontexten, wie das Zusammenführen von zwei Arten. Schwach typisierte Sprachen, wie JavaScript, wird nicht werfen eine Art Fehler (Ergebnisse in '53').

• Statische: Typen überprüft, bevor der run-time -
• Dynamische: Arten überprüft on-the-fly während der Ausführung

Den Definitionen von "Static & Zusammengestellt" und "Dynamik & Interpretiert" sind sich ziemlich ähnlich...aber denken Sie daran, es ist "als Arten überprüft werden" vs. "wenn source-code übersetzt wird".

Erhalten Sie die gleichen Fehler, unabhängig davon, ob die Sprache kompiliert oder interpretiert! Sie müssen trennen Sie diese Bedingungen konzeptionell.

Python-Beispiel

Dynamisch, Interpretiert

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

silly(2)

Weil Python interpretierte und dynamisch typisierte, es nur übersetzt und Typ-Prüfungen-code ausgeführt wird. Die else block wird nie ausgeführt, so 5 + '3' ist nicht einmal angeschaut!

Was ist, wenn es war statisch typisiert?

Einen Typ-Fehler geworfen werden, bevor der code auch ausgeführt wird. Es noch führt Typ-überprüfung vor der Laufzeit-auch wenn es interpretiert wird.

Was ist, wenn es kompiliert wurde?

Den else block übersetzt werden würde/angeschaut, bevor der run-time, aber, weil es dynamisch typisierte, es würde nicht einen Fehler auslösen! Dynamisch typisierte Sprachen, die nicht check-Typen bis zur Ausführung, und diese Zeile wird nie ausgeführt.

Gehen Beispiel

Statisch Kompiliert

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 sind überprüft vor der Ausführung (statisch) und geben Sie Fehler sofort gefangen! Die Typen würden noch überprüft werden, bevor der run-time, wenn es interpretiert wird, mit dem gleichen Ergebnis. Wenn es war dynamisch, es würde nicht werfen Fehler, obwohl der code wäre schaute sich während der Kompilierung.

Leistung

Einer kompilierten Sprache wird, haben eine bessere performance zur Laufzeit, ob es statisch typisiert (vs. dynamisch); Kenntnisse der Arten ermöglicht machine code-Optimierung.

Statisch typisierte Sprachen haben eine bessere performance zur Laufzeit intrinsisch durch nicht brauchen, um check-Typen dynamisch während der Ausführung (es prüft vor der Ausführung).

Ähnlich, kompilierte Sprachen sind schneller zur Laufzeit als code wurde bereits übersetzt, anstatt dass "interpret"/, übersetzen Sie es auf der fliege.

Beachten Sie, dass sowohl kompiliert und statisch typisierte Sprachen haben eine Verzögerung vor der Ausführung für die übersetzung und Typüberprüfung, beziehungsweise.

Mehr Unterschiede

Statische Typisierung fängt Fehler frühzeitig, statt Sie zu finden, die während der Ausführung (besonders nützlich für lange Programme). Es ist mehr "strenge", die es nicht erlauben für Typ-Fehler irgendwo in Ihrem Programm, und oft verhindert, dass Variablen aus den sich verändernden Arten, die außerdem einen Schutz gegen unbeabsichtigten Fehlern.

num = 2
num = '3' //ERROR

Dynamische Eingabe ist flexibler, was einige schätzen. Es in der Regel ermöglicht, Variablen zu ändern, was dazu führen kann, unerwartete Fehler.

InformationsquelleAutor der Antwort JBallin

Starke Typisierung wahrscheinlich bedeutet, dass Variablen, die einem genau definierten Typ sind, und dass es strenge Regeln zum kombinieren von Variablen unterschiedlicher Typen in Ausdrücken. Zum Beispiel, wenn A eine ganze Zahl und B ist ein float, dann die strenge Regel über A+B sein könnte, ist Ein cast zu float und das Ergebnis als float. Wenn A eine ganze Zahl und B ist eine Zeichenkette, so wird die strenge Regel könnte sein, dass A+B nicht gültig ist.

Statische Typisierung bedeutet wahrscheinlich, dass die Arten zugeordnet sind, bei der Kompilierung (oder dessen äquivalent für die nicht-kompilierte Sprachen) und können nicht geändert werden während der Ausführung des Programms.

Beachten Sie, dass diese Klassifizierungen nicht gegenseitig ausschließen, ja, ich würde erwarten, dass Sie gemeinsam auftreten, Häufig. Viele stark-typisierten Sprachen sind auch statisch typisiert.

Und beachten Sie, dass, wenn ich das Wort "wahrscheinlich" es ist, weil es keine allgemein anerkannte Definition dieser Begriffe. Wie Sie bereits gesehen haben von die Antworten so weit.

Einfach gesagt ist es so: in einem statisch typisierten Sprache der Typ ist statischeD. H. sobald Sie eine variable zu einem Typ, Sie können es NICHT ändern. Das ist, weil die Eingabe ist im Zusammenhang mit der variable statt dem Wert, den es sich bezieht.

Zum Beispiel in Java:

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

In der Erwägung, dass in einer dynamisch typisierte Sprache der Typ ist dynamischeD. H. nachdem Sie eine variable eines Typs, KÖNNEN Sie es ändern. Das ist, weil die Eingabe ist im Zusammenhang mit dem Wert anstatt der Variablen.

Zum Beispiel in Python:

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

Auf der anderen Seite, die starke/schwache Typisierung in einer Sprache ist mit impliziten Typkonvertierungen (teilweise übernommen von @Darios Antwort):

Zum Beispiel in Python:

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

in der Erwägung, dass in PHP:

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

Statische Typisierung erlaubt die Prüfung Typ-Korrektheit bei der Kompilierung. Statisch typisierte Sprachen sind in der Regel kompiliert und dynamisch typisierte Sprachen interpretiert werden. Daher dynamicly typisierte Sprachen können überprüfen Sie die Eingabe zur Laufzeit.

InformationsquelleAutor der Antwort Md. Sajedul Karim

Statisch typisierten Sprachen wie C++, Java und Dynamisch typisierten Sprachen wie Python unterscheiden sich nur in Bezug auf die Ausführung der den Typ der Variablen.
Statisch typisierten Sprachen mit statischen Datentyp für die variable, hier die Daten Typ überprüft beim kompilieren so ist das Debuggen viel einfacher...in der Erwägung, dass Dynamisch typisierte Sprachen nicht das gleiche tun, der Daten-Typ-geprüft wird die Ausführung des Programms und damit die Fehlersuche ist etwas schwierig.

Außerdem haben Sie einen sehr kleinen Unterschied und kann im Zusammenhang mit stark typisierte und schwach typisierte Sprachen. Eine stark typisierte Sprache, die nicht zulässt, dass Sie mit einem Typ wie die anderen zB. C und C++ ...in der Erwägung, dass schwach typisierte Sprachen, die erlauben zB.python

InformationsquelleAutor der Antwort Akash sharma

In einem statisch typisierten Sprachejede variable gebunden ist, sowohl
1.zu einer Art (zur compile-Zeit, durch eine Erklärung)
2.um ein Objekt.
Die Bindung an ein Objekt ist optional — wenn Sie einen Namen nicht an ein Objekt gebunden, der name sagt null sein.
In einem dynamisch typisierte Sprache, jede variable ist (es sei denn es ist null) gebunden nur an ein Objekt.

Namen gebunden sind Objekte, die zum Zeitpunkt der Ausführung durch Abtretung, zu Aussagen, und es ist möglich, binden einen Namen an Objekte unterschiedlicher Typen, die während der Ausführung des Programms.

InformationsquelleAutor der Antwort Danysh Mushtaq