Die Rolle eines Dolmetschers bei der Programmierung
Ein Interpreter ist ein Computerprogramm, das direkt in einer Programmiersprache, Zeile für Zeile (oder Anweisung nach Anweisung) geschriebene Anweisungen ausführt, ohne den gesamten Quellcode in den Maschinencode zu konvertieren. Es liest den Code, analysiert ihn (analysiert die Syntax) und führt dann die vom Code angegebenen Aktionen aus.
Schlüsselmerkmale von Dolmetschern:
* Zeilen-für-Leitung-Ausführung: Der Interpreter liest und führt den Programmcode jeweils eine Zeile aus.
* Keine Zwischencode -Generierung: Im Gegensatz zu Compilern erstellen Dolmetscher keine separate ausführbare Datei- oder Objektcode -Datei.
* Dynamische Interpretation: Der Interpretationsprozess erfolgt während der Laufzeit. Der Interpreter analysiert den Code und führt Aktionen durch, die das Programm ausführt.
* Sofortige Ausführung: Änderungen am Quellcode sind unmittelbar nach dem Speichern (normalerweise) zu sehen.
Hier ist eine Aufschlüsselung des Prozesses:
1. Lesen Sie eine Zeile/Anweisung: Der Interpreter liest die nächste Anweisung aus dem Quellcode.
2. Anweisung analysieren: Es überprüft die Syntax und stellt sicher, dass die Anweisung gültig ist.
3. Führen Sie den Anweisungen aus: Der Dolmetscher führt den von der Anweisung angegebenen Vorgang aus.
4. Wiederholen: Die Schritte 1-3 werden für jede Zeile/Anweisung wiederholt, bis das gesamte Programm ausgeführt wird oder ein Fehler auftritt.
Beispiel:
Stellen Sie sich ein einfaches Python -Programm vor:
`` `Python
x =5
y =10
print (x + y)
`` `
Wenn dieses Programm vom Python -Interpreter ausgeführt wird:
1. Der Dolmetscher liest `x =5`.
2. Es analysiert die Zeile und weist den Wert 5 der Variablen `x` zu.
3. Der Dolmetscher liest `y =10`.
4. Es analysiert die Zeile und weist den Wert 10 der Variablen `y` zu.
5. Der Dolmetscher liest `print (x + y)`.
6. Es analysiert die Zeile, bewertet `x + y` (was 15 ist) und ruft dann die Funktion" Print "auf, um das Ergebnis anzuzeigen.
Wie sich Dolmetscher von Compilern unterscheiden
Der Hauptunterschied zwischen Dolmetschern und Compilern liegt darin, wie sie mit der Ausführung des Programmcode umgehen:
| Feature | Interpreter | Compiler |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Translation | Line-by-line-Ausführung; Keine separate ausführbare Datei. | Übersetzt den gesamten Quellcode in den Maschinencode oder eine Zwischendarstellung * vor * Ausführung. |
| Ausführung | Ausgeführt direkt während der Laufzeit. | Führt den kompilierten Code später als separater Vorgang aus. |
| Fehlerbehebung | Fehler werden während der Laufzeit erkannt. | Fehler werden während der Zusammenstellung festgestellt und die Ausführung wird verhindert, wenn Fehler vorliegen
| Geschwindigkeit | Im Allgemeinen langsamere Ausführungsgeschwindigkeit. | Im Allgemeinen schnellere Ausführungsgeschwindigkeit, da der Code bereits übersetzt ist. |
| Portabilität | Sehr tragbar (läuft auf jedem System mit einem Dolmetscher). | Weniger tragbar; Benötigt ein Neukompilieren für jede Zielplattform. |
| Debugging | Einfacheres Debuggen; Fehler können sofort festgelegt werden. | Debugging kann komplexer sein, da Sie die kompilierte Ausgabe debuggen. |
| Speicherverbrauch | Kann einen niedrigeren anfänglichen Speicher -Fußabdruck haben, wenn der Code auf Bedarf geladen wird Möglicherweise erfordern mehr Speicher während der Kompilierung, um den Zwischen-/Maschinencode zu erstellen. |
| Entwicklungszyklus | Schnellere Entwicklungszyklen, da Änderungen sofort sichtbar sind | Längere Entwicklungszyklen, da jede Codeänderung vor dem Ausführen neu kompiliert werden muss
| Beispiele | Python, JavaScript, Ruby, Php | C, C ++, Java (kompiliert zu Bytecode), Go, Rost |
Kinos:
* Interpreter: Führen Sie den Code direkt aus, Zeile für Zeile. Gut für schnelle Entwicklung und Portabilität, aber möglicherweise langsamer.
* Compiler: Übersetzt das gesamte Programm vor der Ausführung in den Maschinencode. Führt zu einer schnelleren Ausführung, aber weniger tragbar und zu einem längeren Entwicklungszyklus.
Analogie:
Stellen Sie sich vor, Sie haben ein Buch in einer Fremdsprache.
* Interpreter: Sie stellen einen Übersetzer ein, der Ihnen das Buch laut vorlesen und einen Satz nach dem anderen übersetzen.
* Compiler: Sie haben das gesamte Buch vorher in Ihre Muttersprache übersetzt. Sie können dann die übersetzte Version selbst lesen, ohne einen Übersetzer vorhanden zu haben.
Hybridansätze:
Es ist auch wichtig zu beachten, dass einige Sprachen einen hybriden Ansatz verwenden. Zum Beispiel wird Java in Bytecode zusammengestellt, das dann von der Java Virtual Machine (JVM) interpretiert wird. Dies kombiniert die Vorteile sowohl der Zusammenstellung (schnellere Ausführung) als auch der Interpretation (Plattformunabhängigkeit).
