Sie können diesen Artikel auch auf Medium lesen.

Es ist immer lustig, wenn wir sehen, wie sich Programmiersprachen im Laufe der Zeit entwickeln.

Als ich meine Reise in die Welt der Softwareentwicklung begann, wurden dynamische Sprachen wie Python, PHP und JavaScript wegen ihrer Flexibilität und prägnanten Syntax geschätzt, die für eine schnelle Entwicklung geeignet war.

Mit der Weiterentwicklung dieser schwach typisierten Sprachen integrieren sie jedoch Merkmale stark typisierter Sprachen, wodurch sie C und Java sehr ähnlich sind:

• Python: Typhinweisfunktionen, die seit Version 3.5 im Jahr 2015 eingeführt und in Version 3.12 im Jahr 2022 verbessert wurden.
• PHP: Deklarierte Typen wurden 2015 in Version 7 eingeführt.
• JavaScript: Erweitert durch die Veröffentlichung von TypeScript im Jahr 2012, definiert als „JavaScript mit Syntax für Typen“.

Warum dieser Wandel?

In Sprachen mit strenger Typisierung definieren wir explizit die Variablentypen in unserem Code. Das Ziel besteht darin, Fehler während der Entwicklungsphase vor der Ausführung des Programms zu erkennen und dem Compiler einen Hinweis auf die Speichergröße zu geben, die diesen Variablen zugewiesen werden soll.

// C   example: 'y' will be an integer
float x = 3.14;
int y = x;  //  y = 3 (ignored the decimal part of the number)

Andererseits ermöglichen uns dynamisch typisierte Sprachen wie Python, PHP und JavaScript, Variablen zu erstellen und den Interpreter ihren Typ während der Laufzeit implizieren zu lassen:

# In python and PHP: 'y' will take the same type as 'x'
x = 3.14
y = x  // y = 3.14 (float)

Wie wird die explizite Typisierung in dynamischen Sprachen eingeführt?

Im folgenden Beispiel deklarieren wir dieselbe Funktion mithilfe dynamischer und statischer Typisierung.

Python:

# using the classic syntax:
def add(x, y):
    return x   y
# using explicit typing:
def add(x: int, y:int) -> int:
    return x   y

JavaScript / TypeScript:

// using the classic syntax
function add(x, y) {
    return x   y;
}
// using explicit typing
function add(x: number, y: number): number {
    return x   y;
}

PHP:

// using the classic syntax:
function add($x, $y) {
    return $x   $y;
}
// using explicit typing:
function add(int $x, int $y): int {
    return $x   $y;
}

PHP 8.2 (veröffentlicht im Dezember 2022) geht noch einen Schritt weiter, indem es die Unterstützung für null, true und false als eigenständige Typen einführt:

public null $nil = null;
public false $false = false;`

Wo ist die Ironie?

Verstehen Sie diesen Artikel nicht als Einwand gegen diese neuen Funktionen, ich erkenne die Vorteile der Verwendung streng typisierter Sprachen an. Allerdings die Verwendung von Typanmerkungen in Python hindert Sie beispielsweise nicht daran, die Typen Ihrer Variablen zu ändern:

x: int = 0
x = "John" 
print(type(x))   # 

Das Gleiche gilt für PHP, es wird nur eine veraltete Warnung auf der Konsole ausgegeben.

Man könnte sich fragen, warum der Interpreter uns dann erlaubt, diesen Code auszuführen?
Das liegt daran, dass diese Sprachen so aufgebaut sind: Sie werden per Definition dynamisch typisiert. Wenn wir dieses Merkmal entfernen, sind sie nicht mehr dynamisch; Sie werden zu streng typisierten Sprachen wie C, aber langsamer.

Hoffentlich können Sie Ihren Interpreter zu einer strengeren Vorgehensweise auffordern, indem Sie strict_types in Ihrer PHP-Datei auf „true“ setzen:

declare(strict_types=1);

In Python können Sie das Paket „mypy“ verwenden, um Ihren Code zu analysieren und Fehler zu erkennen:

$ mypy program.py
error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]

Sie können „mypy“ als Berater betrachten, der Ihnen sagt, was Sie falsch gemacht haben, aber es hindert Sie nicht daran, Ihren Code auf eigenes Risiko auszuführen.

Auch wenn Sie sich über den Typ Ihrer Variablen nicht sicher sind, können Sie den Union-Operator verwenden, um die Liste der akzeptierten Typen zu reduzieren:

Die folgenden Beispiele aus PHP und Python zeigen, wie es geht:

y: int | float = f(x)   # introduced in Python 3.10
int | float $y = f($x)  // introduced in PHP 8.0
let y: number | string  // typescript

Beeinträchtigen wir die Lesbarkeit des Codes?

Vor zehn Jahren habe ich mich für die Verwendung von Python für meine Doktorarbeit entschieden, weil es so einfach ist und sich schnell Prototypen für neue Ideen erstellen lässt. Dann begann ich, es auch für meine anderen Projekte zu verwenden.

Jetzt lese ich einige seltsame PEPs und frage mich, ob es sich wirklich lohnt, meine Codebasis durch die Einbeziehung dieser neuen Funktionen zu komplizieren.

Sehen wir uns eine Beispielfunktion an, die die Elemente eines Wörterbuchs druckt. Hier ist die erste Version:

def print_attributes(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

person = {"name": "John", "height": 1.84}
print_attributes(**person)

Durch die Verwendung der Empfehlungen von PEP 692, eingeführt in Python 3.12, wird der Code zu:

from typing import TypedDict, Unpack

class Person(TypedDict):   # create a class inheriting from TypedDict
    name: str                  
    height: float           

def print_attributes(**kwargs: Unpack[Person]) -> None:  # use the Unpack operator
    for key, value in kwargs.items():
        print(key, value)

person: Person = {"name": "John", "height": 1.84}  # create an instance of the class
print_attributes(**person)

Zusammenfassend: Wir haben eine Klasse erstellt, die von TypedDict erbt, den Namen und Typ jedes Elements angegeben und den Unpack-Operator verwendet, um „mypy“ mitzuteilen, dass das empfangene Objekt ein TypedDict ist.

Dadurch hat sich die Größe unseres Codes verdoppelt. Es würde noch länger werden, wenn unser Objekt mehr Elemente hätte.

Glücklicherweise können wir für einige Teile unseres Codes statische Typisierung verwenden und den Rest dynamisch belassen. Wenn wir möchten, können wir uns auch dafür entscheiden, es überhaupt nicht zu verwenden.

Wann sollten wir es verwenden?

Fühlen Sie sich nicht unter Druck gesetzt, Ihre gesamte Codebasis neu zu schreiben, nur weil Sie eine neue, glänzende Funktion gelernt haben.

Diese neuen Funktionen sind wie Werkzeuge. Mein Rat ist, sie mit Bedacht einzusetzen:

Verwenden Sie statische Typisierung in den folgenden Szenarien:

• Beim Abrufen von Daten aus externen Quellen wie Datenbanken, Bibliotheken und APIs.
• In kritischen Teilen Ihres Codes, in denen Fehler nicht zulässig sind.
• Wenn Ihre Codebasis anfällig für häufige Fehler ist.

Vermeiden Sie die statische Eingabe, wenn Sie:

• Entwerfen eines Prototyps, um Ihre Idee schnell zu testen.
• Implementierung interner Logik, bei der die Typprüfung nur zu ausführlichem Code mit und ohne Vorteile führt.
• Nur Daten auf dem Bildschirm anzeigen (z. B. Diagramme, Bilder, Zahlen usw.).
• Schreiben eines Befehlszeilenskripts ohne Benutzereingaben.

Denken Sie daran, dass die goldene Regel beim Codieren immer darin besteht, nach Einfachheit zu streben, es sei denn, Sie haben einen guten Grund, die Dinge zu komplizieren.