Paano Buksan ang launch.json sa VS Code

Ang epektibong pag-debug at kalidad ng code ay hindi mapaghihiwalay na mga konsepto sa pagbuo ng software. Pangunahing kontrolado ng launch.json file ang pag-debug na functionality ng Visual Studio (VS) Code. Hinahayaan ng file na ito ang mga developer na i-configure at pamahalaan ang kanilang mga setting ng pag-debug ayon sa kanilang pananaw.

Gagabayan ka ng artikulong ito sa pagbubukas at pamamahala sa launch.json file para sa pinakamainam na pag-debug.

Binubuksan ang launch.json sa Visual Studio Code

Upang i-configure at pamahalaan ang mga setting ng pag-debug ng VS Code, kakailanganin mo ng access sa launch.json file. Ang file na ito ay gumaganap ng isang mahalagang papel sa pag-customize ng pag-debug.

Buksan ang Visual Studio Code.
Pindutin ang Ctrl + Shift + P upang buksan ang Command Palette.
I-type ang “Open launch.json” sa Command Palette at pindutin ang “Enter.” Dapat nitong buksan ang launch.json file para sa iyo.
Kung hindi magbubukas ang launch.json file, i-verify na ang folder na '.vscode' ay umiiral sa root folder ng iyong proyekto.
Kung wala ito, gumawa ng bagong folder na tinatawag na '.vscode' sa loob ng iyong folder ng User.
Gumawa ng bagong 'launch.json' na file at ilagay ito sa folder na ito.

Ang launch.json file ay handang i-configure pagkatapos itong paganahin.

Pangkalahatang-ideya ng Istraktura ng Launch.json

Ipinapakita ng launch.json ang mga seksyong 'bersyon' at 'mga configuration.' Ang seksyong 'mga configuration' ay isang array na naglalaman ng iba't ibang mga opsyon sa pag-debug, na gagamitin mo upang i-configure ang iyong scheme ng pag-debug.

Ang bawat bagay sa array ng 'mga configuration' ay kumakatawan sa isang senaryo ng pag-debug. Ang mga bagay na ito ay may mga katangian na tumutukoy sa kapaligiran ng pag-debug, tulad ng mga setting ng wika, programa, at debugger.

Ang ilang karaniwang property na makikita mo sa mga configuration ng launch.json ay kinabibilangan ng:

“pangalan” – Isang pangalang madaling mambabasa para sa configuration upang matukoy ito sa dropdown na menu.
“type” – Tinutukoy ang uri ng debugger (gaya ng “node,” “python,” o “cppvsdbg”).
“kahilingan” – Tinutukoy ang uri ng kahilingan, alinman sa “ilunsad” (upang magsimula ng bagong instance) o “i-attach” (upang ilakip ang debugger sa isang kasalukuyang proseso).
“program” – File path para sa file na gusto mong i-debug.
“args” – Isang hanay ng mga argumento sa command-line na ipapasa sa program habang nagde-debug.
“preLaunchTask” – Isang gawain na tatakbo bago simulan ang debugger.

Ang pag-unawa sa istraktura ng launch.json file ay nagbibigay-daan sa iyong malaman kung aling mga opsyon ang babaguhin at kung alin ang iiwan habang nagko-customize ng iyong kapaligiran sa pag-debug.

Pag-configure ng Mga Setting ng Paglunsad para sa Iba't ibang Wika

Ang mga hakbang para sa pag-configure ng mga setting ng paglunsad ay maaaring bahagyang mag-iba depende sa wika. Narito ang mga hakbang para sa ilang tanyag na wika.

JavaScript at TypeScript

Gumawa ng bagong launch.json file at i-configure ang 'type' na property bilang 'node' para sa JavaScript o 'pwa-node' para sa TypeScript.
Itakda ang “request” property sa “launch” o “attach.”
Dapat mong tukuyin ang entry point file gamit ang 'program' property.

sawa

I-install ang Python interpreter at extension para sa Visual Studio Code.
Itakda ang “type” property sa “python” sa isang bagong launch.json file.
I-configure ang property na 'kahilingan' bilang 'launch' o 'attach.'
Tukuyin ang Python file na tatakbo gamit ang property na 'program'.
Maaaring kailanganin mong itakda ang property na 'pythonPath' sa path ng Python interpreter kung wala ito sa default na lokasyon.

C# at .NET Core

I-install ang C# extension para sa Visual Studio Code.
Sa bagong launch.json file, itakda ang “type” property sa “coreclr” para sa .NET Core o “clr” para sa .NET Framework.
I-configure ang property na 'kahilingan' bilang 'launch' o 'attach.'
Tukuyin ang entry point file gamit ang property na 'program'.
Itakda ang property na 'cwd' sa working directory ng kasalukuyang proyekto kung kinakailangan.

Java

I-install ang Java Extension Pack.
Gumawa ng bagong launch.json file, at itakda ang “type” property sa “java.”
I-configure ang property na 'kahilingan' bilang 'launch' o 'attach.'
Tukuyin ang pangunahing klase na may 'mainClass' na pag-aari.
Itakda ang property na 'projectName' sa pangalan ng iyong proyekto sa Java.
I-configure ang property na 'classpath' para isama ang mga Java library na iyong gagamitin sa panahon ng iyong pag-develop ng Java.

Pag-debug ng Mga Recipe ng Configuration

Sinasaklaw ng sumusunod na seksyon ang iba't ibang mga recipe ng configuration ng pag-debug.

Pag-attach ng Debugger sa isang Tumatakbong Proseso

Upang ilakip ang debugger sa isang tumatakbong proseso:

Itakda ang “request” property sa “attach.”
Piliin ang process ID o filter para mahanap ang prosesong ide-debug.

Remote Application Debugging

Para sa malayuang pag-debug ng application:

Gumamit ng 'remote' na uri.
Ibigay ang address, port, at posibleng impormasyon ng pagpapatotoo ng host para makapagtatag ng koneksyon.

Pag-debug sa Mga Pagsusuri sa Unit at Pagsubok na Suite

Kapag nagde-debug ng mga pagsubok sa unit at mga suite ng pagsubok:

Gumamit ng configuration na kinabibilangan ng test framework at mga setting para i-debug ang mga unit test at test suite.
Tukuyin ang test suite o mga indibidwal na test file sa property na 'program' o 'args' para sa pag-target ng mga partikular na pagsubok.

Pagpapasa sa mga variable ng kapaligiran

Ang property na 'env' sa launch.json ay maaaring magpasa ng mga variable ng kapaligiran sa iyong application habang nagde-debug. Ang property na ito ay isang bagay na naglalaman ng mga pares ng key-value para sa mga variable ng kapaligiran na gusto mong itakda.

Advanced na Pag-debug

Tuklasin natin ang ilang advanced na mga diskarte sa pag-debug para sa mga user na gustong mag-squeeze ng kaunti pang kapangyarihan sa mga debug file.

Mga Kondisyong Breakpoint at Logpoint

Ang mga kondisyon na breakpoint at logpoint ay nagpapahusay sa pag-debug sa pamamagitan ng pag-pause o pag-log ng mga mensahe sa ilalim lamang ng mga partikular na kundisyon. Upang gamitin ang mga ito:

Mag-right-click sa numero ng linya kung saan mo gustong magtakda ng breakpoint o logpoint.
Piliin ang 'Magdagdag ng Conditional Breakpoint' o 'Magdagdag ng Logpoint.'
Ilagay ang kundisyon o mensahe para ma-trigger ang pagkilos.

Pinagmulan na Mapa

Binibigyang-daan ka ng mga source na mapa na i-debug ang code na binago o pinaliit.

Itakda ang property na “sourceMap” sa “true” sa iyong configuration ng launch.json para gumamit ng mga source na mapa.
Tiyaking bumubuo ang iyong proseso ng pagbuo ng mga mapagkukunang mapa at ang binagong code.

Pagsasama ng Mga Panlabas na Debugger

Maaari mong isama ang mga panlabas na debugger at tool, tulad ng gdb o lldb, sa VS Code kung gusto mo.

I-install ang napiling extension ng debugger.
I-configure ang mga setting ng debugger sa launch.json file.

Pag-debug ng Mga Multi-Threaded na Application

Kapag nagde-debug ng mga multi-threaded na application, maaari mong kontrolin ang pagpapatupad ng mga indibidwal na thread.

Gamitin ang view ng 'mga thread' sa sidebar ng Debug upang pamahalaan ang mga thread sa panahon ng sesyon ng pag-debug.
Maaari mong i-pause, ipagpatuloy, o hakbangin ang pagpapatupad ng code para sa bawat thread nang hiwalay.

Multi-Target na Pag-debug

Ang mga pagsasaayos ng paglulunsad ng compound ay nagbibigay-daan sa pag-debug ng maraming target nang sabay-sabay. Kung gusto mong samantalahin ang feature na ito, magdagdag ng array ng 'compounds' na may mga pangalan ng configuration upang igrupo. Patakbuhin ang mga ito sa pamamagitan ng pagpili sa pangalan ng compound configuration mula sa dropdown na menu ng Debug.

I-configure ang maraming configuration ng paglunsad na nagta-target ng iba't ibang serbisyo, function, o endpoint para i-debug ang mga microservice at serverless na application. Gumamit ng mga configuration ng compound launch para patakbuhin ang mga target na ito nang magkasama.

Para sa mga multi-root na workspace, gumawa ng hiwalay na launch.json file para sa bawat folder. I-configure ang mga setting ng paglunsad para sa bawat root folder nang paisa-isa upang i-debug ang mga proyekto nang hiwalay o sabay-sabay gamit ang mga compound.

Pag-troubleshoot ng Mga Karaniwang Isyu sa launch.json

Kung minsan, ang pag-debug ay madaling kapitan ng sarili nitong hanay ng mga bug. Tingnan natin ang ilang karaniwang isyu at kung paano i-troubleshoot ang mga ito.

Mga Error sa Pagpapatunay ng Schema

Nagaganap ang mga error sa pagpapatunay ng schema kapag may mga di-wastong katangian o value ang isang launch.json file. Upang ayusin ang mga error sa schema:

Suriin ang mga mensahe ng error mula sa panel ng Mga Problema.
I-update ang launch.json file ayon sa impormasyon mula sa mensahe ng error.

Mga Pagkabigo sa Pag-debug

Ang mga maling setting ng paglulunsad ay maaaring magdulot ng mga pagkabigo sa pag-debug.

Suriin ang iyong mga configuration ng paglunsad para sa mga maling path ng file.
I-verify ang nawawala o maling debugger o mga uri ng kahilingan.
I-update ang mga setting kung kinakailangan.

Pag-diagnose ng Mga Isyu sa Configuration ng Paglunsad

Upang masuri ang mga isyu sa mga configuration ng paglunsad:

paano i-block ang isang tao sa facebook sa iphone?

I-enable ang diagnostic logging sa pamamagitan ng pagtatakda ng 'trace' property sa 'verbose.'
Suriin ang mga nabuong log sa Debug Console upang matukoy at ayusin ang anumang mga problema.

Mga tip para sa launch.json

Gamitin ang launch.json nang mahusay sa mga tip na ito:

Gumamit ng mga makabuluhang pangalan para sa iyong mga configuration sa paglulunsad para madaling matukoy ang mga ito. Tinutulungan ka ng kasanayang ito na mahanap ang naaangkop na configuration nang mabilis kapag nagtatrabaho sa maraming mga sitwasyon sa pag-debug.
Ibahagi ang mga configuration ng paglunsad sa iyong team sa pamamagitan ng pagsasama ng launch.json file sa version control system ng iyong proyekto. Maa-access ng bawat miyembro ng team ang parehong mga configuration at setting ng pag-debug.
Maaaring subaybayan ng mga system ng pagkontrol ng bersyon tulad ng Git ang mga pagbabago sa iyong launch.json file. Maaari mong gamitin ang kontrol ng bersyon upang bumalik sa mga nakaraang configuration at makipagtulungan sa iba pang miyembro ng team sa pamamagitan ng pagbabahagi ng mga inirerekomendang setting sa kanila.
Mag-install ng mga extension na sumusuporta sa mga partikular na wika, debugger, o tool na angkop sa mga hinihingi ng proyekto. I-configure ang launch.json file upang magamit ang mga extension na ito at ang mga feature ng mga ito sa panahon ng mga session ng pag-debug.

Ilunsad sa Pag-debug

Sa pamamagitan ng paggamit sa kapangyarihan ng launch.json, maaari mong isaayos ang iyong karanasan sa pag-debug upang pinakamahusay na tumugma sa iyong istilo ng coding. Mapapahusay nito ang kalidad at pagganap ng iyong code.

Gaano kadalas mo kailangang i-configure ang iyong mga setting ng paglunsad? Mayroon ka bang anumang mga tip sa pagsasaayos? Mangyaring ibahagi ang iyong mga karanasan sa seksyon ng komento sa ibaba.