Capítulo 1. Configurar tu entorno Go
Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: translation-feedback@oreilly.com
Todo lenguaje de programación necesita un entorno de desarrollo, y Go no es una excepción. Si ya has creado un programa Go o dos, entonces tienes un entorno de trabajo, pero puede que te hayas perdido algunas de las técnicas y herramientas más novedosas. Si es la primera vez que configuras Go en tu ordenador, no te preocupes; es fácil instalar Go y sus herramientas de apoyo. Tras configurar el entorno y verificarlo, construirás un programa sencillo, conocerás las distintas formas de construir y ejecutar código Go, y luego explorarás algunas herramientas y técnicas que facilitan el desarrollo de Go.
Instalar las Herramientas Go
Para construir código Go, necesitas descargar e instalar las herramientas de desarrollo Go. Puedes encontrar la última versión de las herramientas en la página de descargas del sitio web de Go. Elige la descarga correspondiente a tu plataforma e instálala. El instalador .pkg para Mac y el instalador .msi para Windows instalan automáticamente Go en la ubicación correcta, eliminan cualquier instalación antigua y colocan el binario de Go en la ruta ejecutable por defecto.
Consejo
Si eres desarrollador de Mac, puedes instalar Go utilizando Homebrew con el comando brew install go. Los desarrolladores de Windows que utilicen Chocolatey pueden instalar Go con el comando choco install golang.
Los distintos instaladores de Linux y BSD son archivos TAR comprimidos con gzip y se expanden a un directorio llamado go. Copia este directorio en /usr/local y añade /usr/local/go/bin a tu $PATH para que el comando go sea accesible:
$ tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz $ echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.bash_profile $ source $HOME/.bash_profile
Puede que necesites permisos de root para escribir en /usr/local. Si el comando tar falla, vuelve a ejecutarlo con sudo tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz.
Nota
Los programas Go se compilan en un único binario nativo y no requieren la instalación de ningún software adicional para ejecutarlos. Esto contrasta con lenguajes como Java, Python y JavaScript, que requieren que instales una máquina virtual para ejecutar tu programa. Utilizar un único binario nativo facilita mucho la distribución de programas escritos en Go. Este libro no cubre los contenedores, pero los desarrolladores que utilizan Docker o Kubernetes a menudo pueden empaquetar una aplicación Go dentro de una imagen scratch o distroless. Puedes encontrar más detalles en la entrada del blog de Geert Baeke "Distroless or Scratch for Go Apps".
Puedes validar que tu entorno está configurado correctamente abriendo un terminal o símbolo del sistema y escribiendo:
$ go version
Si todo está configurado correctamente, deberías ver algo como esto impreso:
go version go1.20.5 darwin/arm64
Esto te indica que se trata de la versión 1.20.5 de Go en macOS. (Darwin es el sistema operativo en el que se basa macOS, y arm64 es el nombre de los chips de 64 bits basados en los diseños de ARM). En Linux x64, verías
go version go1.20.5 linux/amd64
Solución de problemas de tu instalación Go
Si recibes un error en lugar del mensaje de la versión, es probable que no tengas go en tu ruta de ejecutables, o que tengas otro programa llamado go en tu ruta. En macOS y otros sistemas tipo Unix, utiliza which go para ver el comando go que se está ejecutando, si lo hay. Si no se devuelve nada, tienes que arreglar tu ruta ejecutable.
Si estás en Linux o BSD, es posible que hayas instalado las herramientas de desarrollo Go de 64 bits en un sistema de 32 bits o las herramientas de desarrollo para la arquitectura de chip equivocada.
Ir a Herramientas
A todas las herramientas de desarrollo Go se accede mediante el comando go. Además de go version, hay un compilador (go build), un formateador de código (go fmt), un gestor de dependencias (go mod), un ejecutor de pruebas (go test), una herramienta que busca errores comunes de codificación (go vet), y mucho más. Se tratan en detalle en los capítulos 10, 11 y 15. Por ahora, echemos un vistazo rápido a las herramientas más utilizadas escribiendo la primera aplicación favorita de todos: "¡Hola, mundo!"
Nota
Desde la introducción de Go en 2009, se han producido varios cambios en la forma en que los desarrolladores de Go organizan su código y sus dependencias. Debido a esta agitación, hay muchos consejos contradictorios, y la mayoría de ellos están obsoletos (por ejemplo, puedes ignorar con seguridad las discusiones sobre GOROOT y GOPATH).
Para el desarrollo Go moderno, la regla es sencilla: eres libre de organizar tus proyectos como mejor te parezca y almacenarlos donde quieras.
Tu primer programa Go
Vamos a repasar los fundamentos de la escritura de un programa Go. Por el camino, verás las partes que componen un programa Go sencillo. Puede que aún no lo entiendas todo, y no pasa nada; ¡para eso está el resto del libro!
Hacer un módulo Go
Lo primero que tienes que hacer es crear un directorio que contenga tu programa. Llámalo ch1. En la línea de comandos, introduce el nuevo directorio. Si el terminal de tu ordenador utiliza bash o zsh, tendrá el siguiente aspecto:
$ mkdir ch1 $ cd ch1
Dentro del directorio, ejecuta el comando go mod init para marcar este directorio como módulo Go:
$ go mod init hello_world go: creating new go.mod: module hello_world
Aprenderás más sobre qué es un módulo en el Capítulo 10, pero por ahora, todo lo que necesitas saber es que un proyecto Go se llama módulo. Un módulo no es sólo código fuente. También es una especificación exacta de las dependencias del código dentro del módulo. Cada módulo tiene un archivo go.mod en su directorio raíz. Ejecutar go mod init crea este archivo por ti. El contenido de un archivo go.mod básico es el siguiente:
module hello_world go 1.20
El archivo go. mod declara el nombre del módulo, la versión mínima compatible de Go para el módulo y cualquier otro módulo del que dependa tu módulo. Puedes pensar que es similar al archivo requirements.txt utilizado por Python o al Gemfile utilizado por Ruby.
No debes editar el archivo go.mod directamente. En su lugar, utiliza los comandos go get y go mod tidy para gestionar los cambios en el archivo. De nuevo, todo lo relacionado con los módulos se trata en el Capítulo 10.
ir a construir
¡Ahora vamos a escribir algo de código! Abre un editor de texto, introduce el siguiente texto y guárdalo dentro de ch1 con el nombre de archivo hola.go:
packagemainimport"fmt"funcmain(){fmt.Println("Hello, world!")}
(Sí, la indentación en este ejemplo de código parece descuidada: ¡eso es lo que quería hacer! Dentro de un momento verás por qué).
Repasemos rápidamente las partes del archivo Go que has creado. La primera línea es una declaración de paquete. Dentro de un módulo Go, el código se organiza en uno o más paquetes. El paquete main de un módulo Go contiene el código que inicia un programa Go.
A continuación hay una declaración de importación. La declaración enumera los paquetes a los que se hace referencia en este archivo. Estás utilizando una función del paquete (normalmente se pronuncia "fumpt") de la biblioteca estándar, así que enumeras el paquete aquí. A diferencia de otros lenguajes, Go sólo importa paquetes completos. No puedes limitar la importación a tipos, funciones, constantes o variables concretas dentro de un paquete. import fmt
Todos los programas Go parten de la función main del paquete main. Declaras esta función con func main() y una llave izquierda. Al igual que Java, JavaScript y C, Go utiliza llaves para marcar el inicio y el final de los bloques de código.
El cuerpo de la función consta de una sola línea. Dice que estás llamando a la función Println del paquete fmt con el argumento "Hello, world!". Como desarrollador experimentado, probablemente puedas adivinar lo que hace esta llamada a la función.
Una vez guardado el archivo, vuelve a tu terminal o símbolo del sistema y escribe
$ go build
Esto crea un ejecutable llamado hello_world (o hello_world.exe en Windows) en el directorio actual. Ejecútalo y, como era de esperar, verás Hello, world! impreso en la pantalla:
$ ./hello_world Hello, world!
El nombre del binario coincide con el nombre de la declaración del módulo. Si quieres un nombre distinto para tu aplicación, o si quieres almacenarlo en una ubicación diferente, utiliza la bandera -o. Por ejemplo, si quisieras compilar el código en un binario llamado "hola", utilizarías lo siguiente:
$ go build -o hello
En "Utilizar go run para probar pequeños programas", trataré otra forma de ejecutar un programa Go.
ir a fmt
Uno de los principales objetivos de diseño de Go era crear un lenguaje que te permitiera escribir código de forma eficiente. Esto significaba tener una sintaxis sencilla y un compilador rápido. También llevó a los autores de Go a reconsiderar el formato del código. La mayoría de los lenguajes permiten una gran flexibilidad en la forma de formatear el código. Go no. Imponer un formato estándar hace mucho más fácil escribir herramientas que manipulen el código fuente. Esto simplifica el compilador y permite crear algunas herramientas ingeniosas para generar código.
También hay un beneficio secundario. Los desarrolladores han perdido históricamente cantidades extraordinarias de tiempo en guerras de formatos. Dado que Go define una forma estándar de formatear el código, los desarrolladores de Go evitan las discusiones sobre el estilo de las llaves y las tabulaciones frente a los espacios. Por ejemplo, los programas Go utilizan tabulaciones para la indentación, y es un error de sintaxis si la llave de apertura no está en la misma línea que la declaración o el comando que inicia el bloque.
Nota
Muchos desarrolladores de Go piensan que el equipo de Go definió un formato estándar como forma de evitar discusiones entre desarrolladores y descubrió las ventajas de las herramientas más tarde. Sin embargo, Russ Cox, jefe de desarrollo de Go, ha declarado públicamente que la mejora de las herramientas fue su motivación original.
Las herramientas de desarrollo Go incluyen un comando, go fmt, que corrige automáticamente los espacios en blanco de tu código para que coincidan con el formato estándar. Sin embargo, no puede corregir las llaves en la línea incorrecta. Ejecútalo con lo siguiente:
$ go fmt ./... hello.go
Si utilizas ./..., le dirás a la herramienta Go que aplique el comando a todos los archivos del directorio actual y a todos los subdirectorios. Volverás a verlo cuando aprendas más herramientas Go.
Si abres hola.go, verás que la línea con fmt.Println está ahora correctamente sangrada con una sola tabulación.
ir al veterinario
En una clase de errores, el código es sintácticamente válido pero muy probablemente incorrecto. La herramienta go incluye un comando llamado go vet para detectar este tipo de errores. Añade uno al programa y observa cómo se detecta. Cambia la línea fmt.Println de hola.go por la siguiente:
fmt.Printf("Hello, %s!\n")
Nota
fmt.Printf es similar a printf en C, Java, Ruby y muchos otros lenguajes. Si no has visto fmt.Printf antes, es una función con una plantilla como primer parámetro, y valores para los marcadores de posición de la plantilla en el resto deparámetros.
En este ejemplo, tienes una plantilla ("Hello, %s!\n") con un marcador de posición %s, pero no se ha especificado ningún valor para el marcador de posición. Este código compilará y se ejecutará, pero no es correcto. Una de las cosas que detecta go vet es si existe un valor para cada marcador de posición en una plantilla de formato. Ejecuta go vet en el código modificado, y encontrará un error:
$ go vet ./... # hello_world ./hello.go:6:2: fmt.Printf format %s reads arg #1, but call has 0 args
Ahora que go vet ha encontrado el error, puedes arreglarlo fácilmente. Cambia la línea 6 de hola.go por
fmt.Printf("Hello, %s!\n","world")
Aunque go vet detecta varios errores comunes de programación, hay cosas que no puede detectar. Por suerte, hay herramientas de calidad del código Go de terceros que pueden llenar ese vacío. Algunas de las herramientas de calidad del código más populares se tratan en "Uso de escáneres de calidad del código".
Consejo
Del mismo modo que debes ejecutar go fmt para asegurarte de que tu código tiene el formato adecuado, ejecuta go vet para buscar posibles errores en el código válido. Estos comandos son sólo el primer paso para asegurarte de que tu código es de alta calidad. Además de los consejos de este libro, todos los desarrolladores Go deberían leer Go Eficaz y la página Comentarios de la Revisión del Código en la wiki de Go para comprender cómo es el código Go idiomático.
Elige tus herramientas
Aunque hayas escrito un pequeño programa Go utilizando nada más que un editor de texto y el comando go, probablemente querrás herramientas más avanzadas cuando trabajes enproyectos más grandes. Los IDE de Go ofrecen muchas ventajas sobre los editores de texto, como el formateo automático al guardar, el completado de código, la comprobación de tipos, el informe de errores y la depuración integrada. Existen excelentes herramientas de desarrollo Go para la mayoría de editores de texto e IDEs. Si aún no tienes una herramienta favorita, dos de los entornos de desarrollo Go más populares son Visual Studio Code y GoLand.
Código de Visual Studio
Si buscas un entorno de desarrollo gratuito , Visual Studio Code de Microsoft es tu mejor opción. Desde su lanzamiento en 2015, VS Code se ha convertido en el editor de código fuente más popular entre los desarrolladores. No incluye soporte para Go, pero puedes convertirlo en un entorno de desarrollo Go descargando la extensión Go de la galería de extensiones.
La compatibilidad de VS Code con Go se basa en extensiones de terceros a las que se accede a través de su Marketplace incorporado. Esto incluye las herramientas de desarrollo Go, el depurador Delve y gopls, un servidor de lenguaje Go desarrollado por el equipo Go. Aunque tienes que instalar tú mismo el compilador Go, la extensión Go instalará Delve y gopls por ti.
Nota
¿Qué es un servidor de lenguaje? Es una especificación estándar para una API que permite a los editores implementar un comportamiento de edición inteligente, como la finalización de código, comprobaciones de calidad o encontrar todos los lugares en los que se utiliza una variable o función en tu código. Puedes obtener más información sobre los servidores de idiomas y sus capacidades consultando el sitio web del Protocolo de Servidores de Idiomas.
Una vez configuradas tus herramientas, puedes abrir tu proyecto y trabajar con él. La Figura 1-1 te muestra el aspecto que debe tener la ventana de tu proyecto. "Primeros pasos con VS Code Go" es un tutorial que muestra la extensión VS Code Go.
Figura 1-1. Código de Visual Studio
GoLand
GoLand es el IDE específico para Go de JetBrains, . Aunque JetBrains es más conocido por sus herramientas centradas en Java, GoLand es un excelente entorno de desarrollo Go. Como puedes ver en la Figura 1-2, la interfaz de usuario de GoLand es similar a la de IntelliJ, PyCharm, RubyMine, WebStorm, Android Studio o cualquiera de los otros IDE de JetBrains. Su compatibilidad con Go incluye refactorización, resaltado de sintaxis, completado y navegación de código, ventanas emergentes de documentación, depurador, cobertura de código y mucho más. Además de la compatibilidad con Go, GoLand incluye herramientas JavaScript/HTML/CSS y de bases de datos SQL. A diferencia de VS Code, GoLand no requiere que instales un plug-in para que funcione.
Figura 1-2. GoLand
Si ya estás suscrito a IntelliJ Ultimate, puedes añadir compatibilidad con Go mediante un plug-in. Aunque GoLand es un software comercial, JetBrains tiene un Programa de Licencia Gratuita para estudiantes y colaboradores principales de código abierto. Si no puedes optar a una licencia gratuita, tienes a tu disposición una prueba gratuita de 30 días. Después, tendrás que pagar por GoLand.
El parque infantil Go
Hay otra herramienta importante para el desarrollo Go, , pero es una que no se instala. Visita The Go Playground y verás una ventana parecida a la de la Figura 1-3. Si has utilizado un entorno de línea de comandos como irb, node, o python, verás que The Go Playground tiene una sensación similar. Te ofrece un lugar donde probar y compartir pequeños programas. Introduce tu programa en la ventana y pulsa el botón Ejecutar para ejecutar el código. El botón Formatear ejecuta go fmt en tu programa y actualiza tus importaciones. El botón Compartir crea una URL única que puedes enviar a otra persona para que eche un vistazo a tu programa o para que vuelva a tu código en el futuro (las URL han demostrado ser persistentes durante mucho tiempo, pero yo no confiaría en el Patio de recreo como tu repositorio de código fuente).
Figura 1-3. El patio de recreo Go
Como puedes ver en la Figura 1-4, puedes simular varios archivos separando cada uno de ellos con una línea parecida a -- filename.go --. Incluso puedes crear subdirectorios simulados incluyendo un / en el nombre del archivo, como -- subdir/my_code.go --.
Ten en cuenta que The Go Playground está en el ordenador de otra persona (en concreto, en el ordenador de Google), por lo que no tienes total libertad. Te permite elegir entre varias versiones de Go (normalmente la versión actual, la anterior y la última versión de desarrollo). Sólo puedes establecer conexiones de red con localhost, y los procesos que se ejecutan durante demasiado tiempo o utilizan demasiada memoria se detienen. Si tu programa depende del tiempo, debes tener en cuenta que el reloj está ajustado al 10 de noviembre de 2009, 23:00:00 UTC (la fecha del anuncio inicial de Go). Incluso con estas limitaciones, The Go Playground es una forma útil de probar nuevas ideas sin crear un nuevo proyecto localmente. A lo largo de este libro, encontrarás enlaces a The Go Playground para que puedas ejecutar ejemplos de código sin copiarlos en tu ordenador.
Advertencia
¡No introduzcas información sensible (como datos de identificación personal, contraseñas o claves privadas) en tu zona de juegos! Si haces clic en el botón Compartir, la información se guarda en los servidores de Google y es accesible para cualquiera que tenga laURL asociadapara Compartir. Si lo haces por accidente, ponte en contacto con Google ensecurity@golang.org indicando la URL y la razón por la que es necesario eliminar el contenido.
Figura 1-4. Go Playground admite varios archivos
Makefiles
Un IDE es agradable de usar, pero es difícil de automatizar. El desarrollo de software moderno se basa en compilaciones repetibles y automatizables que puedan ser ejecutadas por cualquiera, en cualquier lugar y en cualquier momento. Exigir este tipo de herramientas es una buena práctica de ingeniería de software. Evita la vieja situación en la que un desarrollador se absuelve de cualquier problema de compilación con un encogimiento de hombros y la afirmación: "¡Funciona en mi máquina!". La forma de hacerlo es utilizar algún tipo de script para especificar tus pasos de compilación. Los desarrolladores de Go han adoptado como solución. Permite a los desarrolladores especificar un conjunto de operaciones necesarias para construir un programa y el orden en que deben realizarse los pasos. Puede que no conozcas , pero se utiliza para construir programas en sistemas Unix desde 1976. make make
Crea un archivo llamado Makefile en el directorio ch1 con el siguiente contenido:
.DEFAULT_GOAL:=build.PHONY:fmtvetbuildfmt:go fmt ./...vet:fmtgo vet ./...build:vetgo build
Aunque no hayas visto antes un Makefile, averiguar qué está pasando no es demasiado difícil. Cada operación posible se denomina objetivo. El .DEFAULT_GOAL define qué objetivo se ejecuta cuando no se especifica ningún objetivo. En este caso, el objetivo por defecto es build. A continuación tienes las definiciones de los objetivos. La palabra antes de los dos puntos (:) es el nombre del objetivo. Cualquier palabra después del objetivo (como vet en la línea build: vet) son los otros objetivos que deben ejecutarse antes de que se ejecute el objetivo especificado. Las tareas que realiza el objetivo se encuentran en las líneas con sangría situadas después del objetivo. La línea .PHONY evita que make se confunda si un directorio o archivo de tu proyecto tiene el mismo nombre que uno de los objetivos de la lista.
Ejecuta make y deberías ver la siguiente salida:
$ make go fmt ./... go vet ./... go build
Introduciendo un solo comando se formatea el código correctamente, se comprueba que no contenga errores no evidentes y se compila. También puedes vetar el código con make vet, o simplemente ejecutar el formateador con make fmt. Puede que no parezca una gran mejora, pero si te aseguras de que el formateo y la comprobación siempre se realizan antes de que un desarrollador (o un script que se ejecute en un servidor de compilación de integración continua) inicie una compilación, no te perderás ningún paso.
Un inconveniente de los Makefiles es que son excesivamente quisquillosos. Debes sangrar los pasos de un objetivo con un tabulador. Además, no son compatibles con Windows. Si desarrollas Go en un ordenador con Windows, primero tienes que instalar make. La forma más sencilla de hacerlo es instalar primero un gestor de paquetes como Chocolatey y luego utilizarlo para instalar make (para Chocolatey, el comando es choco install make).
Si quieres aprender más sobre cómo escribir Makefiles, hay un buen tutorial de Chase Lambert, pero utiliza un poco de C para explicar los conceptos.
Puedes encontrar el código de este capítulo en el repositorio del Capítulo 1 de este libro.
La promesa de compatibilidad Go
Como ocurre con todos los lenguajes de programación, las herramientas de desarrollo Go se actualizan periódicamente. Desde Go 1.2, se ha publicado una nueva versión aproximadamente cada seis meses. También se publican parches con correcciones de errores y seguridad cuando es necesario. Dados los rápidos ciclos de desarrollo y el compromiso del equipo Go con la compatibilidad con versiones anteriores, las versiones Go tienden a ser incrementales más que expansivas. La Promesa de Compatibilidad de Go es una descripción detallada de cómo el equipo Go planea evitar romper el código Go. Dice que no habrá cambios que rompan la compatibilidad con el lenguaje o la biblioteca estándar de ninguna versión de Go que empiece por 1, a menos que el cambio sea necesario para corregir un error o un problema de seguridad. En su charla magistral de la GopherCon 2022 "Compatibilidad: cómo los programas Go siguen funcionando", Russ Cox habla de todas las formas en que el Equipo Go trabaja para evitar que el código Go se rompa. Dice: "Creo que dar prioridad a la compatibilidad fue la decisión de diseño más importante que tomamos en Go 1".
Esta garantía no se aplica a los comandos go. Ha habido cambios incompatibles con el pasado en las banderas y la funcionalidad de los comandos go, y es totalmente posible que vuelva a ocurrir.
Estar al día
Los programas Go se compilan en un binario nativo independiente , por lo que no tienes que preocuparte de que la actualización de tu entorno de desarrollo pueda hacer que fallen tus programas actualmente implementados. Puedes tener programas compilados con diferentes versiones de Go ejecutándose simultáneamente en el mismo ordenador o máquina virtual.
Cuando estés listo para actualizar las herramientas de desarrollo Go instaladas en tu ordenador, los usuarios de Mac y Windows tienen el camino más fácil. Los que instalaron con brew ochocolatey pueden utilizar esas herramientas para actualizar. Los que utilizaron los instaladores de https://golang.org/dl pueden descargar el último instalador, que elimina la versión antigua cuando instala la nueva.
Los usuarios de Linux y BSD tienen que descargar la última versión, mover la versión antigua a un directorio de copia de seguridad, descomprimir la nueva versión y, a continuación, borrar la versión antigua:
$ mv /usr/local/go /usr/local/old-go $ tar -C /usr/local -xzf go1.20.6.linux-amd64.tar.gz $ rm -rf /usr/local/old-go
Nota
Técnicamente, no necesitas trasladar la instalación existente a una nueva ubicación; podrías simplemente borrarla e instalar la nueva versión. Sin embargo, esto entra en la categoría de "más vale prevenir que curar". Si algo va mal al instalar la nueva versión, es bueno tener a mano la anterior.
Ejercicios
Cada capítulo tiene ejercicios al final para que pongas a prueba las ideas que cubro. Puedes encontrar las respuestas a estos ejercicios en el repositorio del Capítulo 1.
-
Coge el programa "¡Hola, mundo!" y ejecútalo en The Go Playground. Comparte un enlace al código en el patio de recreo con un compañero de trabajo al que le gustaría aprender Go.
-
Añade un objetivo al Makefile llamado
cleanque elimine el binariohello_worldy cualquier otro archivo temporal creado porgo build. Echa un vistazo a la documentación del comando Go para encontrar un comandogoque te ayude a ponerlo en práctica. -
Experimenta modificando el formato del programa "¡Hola, mundo! Añade líneas en blanco, espacios, cambia la indentación, inserta nuevas líneas. Después de hacer una modificación, ejecuta
go fmtpara ver si se deshace el cambio de formato. Ejecuta tambiéngo buildpara ver si el código sigue compilándose. También puedes añadir llamadas adicionales afmt.Printlnpara ver qué ocurre si pones líneas en blanco en medio de una función.
Conclusión
En este capítulo has aprendido a instalar y configurar tu entorno de desarrollo Go. También has aprendido sobre las herramientas para construir programas Go y garantizar la calidad del código. Ahora que tu entorno está listo, pasarás al siguiente capítulo, donde explorarás los tipos incorporados en Go y cómo declarar variables.
Get Aprender Go, 2ª Edición now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.
