Ich sehe diese Begriffe überall in der Programmierung und ich habe eine vage Vorstellung davon, was sie bedeuten. Eine Suche zeigt mir, dass solche Dinge tatsächlich überall im Stapelüberlauf gefragt wurden. Soweit mir bekannt ist, unterscheidet sich die statische / dynamische Eingabe in Sprachen geringfügig von der starken / schwachen Eingabe, aber was dieser Unterschied ist, entgeht mir. Unterschiedliche Quellen scheinen unterschiedliche Bedeutungen zu verwenden oder die Begriffe sogar austauschbar zu verwenden. Ich kann keinen Ort finden, der über beides spricht und tatsächlich den Unterschied ausdrückt. Was schön wäre, wäre, wenn jemand dies hier für mich und den Rest der Welt klar formulieren könnte.

• Bei der statischen / dynamischen Typisierung geht es darum, wann Typinformationen erfasst werden (entweder zur Kompilierungszeit oder zur Laufzeit).

• Bei der starken / schwachen Typisierung geht es darum, wie streng Typen unterschieden werden (z. B. ob die Sprache versucht, eine implizite Konvertierung von Zeichenfolgen in Zahlen durchzuführen).

Weitere Informationen finden Sie auf der Wiki-Seite .

Sie haben eine Schwachstelle in der Terminologie entdeckt, mit der Amateure über Programmiersprachen sprechen. Verwenden Sie nicht die Begriffe "stark" und "schwach" , da sie keine allgemein anerkannte technische Bedeutung haben. Im Gegensatz dazu bedeutet statische Typisierung , dass Programme vor der Ausführung überprüft werden und ein Programm möglicherweise vor dem Start abgelehnt wird. Dynamische Typisierung bedeutet , dass die Art der Werte werden überprüft während der Ausführung , und ein schlecht getippt Betrieb könnte das Programm zu stoppen verursachen oder sonst ein Fehlersignal zur Laufzeit . Ein Hauptgrund für die statische Typisierung besteht darin, Programme auszuschließen, die solche "dynamischen Typfehler" aufweisen könnten.

Starke Typisierung bedeutet im Allgemeinen, dass das Typensystem keine Lücken aufweist , während schwache Typisierung bedeutet, dass das Typensystem untergraben werden kann (wodurch alle Garantien ungültig werden). Die Begriffe werden häufig falsch verwendet, um statische und dynamische Typisierung zu bezeichnen. Um den Unterschied zu erkennen, denken Sie an C: Die Sprache wird beim Kompilieren typgeprüft (statische Typisierung), aber es gibt viele Lücken. Sie können einen Wert eines beliebigen Typs so gut wie in einen anderen Typ derselben Größe umwandeln - insbesondere können Sie Zeigertypen frei umwandeln. Pascal war eine Sprache, die stark typisiert werden sollte, aber bekanntermaßen eine unvorhergesehene Lücke hatte: ein Variantendatensatz ohne Tag.

Implementierungen stark typisierter Sprachen führen im Laufe der Zeit häufig zu Lücken, sodass ein Teil des Laufzeitsystems in der Hochsprache implementiert werden kann. Zum Beispiel hat Objective Caml eine aufgerufene Funktion, Obj.magicdie zur Laufzeit einfach das Argument zurückgibt, aber zur Kompilierungszeit einen Wert eines beliebigen Typs in einen beliebigen anderen Typ konvertiert. Mein Lieblingsbeispiel ist Modula-3, dessen Designer ihr Typgusskonstrukt nannten LOOPHOLE.

Trotzdem können Sie sich nicht darauf verlassen, dass zwei Personen die Wörter "stark" und "schwach" genauso verwenden. Also vermeide sie.

Einfach ausgedrückt: In einer statisch typisierten Sprache ist der Typ statisch . Wenn Sie also eine Variable auf einen Typ gesetzt haben, können Sie ihn NICHT mehr ändern. Dies liegt daran, dass die Eingabe eher der Variablen als dem Wert zugeordnet ist, auf den sie sich bezieht.

Zum Beispiel in Java:

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

Während in einer dynamisch typisierten Sprache der Typ dynamisch ist , dh nachdem Sie eine Variable auf einen Typ gesetzt haben, können Sie ihn ändern. Dies liegt daran, dass die Eingabe eher dem Wert als der Variablen zugeordnet ist.

Zum Beispiel in Python:

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

Andererseits hängt die starke / schwache Eingabe in einer Sprache mit impliziten Typkonvertierungen zusammen (teilweise aus der Antwort von @ Dario):

Zum Beispiel in Python:

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

während in PHP:

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

Durch statische Typisierung kann die Typkorrektheit beim Kompilieren überprüft werden. Statisch typisierte Sprachen werden normalerweise kompiliert und dynamisch typisierte Sprachen werden interpretiert. Daher können dynamisch typisierte Sprachen die Eingabe zur Laufzeit überprüfen.

Schwache Typisierung bedeutet, dass sich der Typ eines Objekts je nach Kontext ändern kann. Beispielsweise kann in einer schwach typisierten Sprache die Zeichenfolge "123" als Nummer 123 behandelt werden, wenn Sie eine weitere Nummer hinzufügen. Beispiele für Sprachen mit schwacher Typisierung sind bash, awk und PHP.

Eine andere Art von schwach typisierter Sprache ist C, bei der die Daten an einer Speicheradresse durch Casting als ein anderer Typ behandelt werden können.

In einer stark typisierten Sprache ändert sich der Typ eines Objekts nicht - ein int ist immer ein int, und der Versuch, es als Zeichenfolge zu verwenden, führt zu einem Fehler. Sowohl Java als auch Python sind stark typisiert.

Der Unterschied zwischen dynamischer und statischer Typisierung besteht darin, dass die Typregeln erzwungen werden. In einer statisch typisierten Sprache muss der Typ jeder Variablen und jedes Parameters in der Quelle deklariert werden und wird zur Kompilierungszeit erzwungen. In einer dynamisch typisierten Sprache werden die Typen nur überprüft, wenn sie zur Laufzeit verwendet werden. Java ist also statisch typisiert und Python ist dynamisch typisiert.

Die Grenzen können jedoch manchmal etwas verschwommen sein. Obwohl Java statisch typisiert ist, verschieben Sie die Typprüfung jedes Mal, wenn Sie Reflection oder eine Umwandlung verwenden (z. B. wenn Sie Container mit Objekten verwenden), auf die Laufzeit.

In ähnlicher Weise werden die am stärksten typisierten Sprachen immer noch automatisch zwischen Ganzzahlen und Gleitkommazahlen konvertiert (und in einigen Sprachen BigInts mit absoluter Genauigkeit).

Als ich heute über dieses Thema recherchierte, stieß ich auf diesen großartigen Artikel http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html Es gelöscht eine Menge von bis Dinge für mich und ich dachte, es könnte zu einigen der großartigen Antworten oben beitragen.

Starkes und schwaches Tippen:

Die wahrscheinlich häufigste Art, Systeme zu klassifizieren, ist "stark" oder "schwach". Dies ist bedauerlich, da diese Wörter fast überhaupt keine Bedeutung haben. In begrenztem Umfang ist es möglich, zwei Sprachen mit sehr ähnlichen Typsystemen zu vergleichen und eine als das stärkere dieser beiden Systeme zu bezeichnen. Darüber hinaus bedeuten die Wörter überhaupt nichts.

Statische und dynamische Typen

Dies ist nahezu die einzige gängige Klassifizierung von Typsystemen, die eine echte Bedeutung hat. Tatsächlich wird seine Bedeutung häufig unterschätzt. [...] Dynamische und statische Systeme sind zwei völlig verschiedene Dinge, deren Ziele sich teilweise überschneiden.

Ein statisches Typsystem ist ein Mechanismus, mit dem ein Compiler den Quellcode untersucht, Teilen der Syntax Beschriftungen (sogenannte "Typen") zuweist und diese dann verwendet, um auf das Verhalten des Programms zu schließen. Ein dynamisches Typsystem ist ein Mechanismus, mit dem ein Compiler Code generiert, um die Art der vom Programm verwendeten Datentypen (zufälligerweise auch als "Typ" bezeichnet) zu verfolgen. Die Verwendung des gleichen Wortes "Typ" in jedem dieser beiden Systeme ist natürlich nicht ganz zufällig; dennoch wird am besten verstanden, dass es eine Art schwache historische Bedeutung hat. Große Verwirrung entsteht durch den Versuch, eine Weltanschauung zu finden, in der "Typ" in beiden Systemen wirklich dasselbe bedeutet. Das tut es nicht.

Explizite / implizite Typen:

Wenn diese Begriffe verwendet werden, beziehen sie sich auf das Ausmaß, in dem ein Compiler über die statischen Arten von Teilen eines Programms nachdenkt. Alle Programmiersprachen haben irgendeine Art von Argumentation über Typen. Einige haben mehr als andere. ML und Haskell haben implizite Typen, da keine (oder nur sehr wenige, je nach Sprache und verwendeten Erweiterungen) Typdeklarationen erforderlich sind. Java und Ada haben sehr explizite Typen, und man deklariert ständig die Arten von Dingen. Alle oben genannten Systeme haben (im Vergleich zu beispielsweise C und C ++) starke statische Systeme.

Aus Scotts Programmiersprache Pragmatik , 3. Auflage Seite 291, haben wir

Bei der Typprüfung wird sichergestellt, dass ein Programm die Typkompatibilitätsregeln der Sprache einhält. Ein Verstoß gegen die Regeln wird als Typkonflikt bezeichnet. Eine Sprache wird als stark typisiert bezeichnet, wenn sie die Anwendung einer Operation auf ein Objekt, das diese Operation nicht unterstützen soll, auf eine Weise verbietet, die durch die Sprachimplementierung erzwungen werden kann. Eine Sprache soll statisch typisiert sein wenn sie stark typisiert ist und die Typprüfung zur Kompilierungszeit durchgeführt werden kann. Im strengsten Sinne des Wortes sind nur wenige Sprachen statisch typisiert. In der Praxis wird der Begriff häufig auf Sprachen angewendet, in denen die meisten Typprüfungen zur Kompilierungszeit und der Rest zur Laufzeit durchgeführt werden können.

Einige Beispiele: Ada ist stark typisiert und größtenteils statisch typisiert (bestimmte Typeinschränkungen müssen zur Laufzeit überprüft werden). Eine Pascal-Implementierung kann den größten Teil ihrer Typprüfung auch zur Kompilierungszeit durchführen, obwohl die Sprache nicht sehr stark typisiert ist: Variantendatensätze ohne Tags (die in Abschnitt 7.3.4 erläutert werden) sind die einzige Lücke. C89 ist deutlich stärker typisiert als seine Vorgängerdialekte, aber immer noch deutlich weniger stark typisiert als Pascal. Zu den Lücken gehören Gewerkschaften, Unterprogramme mit variabler Anzahl von Parametern und die Interoperabilität von Zeigern und Arrays (wird in Abschnitt 7.7.1 erläutert). Implementierungen von C überprüfen zur Laufzeit selten etwas.

Die dynamische (Laufzeit-) Typprüfung ist eine Form der späten Bindung und tritt in der Regel in Sprachen auf, die andere Probleme bis zur Laufzeit verzögern. Lisp und Smalltalk werden dynamisch (wenn auch stark) typisiert. Die meisten Skriptsprachen werden auch dynamisch eingegeben. Einige (z. B. Python und Ruby) sind stark typisiert. Sprachen mit dynamischem Gültigkeitsbereich werden im Allgemeinen dynamisch (oder überhaupt nicht) typisiert: Wenn der Compiler das Objekt, auf das sich ein Name bezieht, nicht identifizieren kann, kann er normalerweise auch den Typ des Objekts nicht bestimmen.

In einfachen Worten bezieht sich statische / dynamische Typisierung auf die Zeit, zu der die Typprüfung stattfindet: Kompilierungszeit für statische Typisierung und Laufzeit für dynamische Sprachen. Ebenso bezieht sich starke / schwache Typisierung darauf, wie aggressiv eine Sprache bei der Durchsetzung ihres Typsystems ist.

Ich habe versucht, Scotts Beschreibung in ein schönes Diagramm zu übersetzen, das ich unten gepostet habe.

Ich denke, die anderen Kollegen haben einen guten Job gemacht, besonders. Erklären des Unterschieds zwischen statischer und dynamischer Typisierung. In Bezug auf starkes und schwaches Tippen sollte jedoch gesagt werden, dass es unterschiedliche Auffassungen / Ansichten gibt.

Hier zwei Beispiele:

• Einige sagen, dass Haskell stark typisiert ist, da Sie keine Typkonvertierungen vornehmen dürfen .

• Andere (z. B. Darios Ansicht) sagen, dass eine Sprache, die es erlaubt, absichtlich implizit von einer Zeichenfolge in eine Zahl umzuwandeln, schwach typisiert ist, aber selbst andere nennen dies nur Ententypisierung.

Beide Aussagen heben nicht die entgegengesetzten Extreme eines Typsystems hervor, sondern völlig unterschiedliche Aspekte. Deshalb schließe ich mich Herrn Ramseys Ansicht an, die Begriffe "stark" und "schwach" nicht zu verwenden, um zwischen Typsystemen zu unterscheiden.

Statisch v / s dynamisch typisierte Sprachen

• Statisch typisierte Sprachen sind solche, bei denen die Typprüfung zur Kompilierungszeit durchgeführt wird. Dies bedeutet also auch, dass in statisch typisierten Sprachen jede Variable einen Typ hat und sich im Laufe des Kurses nicht ändert. Im Gegensatz dazu sind dynamisch typisierte Sprachen diejenigen, bei denen die Typprüfung zur Laufzeit durchgeführt wird, und es gibt keine Typprüfung zur Kompilierungszeit. Dies bedeutet auch, dass in dynamisch typisierten Sprachen möglicherweise ein Typ mit Variablen verknüpft ist oder nicht Wenn ein Typ zugeordnet ist, kann es sich um einen generischen Typ wie "var" in JS handeln, der sowohl für eine Zeichenfolge als auch für eine Zahl gilt.
  • „Implementierungen von dynamisch typgeprüften Sprachen verknüpfen im Allgemeinen jedes Laufzeitobjekt mit einem Typ-Tag (dh einem Verweis auf einen Typ), das seine Typinformationen enthält. Diese Laufzeittypinformationen (RTTI) können auch zum Implementieren von dynamischem Versand, später Bindung, Downcasting, Reflexion und ähnlichen Funktionen verwendet werden. “
• Selbst wenn die Sprache statisch typisiert ist, kann sie dennoch eine dynamisch typisierte Funktion haben, was im Grunde bedeutet, dass auch zur Laufzeit eine Art Typprüfung durchgeführt wird. Dies ist nützlich beim Gießen von Typen.
  • „Eine Reihe nützlicher und allgemeiner Programmiersprachenfunktionen kann nicht statisch überprüft werden, z. B. Downcasting. Daher werden in vielen Sprachen sowohl statische als auch dynamische Typprüfungen durchgeführt. Die statische Typprüfung überprüft, was sie kann, und dynamische Überprüfungen überprüfen den Rest. “
• „In einigen Sprachen kann Code geschrieben werden, der nicht typsicher ist. In C können Programmierer beispielsweise einen Wert frei zwischen zwei Typen mit derselben Größe umwandeln. “
• Die Vorteile von "statisch" typisierten Sprachen sind:
  • Da der Großteil der Typprüfung zur Kompilierungszeit erfolgt, können Interpreter oder Laufzeit mit voller Geschwindigkeit ausgeführt werden, ohne sich um die Typen kümmern zu müssen.
  • Dies führt zu einer geringeren Anzahl von Laufzeitausnahmen oder typbezogenen Fehlern, da der größte Teil der Typprüfung zur Kompilierungszeit erfolgt.
• Die Vorteile von "dynamisch" typisierten Sprachen sind:
  • Sie könnten beim extrem schnellen Prototyping helfen, da Entwickler das Typsystem nicht verstehen müssen, damit Entwickler lose Variablen erstellen und ausführen können. Dies führt zu einem sehr schnellen Prototyping.
• Liste der statisch und dynamisch typisierten Sprachen :
  • Statisch:
    • Java
    • C (C ist eine statisch typisierte Sprache, aber im Vergleich zu Java weniger "stark" typisiert, da sie implizitere Konvertierungen ermöglicht.)
    • C ++
    • C #
  • Dynamisch:
    • PERL
    • PHP
    • Python
    • JavaScript
    • Rubin
• Die Typprüfung ist ein wichtiges Sicherheitsmerkmal. Angenommen, es gibt keine Typprüfung, und eine Methode akzeptiert ein Objekt vom Typ "BankAccount" mit einer Methode namens "creditAccount (BankAccountDetails)". Wenn zur Laufzeit keine Typprüfung erfolgt, kann ich ein eigenes Objekt übergeben Klasse, die dieselbe Methode "creditAccount (BankAccountDetails)" hat und ausgeführt wird, wenn man bedenkt, dass es sich um eine objektorientierte Sprache handelt, da OOP "Polymorphismus" unterstützt und hier nur "Polymorphismus" diskutiert wird. Grundsätzlich kann eine objektorientierte Sprache (was im Grunde bedeutet, dass sie „Polymorphismus“ unterstützt) ohne starke Typprüfung zu Sicherheitsproblemen führen.

Stark v / s schwach typisierte Sprachen

• Stark typisierte Sprachen sind solche, in denen implizite Konvertierungen bei Genauigkeitsverlust nicht zulässig sind. In Java können Sie beispielsweise ein "int to long" umwandeln, weil es keinen Genauigkeitsverlust gibt, aber Sie können ein "long to int" nicht "implizit" umwandeln, weil es zu einem Genauigkeitsverlust kommen würde. Im Gegensatz dazu sind in schwach typisierten Sprachen implizite Konvertierungen auch bei Genauigkeitsverlusten zulässig.
• Ich denke, dynamisch typisierte Sprache kann auch eine stark typisierte Sprache sein, wenn sie „zur Laufzeit“ keine impliziten Konvertierungen zulässt, bei denen es zu Genauigkeitsverlusten kommt.

Gute weitere Lesungen

• Type_system
• Strong_and_weak_typing
• Kategorie: Statisch_typisierte_Programmiersprachen
• Kategorie: Dynamisch_typisierte_Programmiersprachen

Bei statisch typisierten Sprachen müssen Sie im Allgemeinen die Variablentypen deklarieren, die dann beim Kompilieren überprüft werden, um Fehler zu reduzieren. Das Wort "statisch" in "statisch typisiert" bezieht sich auf "statische Code-Analyse", bei der der Code vor seiner Ausführung untersucht wird. Obwohl es für eine statisch typisierte Sprache möglich ist, den Typ der Variablen von der rechten Seite eines Ausdrucks oder von tatsächlichen Parametern abzuleiten, erfordern die meisten statisch typisierten Sprachen in der Praxis die explizite Deklaration von Variablentypen.

Dynamisch typisierte Sprachen erfordern im Allgemeinen keine Variablendeklarationen, um Typen zu haben, und sie leiten Variablentypen basierend auf dem Typ ab, der als Ergebnis der Auswertung der rechten Seite jeder Zuweisungsanweisung oder der tatsächlichen Parameter für einen Funktionsaufruf berechnet wurde. Da der Variablen im Laufe ihrer Lebensdauer mehrere Zuweisungen zugewiesen werden können, kann sich ihr Typ im Laufe der Zeit ändern. Aus diesem Grund wird sie als "dynamisch typisiert" bezeichnet. Außerdem muss die Laufzeitumgebung den aktuellen Typ für jede Variable verfolgen, sodass der Typ eher an den Wert als an die Variablendeklaration gebunden ist. Dies kann als RTTI-System (Runtime Type Information) betrachtet werden.

Elemente statisch und dynamisch typisierter Sprachen können kombiniert werden. Beispielsweise unterstützt C # sowohl statisch als auch dynamisch typisierte Variablen, und objektorientierte Sprachen unterstützen im Allgemeinen das Herabsetzen der Typhierarchie. Statisch typisierte Sprachen bieten normalerweise verschiedene Möglichkeiten, um die Typprüfung zu umgehen, z. B. durch Casting, Reflektion und dynamischen Aufruf.

Starke vs. schwache Typisierung bezieht sich auf ein Kontinuum dessen, wie sehr die Sprache versucht, Fehler zu verhindern, weil eine Variable verwendet wird, als wäre es ein Typ, obwohl es sich tatsächlich um einen anderen Typ handelt. Zum Beispiel sind sowohl C als auch Java statisch typisierte Sprachen, Java verwendet jedoch eine viel stärkere Typprüfung als C. Der folgende C-Code kompiliert und führt gerne aus und fügt zur Laufzeit einen zufälligen Wert in die Variable b ein, was höchstwahrscheinlich a verursacht Fehler:

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

Der entsprechende Java-Code erzeugt einen Kompilierungsfehler, der im Allgemeinen vorzuziehen ist:

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