Ejercicio: Hola mundo

  • 6 minutos

En esta sección, escribirá su primer programa de Go para imprimir un mensaje en la pantalla. Este ejercicio es una manera típica de empezar a trabajar en un lenguaje de programación. Aprenderá más sobre la interfaz de la línea de comandos (CLI) de Go y cómo compilar y ejecutar una aplicación de Go.

Configuración del IDE para que se abra desde la CLI

Puede abrir el IDE Visual Studio Code desde el símbolo del sistema de la CLI y empezar a editar los archivos en el área de trabajo actual. Esta característica del IDE se implementa mediante la variable $PATH (o $Path) del entorno del sistema. Cuando la característica está habilitada, puede usar el comando code . de la CLI para abrir el IDE y editar archivos en el directorio actual.

Algunas instalaciones de Visual Studio Code agregan compatibilidad con la CLI a la variable $PATH de forma predeterminada. Es posible que vea esta opción durante el proceso de instalación. Si ya tiene esta opción configurada, está todo listo. De lo contrario, es posible que tenga que seguir estos pasos para usar esta característica.

Linux o macOS

Siga estos pasos para registrar la CLI de Visual Studio Code en la variable de entorno $PATH:

  1. Abra Visual Studio Code.

  2. En Ver, seleccione Paleta de comandos.

  3. En el cuadro de búsqueda, escriba comando de shell. A medida que escribe, los resultados se filtran.

  4. Elija el comando Shell Command: Instalar el comando "code" en PATH.

  5. Cierre el símbolo del sistema del comando o terminal abierto.

    Importante

    Si tiene un símbolo del sistema abierto del ejercicio anterior, cierre el símbolo del sistema y abra uno nuevo. Este paso es necesario para que el nuevo valor de $PATH surta efecto.

  6. Cierre Visual Studio Code.

Windows

Siga estos pasos para agregar la ubicación de la CLI de Visual Studio Code a la variable de entorno del sistema $Path:

Nota:

Si está familiarizado con las variables de entorno y sabe cómo agregar una nueva ubicación a la variable del sistema $Path, puede usar el método que mejor le venga. El procedimiento siguiente es un poco largo, pero es un método comprobado para asegurarse de que la variable se actualiza correctamente.

  1. Abra el Panel de control de Windows.

  2. Seleccione Sistema y, a continuación, seleccione Configuración avanzada del sistema.

  3. En el cuadro de diálogo Propiedades del sistema, en Opciones avanzadas, seleccione Variables de entorno. Se abre el cuadro de diálogo para editar variables de entorno.

    El cuadro de diálogo para editar variables de entorno muestra dos listas:

    • Variables de usuario para <user-name>: definiciones de variables locales para el usuario específico.
    • Variables del sistema: definiciones de variables del sistema para todos los usuarios.

    En este procedimiento, estamos trabajando con las variables del sistema.

  4. En el cuadro de diálogo Variables de entorno, en el cuadro de lista Variables del sistema, desplácese para buscar la variable Path.

  5. Seleccione la variable Path para resaltar la fila. Seleccione Editar. Se abre el cuadro de diálogo para editar variables de entorno. En el cuadro de diálogo se enumeran todas las ubicaciones de carpeta que se definen en la variable.

  6. En el cuadro de diálogo para editar variables de entorno, seleccione Nuevo. Se abre una fila vacía al final de la lista.

  7. En la fila vacía, escriba la ubicación del archivo ejecutable de la CLI de Visual Studio Code. Reemplace <user-name> por el nombre de usuario.

    C:\Users\<user-name>\AppData\Local\Programs\Microsoft VS Code\bin

  8. Seleccione Aceptar para cerrar cada cuadro de diálogo.

  9. Cierre el cuadro de diálogo Propiedades del sistem y el Panel de control de Windows.

Paso 1: Abrir el área de trabajo de Go y el IDE

Después de confirmar que Visual Studio Code está listo para usarse desde la CLI, puede abrir el área de trabajo de Go.

  1. Abra un nuevo símbolo del sistema del comando o terminal.

  2. Abra el directorio del área de trabajo de Go ejecutando el siguiente comando:

    cd $GOPATH/src

    cd %GOPATH%/src

  3. Use el siguiente comando para abrir Visual Studio Code desde el área de trabajo:

    code .

Se inicia Visual Studio Code. La vista Explorador se muestra a la izquierda y hay una página principal a la derecha.

En la vista Explorador, la sección SRC del proyecto de Go debe estar abierta (expandida). Esta sección es la carpeta /src del proyecto. Actualmente está vacía, pero le agregaremos contenido en el paso siguiente.

Paso 2: Crear una carpeta y un archivo de Go

Vamos a agregar una carpeta y un archivo al proyecto de Go. Hay varias maneras en Visual Studio Code de crear nuevos elementos:

  • Acciones en el menú de la barra de herramientas:
    • Seleccione Archivo>Abrir carpeta y, a continuación, cree una Nueva carpeta.
    • Seleccione Archivo>Nuevo archivo e inicie un archivo nuevo.
  • Vínculos de la página principal, que son similares a las acciones del menú de la barra de herramientas.
  • Iconos en la vista Explorador, a la derecha de la sección SRC:
    • Seleccione el icono Nueva carpeta. En el cuadro de texto, escriba el nombre de la carpeta y presione Entrar.
    • Seleccione el icono Nuevo archivo. En el cuadro de texto, escriba el nombre del archivo y presione Entrar.

Complete los pasos siguientes en Visual Studio Code. Para crear el archivo y la carpeta nuevos, use el proceso que mejor se adapte a su caso.

  1. Cree una nueva carpeta denominada helloworld.

  2. Cree un nuevo archivo denominado main.go para el código de la aplicación.

  3. Expanda la vista>SRC del Explorador para mostrar el árbol de estructura de carpetas. Deberían parecerse a los de este ejemplo:

    SRC/
        helloworld/
            main.go

Instalación de las herramientas de la extensión de Go

Si main.go es el primer archivo de Go que abre en Visual Studio Code, es posible que se le pida que instale otras herramientas para la extensión de Go. Cuando se le pida, seleccione Instalar. Se abre un terminal en la parte inferior del IDE para mostrar la salida del proceso. Debería ver una salida como la de este ejemplo:

Tools environment: GOPATH=C:\Projects\Go
Instalación de 5 herramientas en C:\Projects\Go\bin en el modo de módulo.
Installing github.com/uudashr/gopkgs/v2/cmd/gopkgs (C:\Projects\Go\bin\gopkgs.exe) SUCCEEDED

Durante el proceso de instalación, compruebe la barra de estado de Visual Studio Code. Si ve un mensaje en la parte inferior derecha, como "Todas las herramientas no instaladas", selecciónelo. En la ventana emergente, seleccione Instalar.

Cuando el proceso de instalación se completa correctamente, la salida del terminal muestra un resumen:

Todas las herramientas se instalaron correctamente. Está listo para ir a Go :).

Paso 3: Agregar código al archivo de Go

Ahora vamos a agregar código al archivo de Go.

  1. Abra el archivo main.go y escriba el código siguiente:

    package main

import "fmt"

func main() {
    fmt.Println("Hello World!")
}

  2. Guarde el archivo.

No se preocupe por el formato de código, como tabulaciones o espacios. Visual Studio Code da formato al código automáticamente cada vez que se guarda el archivo.

Paso 4: Ejecución del programa de Go

El programa Go se puede ejecutar en un símbolo del sistema del comando o terminal, o en un terminal que se ejecute dentro de Visual Studio Code.

Puede usar un símbolo del sistema existente o abrir uno nuevo. Si abre un nuevo símbolo del sistema, no olvide cambiar la ubicación del directorio al área de trabajo de Go. Asegúrese también de ejecutar el programa desde la carpeta que tiene el archivo de Go: $GOPATH/src/helloworld.

Abra un terminal dentro de Visual Studio Code

Si desea ejecutar el programa desde dentro de Visual Studio Code, en lugar de un símbolo del sistema del comando o terminal independiente, siga estos pasos:

  1. En Visual Studio Code, seleccione Terminal y luego Nuevo terminal.

  2. En el cuadro desplegable de la parte superior derecha del terminal, seleccione Nuevo símbolo del sistema.

  3. En el terminal, ejecute el siguiente comando para cambiar la ubicación del directorio al área de trabajo de Go y a la carpeta que tiene el archivo de Go:

    cd $GOPATH/src/helloworld

    cd %GOPATH%/src/helloworld

Ejecución de la aplicación de Go

Para ejecutar la aplicación de Go, use el siguiente comando en el terminal o en el símbolo del sistema:

go run main.go

Debería ver la siguiente salida:

Hello World!

El comando go run hace dos cosas. Compila la aplicación y, una vez que se completa correctamente, ejecuta la aplicación.

Compilación de un archivo ejecutable

Para generar un archivo ejecutable para el programa, use este comando:

go build main.go

Cuando finaliza el comando go build, se genera una aplicación ejecutable que se puede ejecutar en cualquier momento sin más procesamiento. El comando solo genera un archivo ejecutable. No ejecuta el programa como el comando go run.

Revisión del contenido de /src

Este es el aspecto que debería tener el proyecto ahora en la vista Explorador>SRC:

SRC/
    helloworld/
        main (principal)
        main.go

En la vista Explorador, el nombre del archivo sin la extensión es el archivo ejecutable que puede usar para ejecutar el programa. (En Windows, este archivo tiene la extensión .exe). Al desarrollar, use el comando go run. Para compilar los archivos binarios de la aplicación, use el comando go build e implemente el archivo ejecutable binario en un entorno adecuado.

¿Qué acaba de escribir en Go?

Ha creado su primera aplicación de Go y se ha asegurado de que se compila y se ejecuta. Examinemos el código línea a línea.

Comenzaremos con la primera instrucción del archivo de Go:

package main

La instrucción package main especifica cómo se le indica a Go que la aplicación que estamos creando es un programa ejecutable (un archivo que puede ejecutar). Nuestra aplicación "Hola mundo" forma parte del paquete main. Un paquete es un conjunto de archivos de código fuente comunes. Todas las aplicaciones ejecutables tienen esta primera línea, aunque el proyecto o el archivo tenga otro nombre.

Examinaremos más de cerca estos conceptos en el módulo siguiente. Por ahora, es necesario saber que todos los programas ejecutables deben formar parte del paquete main.

Reto: Cambiar el nombre del paquete

¿Puede confirmar la importancia del paquete main?

  1. En el archivo de Go, cambie el nombre del paquete en la primera línea.
  2. Guarde el archivo y vuelva a ejecutar el programa en el terminal.

  ¿Qué sucede? ¿Ve "¡Hola mundo!"? ¿Se genera un archivo ejecutable binario?

 

Mostrar respuesta
"Hello World!" no se muestra. No se genera un archivo ejecutable binario. Debería ver un error: "go run: cannot run non-main package" (ejecutar: no se puede ejecutar el paquete non-main). ¿Por qué? Todos los programas ejecutables deben formar parte del paquete "main".

Esta es la siguiente línea del archivo de Go:

import "fmt"

La instrucción import proporciona acceso al programa a otro código en paquetes diferentes. En este caso, fmt es un paquete de biblioteca estándar. Puede leer sobre el paquete fmt en el sitio oficial de la documentación de Go.

Necesita esta instrucción import porque, más adelante en el programa, va a usar una función de este paquete para imprimir un mensaje en la pantalla. Puede incluir tantas instrucciones import como quiera o necesite en el programa. Sin embargo, Go es idiomático en este sentido. Si importa un paquete, pero no usa una función correspondiente del paquete, la aplicación no se compilará. Una excelente característica de Visual Studio Code es que quita automáticamente las importaciones no utilizadas en un programa al guardar el archivo.

¿Quitó Visual Studio Code la importación al guardar el archivo? Pruebe a editar el archivo sin Visual Studio Code e intente ejecutar la aplicación. ¿Qué salida ve ahora?

Reto: Agregar otra importación

¿Puede comprobar lo que ha aprendido sobre las importaciones sin usar?

  1. Restaure el archivo de Go al código original.
  2. Agregue otra instrucción de importación como math o io.
  3. Guarde el archivo y vuelva a ejecutar el programa en el terminal.

  ¿Qué sucede? ¿Visual Studio Code quita la importación sin usar? Si es así, ¿cuándo se quita?

  1. Vuelva a editar el archivo de Go, pero no use Visual Studio Code.
  2. Guarde el archivo y ejecute el programa en un nuevo símbolo del sistema.

  ¿Qué sucede? ¿Qué salida ve ahora?

 

Mostrar respuesta
Si edita el archivo Go en el IDE, al guardar el archivo, Visual Studio Code detectará los paquetes no usados y quitará las instrucciones "import" correspondientes. Al editar el archivo Go fuera de Visual Studio Code, se produce un error en el código. Debería ver un error, como: "# command-line-arguments .\main.go:5:2: importado y no usado: 'math'".

Echemos un vistazo al bloque de código del archivo de Go:

func main() {
   fmt.Println("Hello World!")
}

La instrucción func es una palabra reservada que se usa para declarar una función. Esta primera función se denomina "main" porque es el punto inicial de nuestro programa. Solo puede tener una función main() enpackage main (el que definió en la primera línea). En la función main(), llamó a la función Println desde el paquete fmt. Envió un mensaje de texto que quería ver en la pantalla.

Hay otros aspectos que tratar sobre las funciones, y lo haremos en el próximo módulo.