Tutorials

How to debug GO program with visual studio code

Melden

Das Debugging ist ein essenzieller Teil der Softwareentwicklung. Anstatt nur fmt.Println() zu verwenden, ermöglicht dir ein Debugger, den Programmfluss Zeile für Zeile zu verfolgen, Variablenwerte in Echtzeit zu prüfen und Fehler präzise zu lokalisieren.

Dieses Tutorial zeigt dir, wie du die Go-Umgebung in Visual Studio Code (VS Code) einrichtest und effektiv nutzt.

1. Voraussetzungen

Bevor du startest, stelle sicher, dass folgende Komponenten installiert sind:

  • Go: Die Go-Programmiersprache muss auf deinem System installiert sein.
  • Visual Studio Code: Der Editor selbst.
  • Go Extension für VS Code: Suche im Extension-Marktplatz nach „Go“ (herausgegeben vom Go Team bei Google) und installiere sie.

2. Delve (dlv) installieren

Go nutzt ein Tool namens Delve als Debugging-Backend. VS Code hilft dir normalerweise dabei, es automatisch zu installieren.

  1. Öffne VS Code.
  2. Drücke Strg + Shift + P (Windows/Linux) oder Cmd + Shift + P (macOS), um die Befehlspalette zu öffnen.
  3. Tippe Go: Install/Update Tools ein und wähle es aus.
  4. Suche in der Liste nach dlv (Delve), setze ein Häkchen und klicke auf OK.

3. Das Projekt vorbereiten

Stelle sicher, dass dein Go-Projekt eine go.mod-Datei hat. Falls nicht, erstelle sie im Terminal deines Projektordners:

go mod init mein-projektname

4. Debugging-Konfiguration (launch.json)

Um das Debugging zu starten, benötigt VS Code eine Konfigurationsdatei.

  1. Klicke auf das Run and Debug Icon in der Seitenleiste (das Käfer-Symbol).
  2. Klicke auf create a launch.json file.
  3. Wähle Go als Umgebung aus.
  4. VS Code erstellt eine Datei im Ordner .vscode/launch.json. Eine Standard-Konfiguration sieht so aus:
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch Package",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            "program": "${fileDirname}"
        }
    ]
}

Tipp: program: "${fileDirname}" startet das Debugging für das Paket der Datei, die du gerade geöffnet hast.

5. Breakpoints setzen

Ein Breakpoint (Haltepunkt) stoppt die Ausführung deines Programms an einer bestimmten Stelle, damit du den Zustand untersuchen kannst.

  • Klicke im Editor links neben die Zeilennummer, bei der das Programm anhalten soll. Es erscheint ein roter Punkt.

6. Den Debug-Prozess starten

  1. Öffne die Datei, die deine main-Funktion enthält.
  2. Drücke F5 oder klicke im „Run and Debug“-Bereich auf den grünen Play-Button (Launch Package).
  3. Das Programm startet und hält automatisch am ersten Breakpoint an.

7. Die Debug-Steuerung nutzen

Sobald der Debugger aktiv ist, erscheint am oberen Bildschirmrand eine Werkzeugleiste:

  • Continue (F5): Läuft bis zum nächsten Breakpoint weiter.
  • Step Over (F10): Geht zur nächsten Zeile im aktuellen Codeblock (überspringt das Innere von Funktionen).
  • Step Into (F11): Springt hinein in eine Funktion, um diese im Detail zu prüfen.
  • Step Out (Shift + F11): Springt aus der aktuellen Funktion zurück zum Aufrufer.
  • Restart (Ctrl+Shift+F5): Startet den Debug-Prozess neu.
  • Stop (Shift + F5): Beendet das Debugging.

8. Variablen und Zustand prüfen

Während das Programm pausiert ist, kannst du im linken Bereich von VS Code folgende Sektionen nutzen:

  • Variables: Hier siehst du alle lokalen und globalen Variablen und deren aktuelle Werte.
  • Watch: Du kannst gezielt Ausdrücke oder Variablen hinzufügen, die du permanent im Auge behalten möchtest.
  • Call Stack: Zeigt dir die Hierarchie der Funktionsaufrufe an (hilfreich, um zu sehen, "wie" du an diese Stelle im Code gekommen bist).
  • Debug Console: Hier kannst du während der Pause Code-Befehle eingeben, um Variablen zu testen oder Werte zu manipulieren.

Fazit

Mit Delve und VS Code hast du ein mächtiges Werkzeug an der Hand. Anstatt zu raten, was dein Code tut, kannst du ihn nun präzise steuern und beobachten. Das spart Zeit und hilft dir, die Funktionsweise von Go tiefer zu verstehen. Viel Erfolg beim Debuggen!

0