Die Methode zum Drucken des Quelldateinamens, bei dem ein Fehler auftritt, hängt stark von der Programmiersprache und der Art des Fehlers ab. Hier ist eine Aufschlüsselung von Ansätzen für mehrere gemeinsame Szenarien:
1. Ausnahmebehandlung (die meisten Sprachen):
Die meisten modernen Sprachen haben Ausnahmebehörigmechanismen. Die Kernidee besteht darin, Ausnahmen zu fangen und Informationen darüber zu extrahieren, wo sie stammen. Dies schließt häufig den Dateinamen und die Zeilennummer ein.
* Python:
`` `Python
Traceback importieren
versuchen:
# Ein Code, der eine Ausnahme hervorrufen könnte
Ergebnis =10 /0
außer Ausnahme als E:
TraceBack.print_exc () # druckt den vollständigen Traceback einschließlich Dateiname und Zeilennummer aus
`` `
`taceBack.print_exc ()` ist hier von entscheidender Bedeutung. Ein einfacher "Druck (e)" zeigt möglicherweise nur den Ausnahmetyp und die Meldung, nicht den Ort.
* Java:
`` `Java
versuchen {
// ein Code, der möglicherweise eine Ausnahme hervorrufen könnte
int result =10/0;
} catch (AritheMeticexception e) {
E. printstacktrace (); // druckt die Stapelspur mit Dateinamen und Zeilennummer aus
}
`` `
`e.printstacktrace ()` liefert ähnliche Funktionen wie Pythons `TraceBack.print_exc ()`.
* C ++:
C ++ hat kein integriertes Ausnahmebehandlung so elegant wie Python oder Java. Sie müssen Debugging -Tools oder Bibliotheken wie "libunwind" verwenden, um detaillierte Informationen zu Stack Trace zu erhalten. Dies ist komplexer und erfordert häufig Compiler- und Linker -Flags, um Debug -Symbole zu ermöglichen. Grundlegende Fehlerbehelde beinhalten möglicherweise nur die Protokollierung des Fehlers mit "Perror", der keine Dateinameninformationen enthält.
* javaScript (node.js):
`` `JavaScript
versuchen {
// ein Code, der möglicherweise einen Fehler macht
sei Ergebnis =10/0;
} catch (error) {
console.Error (error.stack); // druckt die Stapelverfolgung einschließlich Dateiname und Zeilennummer
}
`` `
2. Precessor -Anweisungen (C/C ++):
In C und C ++ können Sie mit dem Präprozessor den Dateinamen in Ihren Code einfügen:
`` `C ++
#include
#define Datei_Name __file__
int main () {
versuchen {
int result =10/0;
} catch (const std ::exception &e) {
std ::cerr <<"Fehler in der Datei:" <
// ... detailliertere Fehlerbehandlung ...
}
Rückkehr 0;
}
`` `
`__File__` ist ein Präprozessor -Makro, das auf den Namen der aktuellen Datei erweitert wird. Dies ist weniger anspruchsvoll als die Stapelspur von Exception Handling, da sie nur den Dateinamen des sofortigen Fehlerortes enthält, nicht die Funktionskette, die dazu führt.
3. Protokollierungsbibliotheken:
Viele Protokollierungsbibliotheken (wie "Protokollierung" in Python oder `log4j` in Java) enthalten automatisch Datei- und Zeileninformationen in ihre Protokollnachrichten. Dies ist ein guter Ansatz für die Verfolgung von Fehlern während der Programmausführung, auch wenn Sie an jedem potenziellen Fehlerpunkt keine expliziten Ausnahmen behandeln.
4. Debugger:
Debugger (wie GDB für C/C ++, PDB für Python) sind von unschätzbarem Wert, um Fehler zu finden. Sie liefern detaillierte Informationen zum Ausführungszustand zum Fehler, einschließlich des Dateinamens und der Zeilennummer.
Wichtige Überlegungen:
* Debug Builds: Für viele Sprachen sind Compiler-Optionen erforderlich, um Debugging-Informationen zu aktivieren (z. B. `-g`-Flag in GCC). Diese Informationen sind für Stapelspuren und Debugger -Funktionen von entscheidender Bedeutung. Release -Builds streifen diese Debug -Informationen häufig aus, um die ausführbare Größe zu reduzieren.
* Fehlerbehandlungsstrategie: Entscheiden Sie, ob Sie Fehler lokal verarbeiten (mit `try ... außer"/`try ... catch`) oder zentral (mit Protokollierung). Ein Hybridansatz ist oft am besten.
* Klarheit: Vermeiden Sie generische Fehlermeldungen. Geben Sie nach Möglichkeit einen Kontext an (z. B. "Fehlerlesendatei" data.txt '").
Denken Sie daran, die Methode auszuwählen, die Ihrer Sprache, der Komplexität Ihrer Anwendung am besten passt, und Ihrer Fehlerbehandlungsstrategie. Die Ausnahmehandhabung mit einem Protokollierungssystem bietet normalerweise eine robuste Lösung.
