Die Ironie des statischen Tippens in dynamischen Sprachen

Sie können diesen Artikel auch auf Medium lesen.

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

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, eingeführt in Version 7 im Jahr 2015.
• 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, die 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 die Erstellung von Variablen und lassen den Interpreter ihren Typ während der Laufzeit implizieren:

# 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 beispielsweise in Python hindert Sie nicht daran, die Typen Ihrer Variablen zu ändern:

x: int = 0
x = "John" 
print(type(x))   # <class 'str'>

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 auf diese Weise 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:

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

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:

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

Beeinträchtigen wir die Lesbarkeit des Codes?

Vor zehn Jahren habe ich mich für die Verwendung von Python für meine Doktorarbeit entschieden, da es einfach zu bedienen ist und neue Ideen schnell in Prototypen umsetzen kann. 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:

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

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

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

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 Artikel 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 Eingabe 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 statisches Tippen, wenn Sie:

sind

• 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 beim Codieren die goldene Regel immer darin besteht, nach Einfachheit zu streben, es sei denn, Sie haben einen guten Grund, Dinge zu komplizieren.

Das obige ist der detaillierte Inhalt vonDie Ironie des statischen Tippens in dynamischen Sprachen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!