Metoden för att skriva ut källfilnamnet där ett fel uppstår beror starkt på programmeringsspråket och typen av fel. Här är en uppdelning av tillvägagångssätt för flera vanliga scenarier:
1. Undantagshantering (de flesta språk):
De flesta moderna språk har undantagshanteringsmekanismer. Kärnidén är att fånga undantag och extrahera information om var de har sitt ursprung. Detta inkluderar ofta filnamnet och radnumret.
* python:
`` `python
importback
försök:
# Någon kod som kan höja ett undantag
resultat =10/0
utom undantag som E:
traceback.print_exc () # skriver ut hela traceback, inklusive filnamn och radnummer
`` `
`Traceback.print_exc ()` är avgörande här. Ett enkelt "tryck (e)" kanske bara visar undantagstyp och meddelande, inte platsen.
* java:
`` `Java
försök {
// någon kod som kan höja ett undantag
int resultat =10/0;
} catch (arithmeticException e) {
e.printStackTrace (); // skriver ut stackspåret med filnamn och radnummer
}
`` `
`E.printStackTrace ()` ger liknande funktionalitet som Pythons `traceback.print_exc ()`.
* C ++:
C ++ har inte inbyggt undantagshantering så elegant som Python eller Java. Du måste använda felsökningsverktyg eller bibliotek som `libunwind 'för att få detaljerad stackspårinformation. Detta är mer komplex och kräver ofta kompilator- och länkflaggor för att möjliggöra felsökningssymboler. Grundläggande felhantering kan bara involvera loggning av felet med "perror" som inte ger information om filnamn.
* javascript (node.js):
`` `JavaScript
försök {
// någon kod som kan kasta ett fel
Låt resultat =10/0;
} catch (fel) {
Console.Error (Error.Stack); // skriver ut stackspåret inklusive filnamn och radnummer
}
`` `
2. Förprocessordirektiv (C/C ++):
I C och C ++ kan du använda förbehandlaren för att infoga filnamnet i din kod:
`` `C ++
#include
#Definera file_name __File__
int main () {
försök {
int resultat =10/0;
} catch (const std ::undantag &e) {
std ::cerr <<"Fel i fil:" <
// ... mer detaljerad felhantering ...
}
return 0;
}
`` `
`__File__` är ett förbehållsmakro som expanderar till den aktuella filens namn. Detta är mindre sofistikerat än undantagshanteringens stackspår, eftersom det bara ger filnamnet på den omedelbara felplatsen, inte kedjan av funktionssamtal som leder till den.
3. Loggbibliotek:
Många loggningsbibliotek (som "logging" i Python eller "log4j" i Java) innehåller automatiskt fil- och radinformation i sina loggmeddelanden. Detta är ett bra tillvägagångssätt för att spåra fel under programutförandet, även om du inte uttryckligen hanterar undantag vid varje potentiell felpunkt.
4. Debuggers:
Debuggers (som GDB för C/C ++, PDB för Python) är ovärderliga för att hitta fel. De tillhandahåller detaljerad information om exekveringstillståndet vid felet, inklusive filnamnet och radnumret.
Viktiga överväganden:
* Debug Builds: För många språk behövs kompilatoralternativ för att möjliggöra felsökningsinformation (t.ex. `-g` flagga i GCC). Denna information är avgörande för stackspår och felsökningsfunktionalitet. Release Builds tar ofta bort denna felsökningsinformation för att minska körbar storlek.
* Felhanteringsstrategi: Bestäm om du ska hantera fel lokalt (med "försök ... utom"/"försök ... fånga") eller centralt (med loggning). En hybridmetod är ofta bäst.
* tydlighet: Undvik generiska felmeddelanden. Ge kontext när det är möjligt (t.ex. "felläsningsfil 'data.txt'").
Kom ihåg att välja den metod som bäst passar ditt språk, komplexiteten i din applikation och din felhanteringsstrategi. Undantagshantering i kombination med ett loggningssystem erbjuder vanligtvis en robust lösning.
