So öffnen Sie launch.json in VS Code (2023)

Effektives Debuggen und Codequalität sind untrennbare Konzepte in der Softwareentwicklung. Die Debugging-Funktionalität von Visual Studio (VS) Code wird hauptsächlich durch die Datei launch.json gesteuert. Mit dieser Datei können Entwickler ihre Debugging-Einstellungen entsprechend ihrer Vision konfigurieren und verwalten.

Dieser Artikel führt Sie durch das Öffnen und Verwalten der Datei launch.json für ein optimales Debugging.

Öffnen von launch.json in Visual Studio Code

Um die Debugging-Einstellungen für VS-Code zu konfigurieren und zu verwalten, benötigen Sie Zugriff auf die Datei launch.json. Diese Datei spielt eine entscheidende Rolle bei der Debug-Anpassung.

1. Öffnen Sie Visual Studio Code.
   
2. Drücken Sie Strg + Umschalt + P, um die Befehlspalette zu öffnen.
   
3. Geben Sie „Open launch.json“ in die Befehlspalette ein und drücken Sie „Enter“. Dadurch sollte die Datei launch.json für Sie geöffnet werden.
   
4. Wenn die Datei „launch.json“ nicht geöffnet wird, überprüfen Sie, ob der Ordner „.vscode“ im Stammordner Ihres Projekts vorhanden ist.
5. Wenn es nicht vorhanden ist, erstellen Sie einen neuen Ordner mit dem Namen „.vscode“ in Ihrem Benutzerordner.
   
6. Erstellen Sie eine neue „launch.json“-Datei und legen Sie sie in diesem Ordner ab.
   

Die Datei „launch.json“ kann nach der Aktivierung konfiguriert werden.

Übersicht über die Launch.json-Struktur

Die launch.json zeigt die Abschnitte „Version“ und „Konfigurationen“ an. Der Abschnitt „Konfigurationen“ ist ein Array mit verschiedenen Debugging-Optionen, die Sie zum Konfigurieren Ihres Debugging-Schemas verwenden.

Jedes Objekt im Array „Konfigurationen“ stellt ein Debugging-Szenario dar. Diese Objekte verfügen über Eigenschaften, die die Debugumgebung definieren, z. B. die Sprach-, Programm- und Debuggereinstellungen.

Zu den allgemeinen Eigenschaften, die Sie in launch.json-Konfigurationen finden, gehören:

• „Name“ – Ein leserfreundlicher Name für die Konfiguration, um sie im Dropdown-Menü zu identifizieren.
• „type“ – Gibt den Typ des Debuggers an (z. B. „node“, „python“ oder „cppvsdbg“).
• „request“ – Bestimmt den Anforderungstyp, entweder „launch“ (um eine neue Instanz zu starten) oder „attach“ (um den Debugger an einen vorhandenen Prozess anzuhängen).
• „Programm“ – Dateipfad für die Datei, die Sie debuggen möchten.
• „args“ – Ein Array von Befehlszeilenargumenten, die beim Debuggen an das Programm übergeben werden.
• „preLaunchTask“ – Eine Aufgabe, die vor dem Start des Debuggers ausgeführt werden soll.

Wenn Sie die Struktur der Datei „launch.json“ verstehen, wissen Sie, welche Optionen Sie ändern und welche Sie bei der Anpassung Ihrer Debugging-Umgebung in Ruhe lassen sollten.

Konfigurieren der Starteinstellungen für verschiedene Sprachen

Die Schritte zum Konfigurieren der Starteinstellungen können je nach Sprache leicht variieren. Hier sind die Schritte für mehrere beliebte Sprachen.

JavaScript und TypeScript

1. Erstellen Sie eine neue launch.json-Datei und konfigurieren Sie die Eigenschaft „type“ als „node“ für JavaScript oder „pwa-node“ für TypeScript.
   
2. Setzen Sie die Eigenschaft „request“ auf „launch“ oder „attach“.
   
3. Sie sollten die Einstiegspunktdatei mit der Eigenschaft „Programm“ angeben.
   

Python

1. Installieren Sie den Python-Interpreter und die Erweiterung für Visual Studio Code.
   
2. Setzen Sie die Eigenschaft „type“ in einer neuen Datei „launch.json“ auf „python“.
   
3. Konfigurieren Sie die Eigenschaft „request“ als „launch“ oder „attach“.
   
4. Geben Sie die auszuführende Python-Datei mit der Eigenschaft „Programm“ an.
   
5. Möglicherweise müssen Sie zusätzlich die Eigenschaft „pythonPath“ auf den Pfad des Python-Interpreters festlegen, wenn dieser sich nicht am Standardspeicherort befindet.
   
   

C# und .NET Core

1. Installieren Sie die C#-Erweiterung für Visual Studio Code.
   
2. Setzen Sie in der neuen Datei launch.json die Eigenschaft „type“ auf „coreclr“ für .NET Core oder „clr“ für .NET Framework.
   
3. Konfigurieren Sie die Eigenschaft „request“ als „launch“ oder „attach“.
   
4. Geben Sie die Einstiegspunktdatei mit der Eigenschaft „Programm“ an.
   
5. Legen Sie bei Bedarf die Eigenschaft „cwd“ auf das Arbeitsverzeichnis des aktuellen Projekts fest.
   

Java

1. Installieren Sie das Java Extension Pack.
   
2. Erstellen Sie eine neue launch.json-Datei und setzen Sie die Eigenschaft „type“ auf „java“.
   
3. Konfigurieren Sie die Eigenschaft „request“ als „launch“ oder „attach“.
   
4. Geben Sie die Hauptklasse mit der Eigenschaft „mainClass“ an.
   
5. Legen Sie die Eigenschaft „projectName“ auf den Namen Ihres Java-Projekts fest.
   
6. Konfigurieren Sie die Eigenschaft „classpath“ so, dass sie die Java-Bibliotheken enthält, die Sie während Ihrer Java-Entwicklung verwenden werden.
   

Konfigurationsrezepte debuggen

Im folgenden Abschnitt werden verschiedene Debugkonfigurationsrezepte behandelt.

Anhängen des Debuggers an einen laufenden Prozess

So hängen Sie den Debugger an einen laufenden Prozess an:

• Setzen Sie die Eigenschaft „request“ auf „attach“.
  
• Wählen Sie die Prozess-ID oder den Filter aus, um den zu debuggenden Prozess zu finden.
  

Remote-Anwendungs-Debugging

Für das Debuggen von Remote-Anwendungen:

• Verwenden Sie einen „Remote“-Typ.
• Geben Sie die Adresse, den Port und möglicherweise Authentifizierungsinformationen des Hosts an, um eine Verbindung herzustellen.

Debuggen von Unit-Tests und Testsuiten

Beim Debuggen von Komponententests und Testsuiten:

• Verwenden Sie eine Konfiguration, die das Testframework und die Einstellungen zum Debuggen von Komponententests und Testsuiten umfasst.
• Definieren Sie die Testsuite oder einzelne Testdateien in der Eigenschaft „program“ oder „args“, um bestimmte Tests gezielt durchzuführen.

Übergeben von Umgebungsvariablen

Die Eigenschaft „env“ in launch.json kann beim Debuggen Umgebungsvariablen an Ihre Anwendung übergeben. Bei dieser Eigenschaft handelt es sich um ein Objekt, das Schlüssel-Wert-Paare für die Umgebungsvariablen enthält, die Sie festlegen möchten.

Erweitertes Debuggen

Lassen Sie uns einige fortgeschrittene Debugging-Techniken für Benutzer erkunden, die etwas mehr Leistung aus den Debug-Dateien herausholen möchten.

Bedingte Haltepunkte und Protokollpunkte

Bedingte Haltepunkte und Protokollpunkte verbessern das Debuggen, indem sie Nachrichten nur unter bestimmten Bedingungen anhalten oder protokollieren. Um sie zu verwenden:

• Klicken Sie mit der rechten Maustaste auf die Zeilennummer, in der Sie einen Haltepunkt oder Protokollpunkt festlegen möchten.
• Wählen Sie „Bedingten Haltepunkt hinzufügen“ oder „Protokollpunkt hinzufügen“.
• Geben Sie die Bedingung oder Nachricht ein, um die Aktion auszulösen.

Quellkarten

Mit Quellkarten können Sie Code debuggen, der transformiert oder minimiert wurde.

• Setzen Sie die Eigenschaft „sourceMap“ in Ihrer launch.json-Konfiguration auf „true“, um Quellkarten zu verwenden.
• Stellen Sie sicher, dass Ihr Build-Prozess Quellkarten und den transformierten Code generiert.

Externe Debugger integrieren

Wenn Sie möchten, können Sie externe Debugger und Tools wie gdb oder lldb in VS Code integrieren.

• Installieren Sie die Debugger-Erweiterung Ihrer Wahl.
• Konfigurieren Sie die Einstellungen des Debuggers in der Datei launch.json.

Debuggen von Multithread-Anwendungen

Beim Debuggen von Multithread-Anwendungen können Sie die Ausführung einzelner Threads steuern.

• Verwenden Sie die „Threads“-Ansicht in der Debug-Seitenleiste, um die Threads während einer Debugging-Sitzung zu verwalten.
• Sie können die Codeausführung für jeden Thread separat anhalten, fortsetzen oder schrittweise durchlaufen.

Multi-Target-Debugging

Zusammengesetzte Startkonfigurationen ermöglichen das gleichzeitige Debuggen mehrerer Ziele. Wenn Sie diese Funktion nutzen möchten, fügen Sie ein „Compounds“-Array mit Konfigurationsnamen zur Gruppierung hinzu. Führen Sie sie aus, indem Sie im Dropdown-Menü „Debuggen“ den Namen der Verbundkonfiguration auswählen.

Konfigurieren Sie mehrere Startkonfigurationen, die auf verschiedene Dienste, Funktionen oder Endpunkte abzielen, um Microservices und serverlose Anwendungen zu debuggen. Verwenden Sie zusammengesetzte Startkonfigurationen, um diese Ziele gemeinsam auszuführen.

Erstellen Sie für Multi-Root-Arbeitsbereiche separate launch.json-Dateien für jeden Ordner. Konfigurieren Sie die Starteinstellungen für jeden Stammordner einzeln, um Projekte separat oder gleichzeitig mithilfe von Compounds zu debuggen.

Fehlerbehebung bei häufigen launch.json-Problemen

Manchmal ist das Debuggen anfällig für eigene Fehler. Schauen wir uns einige häufige Probleme und deren Behebung an.

Fehler bei der Schemavalidierung

Schemavalidierungsfehler treten auf, wenn eine launch.json-Datei ungültige Eigenschaften oder Werte aufweist. So beheben Sie Schemafehler:

• Überprüfen Sie die Fehlermeldungen im Bereich „Probleme“.
• Aktualisieren Sie die Datei launch.json entsprechend den Informationen aus der Fehlermeldung.

Debuggen von Fehlern

Falsche Starteinstellungen können zu Debugging-Fehlern führen.

• Überprüfen Sie Ihre Startkonfigurationen auf falsche Dateipfade.
• Überprüfen Sie fehlende oder falsche Debugger- oder Anforderungstypen.
• Aktualisieren Sie die Einstellungen nach Bedarf.

Diagnostizieren von Problemen mit der Startkonfiguration

So diagnostizieren Sie Probleme mit Startkonfigurationen:

• Aktivieren Sie die Diagnoseprotokollierung, indem Sie die Eigenschaft „trace“ auf „verbose“ setzen.
• Überprüfen Sie die generierten Protokolle in der Debug-Konsole, um etwaige Probleme zu identifizieren und zu beheben.

Tipps für launch.json

Nutzen Sie launch.json optimal mit diesen Tipps:

• Verwenden Sie aussagekräftige Namen für Ihre Startkonfigurationen, um sie leicht identifizierbar zu machen. Diese Vorgehensweise hilft Ihnen, schnell die geeignete Konfiguration zu finden, wenn Sie mit mehreren Debug-Szenarien arbeiten.
• Teilen Sie Startkonfigurationen mit Ihrem Team, indem Sie die Datei launch.json in das Versionskontrollsystem Ihres Projekts einbinden. Jedes Teammitglied kann auf dieselben Debugging-Konfigurationen und -Einstellungen zugreifen.
• Versionskontrollsysteme wie Git können Änderungen an Ihrer launch.json-Datei verfolgen. Mithilfe der Versionskontrolle können Sie zu früheren Konfigurationen zurückkehren und mit anderen Teammitgliedern zusammenarbeiten, indem Sie empfohlene Einstellungen mit ihnen teilen.
• Installieren Sie Erweiterungen, die bestimmte Sprachen, Debugger oder Tools unterstützen, die den Anforderungen des Projekts entsprechen. Konfigurieren Sie die Datei launch.json, um diese Erweiterungen und ihre Funktionen während Debugging-Sitzungen zu verwenden.

Starten Sie das Debuggen

Indem Sie die Leistungsfähigkeit von launch.json nutzen, können Sie Ihr Debugging-Erlebnis so anpassen, dass es am besten zu Ihrem Codierungsstil passt. Dadurch wird die Qualität und Leistung Ihres Codes verbessert.

Wie oft müssen Sie Ihre Starteinstellungen konfigurieren? Habt ihr Konfigurationstipps? Bitte teilen Sie Ihre Erfahrungen im Kommentarbereich unten.