Depura tú código de GO con VS Code

Como programadores constantemente debemos depurar nuestro código en búsqueda de errores, para ello algunas veces utilizamos un logger o imprimimos en terminal el estado de nuestras variables, sin embargo existen herramientas que nos permiten realizar este proceso de forma rápida y con mayor control, hoy te enseñaré a usar el Debugger de VS Code en nuestro código de Go.

¿Qué necesitamos?

1. Instala la Extensión de Go for Visual Studio Code.
2. Instala delve el debugger de Go que utilizaremos. Para ello abre la paleta de comandos de VS Code con la combinación de teclas Ctrl+Shift+P, escribe el comando Go: Install/Update Tools, selecciona dlv, presiona OK para instalar.
3. Crea un archivo de configuración de depuración, para ello luego de instalar delve abre la paleta de comandos y ejecuta el comando Debug: Open launch.json, selecciona la opción Go, esto creará el archivo de configuración si aún no tenías creado uno, el archivo se verá así:

1
2	{
3    // Use IntelliSense to learn about possible attributes.
4    // Hover to view descriptions of existing attributes.
5    // For more information, visit: <https://go.microsoft.com/fwlink/?linkid=830387>
6    "version": "0.2.0",
7    "configurations": [
8        {
9            "name": "Launch",
10            "type": "go",
11            "request": "launch",
12            "mode": "auto",
13            "program": "${fileDirname}",
14            "env": {},
15            "args": []
16        }
17    ]
18}
19

En nuestro caso realizaremos la depuración de código en un archivo ejecutable, así que estableceremos la propiedad mode con el valor exec, y agregaremos la propiedad program donde indicaremos la ruta a nuestro archivo ejecutable, no olvides asignar un nombre que identifique tu configuración de depuración en la propiedad name, esto será útil en el momento de indicarle a VS Code que configuración deseamos ejecutar, nuestras configuración final se verá así:

1
2	{
3    // Use IntelliSense to learn about possible attributes.
4    // Hover to view descriptions of existing attributes.
5    // For more information, visit: <https://go.microsoft.com/fwlink/?linkid=830387>
6    "version": "0.2.0",
7    "configurations": [
8        {
9            "name": "Mi primer debugging en Go",
10            "type": "go",
11            "request": "launch",
12            "mode": "exec",
13            "program": "C:/Users/ajrdrgz/go/src/EDteam/debuggingGo/debuggingGo.exe"
14        }
15    ]
16}
17

Código de ejemplo

Para explicar el funcionamiento del depurador utilizaremos el siguiente código de ejemplo que contiene un error.

1
2	package main
3
4import "fmt"
5
6type course struct {
7	ID   uint   `json:"id"`
8	Name string `json:"name"`
9	Type string `json:"type"`
10}
11
12func getWorkshops(cs []course) (ws []course) {
13	for _, c := range cs {
14		if c.Type == "WORKSHOP" {
15			ws = append(ws, c)
16		}
17	}
18
19	return
20}
21
22func main() {
23	cs := []course{
24		course{ID: 1, Name: "Go desde Cero", Type: "Curso"},
25		course{ID: 2, Name: "JS desde Cero", Type: "Curso"},
26		course{ID: 3, Name: "Metodologías TDD", Type: "Workshop"},
27		course{ID: 4, Name: "Mi primera página Web", Type: "Workshop"},
28		course{ID: 5, Name: "Bases de datos desde Cero", Type: "Curso"},
29	}
30
31	ws := getWorkshops(cs)
32	fmt.Println("La lista de Workshops es:", ws)
33}
34

Se requiere que la función getWorkshops reciba un slice de course que contiene los campos: id, name y type, y retorne un nuevo slice solo con los cursos de tipo Workshop, sin embargo cuando ejecutamos nuestro código el resultado que obtenemos es un slice vacío:

1
2	C:\Users\ajrdrgz\go\src\EDteam\debuggingGo> go build
3C:\Users\ajrdrgz\go\src\EDteam\debuggingGo> .\debuggingGo.exe
4La lista de Workshops es: []
5

¿Cómo funciona?

Ahora que tenemos un error que depurar lo primero que haremos es compilar el código nuevamente, pero esta vez sin optimizaciones para poder depurar el ejecutable correctamente.

1
2C:\Users\ajrdrgz\go\src\EDteam\debuggingGo> go build -gcflags="all=-N -l"
3

Selecciona el icono de Debug en la barra de Actividad o usa la combinación de teclas Ctrl+Shift+D para ver la vista de depuración.

Ahora debemos establecer los breakpoints que son puntos de interrupción en donde se detendrá la ejecución de nuestro código, lo que nos permitirá ver el estado de nuestras variables en ese punto y poder encontrar nuestro problema, también podremos utilizar la sección watch o la consola de depuración para observar y evaluar expresiones.

Estableceremos un breakpoint en la línea 13, donde tenemos la condición que evalúa si el curso es de tipo Workshop, para hacerlo podemos dar click sobre el margen del editor, o usar la tecla F9 que agregará el breakpoint sobre la línea actual, al hacerlo se pintará un circulo rojo en el margen y se incluirá en la sección breakpoints.

Seleccionamos nuestra configuración de depuración desde la lista desplegable ubicada en la parte superior derecha, y damos click en el botón de play para iniciar la depuración, ahora veremos nuestro depurador en acción:

Los elementos que encontramos son:

variables: En esta sección encontramos la lista de variables locales y globales de nuestro código en el breakpoint en el que nos encontramos.

editor: En nuestro editor veremos seleccionado en amarillo el punto de interrupción actual, también podemos hacer hover sobre nuestras variables para ver el estado de las variables en el breakpoint actual.

callstack: En esta sección encontrarás la pila de llamadas de nuestro código y la posición en la que nos encontramos en ella para el breakpoint actual.

barra de herramientas de depuración: Esta contiene las siguientes acciones que nos permiten controlar el flujo de la depuración.

• Continuar / Pausar: Continuar con la ejecución hasta que llegar a otro punto de interrupción o hasta que finalice el programa.
• Paso a Paso: Recorre la línea actual, pero no ingresa en una llamada de función.
• Entrar en: Ejecute la línea de código actual y, si llama a una función, entre en el nuevo ámbito de función.
• Salir de: Salir de un ámbito de la llamada de función. Si este es el alcance superior, continuará y terminará el programa.
• Reiniciar: reinicia la aplicación desde el principio.
• Detener: detiene el depurador y cancela el programa en ejecución.

Tenemos dos elementos más watch y la consola de depuración en donde podemos incluir expresiones, allí incluiremos las siguientes: c.Type para obtener el valor del tipo del curso actual y c.Type == "WORKSHOP" para ver el resultado que nos esta devolviendo la condicional de la línea 13.

Nuestra expresión siempre nos devuelve false si damos click en la acción Paso a Paso podemos ver el siguiente elemento del slice para revisar cada uno de ellos. Al finalizar nuestra ejecución la variable ws (slice de workshops) siempre esta vacío.

Si revisas con atención la sección watch verás que c.Type tiene el valor de Workshop, así que la expresión que estamos evaluando en la línea 13 es equivalente a Workshop == WORKSHOP, por lo que debemos convertir c.Type a mayúsculas para corregir nuestro problema, realizando este cambio veremos como los cursos tipo workshop se van agregando en la variable ws, ahora nuestro código funciona correctamente.

Referencias

https://code.visualstudio.com/docs/editor/debugging

https://vscode.rocks/debugging/

https://github.com/Microsoft/vscode-go/wiki/Debugging-Go-code-using-VS-Code

Aprende Go Desde Cero con EDteam. Crea aplicaciones robustas y de alto rendimiento para cualquier sistema operativo con el lenguaje de Google. Entra a https://ed.team/cursos/go