Escribir aplicaciones CLI con Go

Introducción a Go y Aplicaciones CLI

Go, también conocido como Golang, es un lenguaje de programación de código abierto diseñado por Google. Hace hincapié en la simplicidad, la seguridad y el rendimiento, por lo que es una excelente opción para la construcción de aplicaciones de interfaz de línea de comandos (CLI). Las aplicaciones CLI son herramientas con las que los usuarios pueden interactuar a través de una interfaz basada en texto, comúnmente utilizadas para la administración de sistemas, automatización y tareas de scripting. Go es muy adecuado para el desarrollo CLI porque ofrece:

1. Simplicidad: La sintaxis de Go es fácil de entender y escribir, permitiendo a los desarrolladores construir y mantener rápidamente aplicaciones CLI.
2. Rendimiento: Go es un lenguaje compilado y estáticamente tipado, lo que significa que produce archivos binarios optimizados, dando como resultado aplicaciones CLI rápidas y eficientes.
3. Soporte de concurrencia: Go incorpora primitivas de concurrencia, como goroutines y canales, lo que permite un procesamiento paralelo perfecto y, en última instancia, aplicaciones CLI más rápidas y con mayor capacidad de respuesta.
4. Compilación binaria estática: Go compila las aplicaciones en un único binario independiente, sin dependencias externas, lo que facilita la distribución y el despliegue de su aplicación CLI.
5. Potente biblioteca estándar: La biblioteca estándar de Go proporciona numerosos paquetes incorporados, simplificando las tareas comunes de desarrollo de CLI, como trabajar con archivos, redes y manejar argumentos de línea de comandos.

En este artículo, aprenderás lo esencial para desarrollar aplicaciones CLI utilizando Go, desde la configuración de tu entorno y la estructuración de tu aplicación hasta el manejo de argumentos de línea de comandos y el aprovechamiento de paquetes de terceros.

Primeros pasos: Instalación de Go y configuración del entorno

Antes de empezar a escribir aplicaciones CLI con Go, debe instalar el lenguaje de programación Go en su sistema.

1. Visite la página oficial de descargas de Go, seleccione el paquete binario adecuado para su plataforma (Windows, macOS o Linux) y siga las instrucciones de instalación.
2. Una vez completada la instalación, compruebe que Go está correctamente instalado ejecutando go version en su terminal. Este comando debería mostrar la versión de Go instalada.
3. Configure las variables de entorno necesarias para Go, incluyendo GOPATH, que determina la ubicación de su espacio de trabajo Go (donde se almacenarán sus proyectos Go y dependencias), y GOROOT, que apunta a su directorio de instalación Go.
4. Asegúrese de que el comando go está en la variable PATH de su sistema. Esto le permitirá ejecutar comandos Go desde cualquier directorio.

Con Go instalado y tu entorno configurado, estás listo para empezar a construir tu primera aplicación CLI.

Estructurando tu aplicación CLI: Paquetes y Módulos

Estructurar adecuadamente tu aplicación CLI es esencial para su mantenimiento y escalabilidad, asegurando que tu código está organizado y es fácil de navegar. En Go, la organización del código se consigue a través de paquetes y módulos.

Paquetes: Los paquetes son la forma de Go de organizar y compartimentar el código. Un paquete consiste en uno o más archivos fuente (con extensión .go ) ubicados en el mismo directorio. Cada archivo en un paquete debe declarar su nombre de paquete, especificado con la palabra clave package al principio del archivo. Una aplicación Go CLI típica tiene al menos dos paquetes:

1. main: Este es el paquete por defecto para el punto de entrada de su aplicación. Es donde reside la función main() y sirve como punto de partida para tu aplicación CLI. Toda la lógica y comandos específicos del CLI deben ser colocados dentro del paquete main.
2. internal o pkg: Estos paquetes contienen código reutilizable que está separado de tu lógica CLI. Puedes usar internal para código que sólo debe ser importado por tu propio código Go dentro del proyecto, y pkg para código que puede ser importado por cualquier proyecto Go.

Módulos: Los módulos son una forma de gestionar dependencias y versiones en aplicaciones Go. Introducidos en Go 1.11, permiten a los desarrolladores declarar dependencias de paquetes y especificar la versión requerida. Para crear un nuevo módulo Go, navegue hasta el directorio raíz de su proyecto y ejecute el siguiente comando:

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

go mod init tu.modulo.nombre

Este comando crea un archivo go. mod en el directorio raíz, que enumera las dependencias de su proyecto, y un archivo go. sum, que contiene las sumas de comprobación de cada dependencia. Cuando importes paquetes o utilices librerías de terceros, Go mantendrá automáticamente un registro de las dependencias en los archivos go . mod y go.sum.

Fuente de la imagen: El lenguaje de programación Go

Usando paquetes y módulos de forma efectiva, puedes mantener una estructura de código limpia y eficiente para tu aplicación Go CLI, haciendo más sencillo desarrollar, depurar y extender tu proyecto en el futuro.

Argumentos y banderas de la línea de comandos

Los argumentos de la línea de comandos y las banderas son componentes esenciales de las aplicaciones CLI, permitiendo a los usuarios controlar el comportamiento de la aplicación y proporcionar la información necesaria. En Go, puedes trabajar con argumentos de línea de comandos y banderas usando los paquetes flag y os.Args de la librería estándar.

Uso de os.Args

El paquete os. Args proporciona acceso directo a los argumentos de la línea de comandos. Es una porción de cadenas, donde os.Args [0] es el nombre del programa en ejecución, y el resto de las entradas representan los argumentos pasados al programa.

He aquí un ejemplo de uso de os. Args:

package main import ( "fmt" "os" ) func main() { argCount := len(os.Args) fmt.Printf("Número de argumentos: %d\n", argCount) fmt.Println("Argumentos:", os.Args) }

Al ejecutar el programa, verá el número y la lista de argumentos proporcionados.

Uso del paquete flag

El paquete flag es una forma más sofisticada y flexible de trabajar con flags en la línea de comandos. Le permite definir indicadores con varios tipos de datos y analizar la entrada convenientemente.

A continuación se muestra un ejemplo de uso del paquete flag:

package main import ( "flag" "fmt" ) func main() { var ( nombre cadena edad int altura float64 ) flag.StringVar(&nombre, "nombre", "Juan Pérez", "Tu nombre") flag.IntVar(&edad, "edad", 21, "Tu edad") flag.Float64Var(&height, "altura", 180.0, "Su altura (en cm)") flag.Parse() fmt.Printf("Nombre: %s\n", nombre) fmt.Printf("Edad: %d\n", edad) fmt.Printf("Altura: %.1f\n", altura) }

Una vez definidos los indicadores, invoque flag.Parse() para analizar la entrada de la línea de comandos y rellenar las variables definidas. A continuación, puede utilizar estas variables en toda la aplicación.

Creación de comandos y subcomandos

Para aplicaciones CLI complejas, puede que quieras crear comandos y subcomandos para organizar mejor tus funcionalidades y opciones. Un paquete popular de terceros para trabajar con comandos y subcomandos en Go es github.com/spf13/cobra.

Primeros pasos con Cobra

Para empezar, necesitarás instalar el paquete Cobra:

go get -u github.com/spf13/cobra/cobra

Una vez instalado, puedes crear una nueva aplicación CLI con Cobra:

cobra init mi-cli --pkg-name=mi-cli

Este comando crea un nuevo directorio llamado my-cli con la estructura y archivos necesarios para una aplicación CLI basada en Cobra.

Definición de comandos

En una aplicación basada en Cobra, se crean comandos definiendo instancias de cobra.Command. Cada comando tiene un campo Use (que indica cómo se utiliza el comando), un campo Short (que proporciona una descripción corta) y un campo Long (que proporciona una descripción más detallada).

Además, cada comando debe tener un campo Ejecutar, que contiene una función que ejecuta la lógica del comando. A menudo se define esta función como un cierre para capturar los indicadores y argumentos del comando.

He aquí un ejemplo de creación de un simple comando "greet":

greetCmd := &cobra.Command{ Use: "greet", Short: "Saluda a alguien", Long: "Este comando saluda a alguien con un mensaje personalizable", Run: func(cmd *cobra.Command, args []string) { // Lógica del comando greet }, }

Para crear un subcomando, puedes definir otra instancia cobra.Command y añadirla como hijo del comando padre usando el método AddCommand. Por ejemplo, puedes crear un subcomando "adiós" bajo el comando "saludar":

goodbyeCmd := &cobra.Command{ Use: "goodbye", Short: "Despídete de alguien", Long: "Este subcomando se despide de alguien en un idioma específico", Run: func(cmd *cobra.Command, args []string) { // Lógica para el subcomando goodbye }, } greetCmd.AddCommand(goodbyeCmd)

Avisos interactivos y entradas de usuario

Los avisos interactivos pueden mejorar la experiencia de usuario de tu aplicación CLI guiando a los usuarios a través de una serie de preguntas y recopilando información basada en sus respuestas. Un paquete popular de terceros para trabajar con prompts interactivos en Go es github.com/AlecAivazis/survey/v2.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Primeros pasos con Survey

En primer lugar, es necesario instalar el paquete Survey:

go get -u github.com/AlecAivazis/survey/v2

Uso de Survey para preguntas interactivas

Survey proporciona un conjunto de tipos de preguntas predefinidos, entre los que se incluyen Introducir, Seleccionar, Selección múltiple, Confirmar y otros. Para crear una pregunta, instancie el tipo de pregunta deseado y llame a la función survey.Ask.

package main import ( "fmt" "github.com/AlecAivazis/survey/v2" ) func main() { var name string namePrompt := &survey.Input{ Message: "¿Cómo te llamas?", } err := survey.Ask([]*survey.Question{{ Nombre:    "nombre", Pregunta: nombrePregunta, Validar: encuesta.Obligatorio, }}, &nombre) if err != nil { fmt.Println("Error:", err) return } fmt.Printf("¡Hola, %s!\n", nombre) }

Este fragmento de código muestra el uso del indicador de entrada de la encuesta para recopilar un nombre y mostrar un mensaje de saludo. El campo Validar se puede configurar para implementar una lógica de validación personalizada para la entrada del usuario.

Trabajar con bibliotecas externas

En muchas aplicaciones CLI, es común depender de bibliotecas externas para mejorar la funcionalidad y agilizar el proceso de desarrollo. Go proporciona un enfoque moderno y eficiente para la gestión de dependencias que permite a los desarrolladores trabajar con bibliotecas externas sin problemas. Introducidos en Go 1.11, los módulos Go le permiten declarar dependencias de paquetes dentro de su proyecto y automatizar el proceso de descarga, construcción e instalación de los paquetes requeridos. Para gestionar bibliotecas externas en su aplicación CLI, siga estos pasos:

1. Inicialice un módulo Go: En el directorio raíz de su aplicación CLI, ejecute el comando go mod init <nombre-del-módulo>, sustituyendo '<nombre-del-módulo>' por el nombre del módulo que desee. Este comando creará un nuevo archivo llamado go.mod en el directorio de tu proyecto.
2. Añadir bibliotecas externas: Siempre que desee importar una biblioteca externa, añada las sentencias import necesarias en su código fuente. La primera vez que construya o ejecute su proyecto, Go descargará e instalará automáticamente las versiones requeridas de esas librerías, y actualizará los ficheros go.mod y go.sum.
3. Actualizar bibliotecas: Para actualizar una biblioteca externa, puede utilizar el comando go get -u seguido del nombre del paquete. Esto actualiza el paquete a la última versión, reflejando los cambios en su archivo go. mod.
4. Eliminar bibliotecas no utilizadas: Para limpiar las bibliotecas no utilizadas de su archivo go.mod, ejecute el comando go mod tidy. Esto elimina cualquier librería que ya no se necesite o que haya quedado obsoleta durante el desarrollo.

El uso de módulos Go proporciona varias ventajas cuando se trabaja con bibliotecas externas. Por ejemplo, promueve la legibilidad del código y simplifica la gestión de dependencias, permitiendo una aplicación CLI más mantenible y modular.

Gestión de errores y registro

El manejo adecuado de errores y el registro son cruciales para asegurar la robustez de su aplicación CLI. Go ofrece un enfoque muy práctico y ergonómico para trabajar con errores y registros. Para manejar errores en Go, puedes usar el paquete estándar errors. Estas son algunas de las mejores prácticas a la hora de trabajar con errores en tus aplicaciones CLI:

• Devuelve errores en lugar de pánicos: En lugar de hacer que tu aplicación entre en pánico y se bloquee, devuelve errores desde las funciones y manéjalos adecuadamente. Esto permite un mejor flujo de control y mecanismos de recuperación en su aplicación CLI.
• Utilice tipos de error personalizados: Cree sus propios tipos de error utilizando la función errors.New o implementando la interfaz de error. Los tipos de error personalizados le permiten transmitir información más específica sobre lo que ha ido mal cuando se produce un error.
• Gestione los errores cerca del origen: Siempre que sea posible, gestione los errores lo más cerca posible de su origen. Esto ayuda a mantener la simplicidad de su código y hace más fácil razonar sobre el manejo de errores en situaciones complejas.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Para el registro, la biblioteca estándar de Go ofrece el paquete log, que proporciona una interfaz de registro sencilla y flexible. Puede utilizar el paquete para registrar mensajes con diferentes niveles de gravedad y personalizar el destino de la salida. Para capacidades de registro más avanzadas, considere el uso de registro estructurado con el popular paquete github.com/sirupsen/logrus. Aquí hay algunos consejos para el registro eficaz en su aplicación CLI:

• Elija el nivel de registro adecuado: Utilice los niveles de registro para diferenciar entre errores críticos, advertencias y mensajes informativos normales. Esto hace que los registros sean más procesables y ayuda a identificar los problemas de manera más eficiente.
• Incluya contexto en los mensajes de registro: Proporcione contexto relevante al registrar, como valores de variables y nombres de funciones. Esto facilita la localización de problemas durante la resolución de problemas.
• Considere el registro estructurado: Utilice el registro estructurado para emitir mensajes de registro en un formato legible por máquina, como JSON. Esto resulta especialmente útil para sistemas de registro centralizados, agregación de registros y herramientas de análisis.

Pruebas y evaluación comparativa de aplicaciones CLI

La garantía de calidad es otro aspecto vital en el desarrollo de aplicaciones CLI fiables. El soporte integrado de Go para pruebas y benchmarking le permite escribir pruebas unitarias efectivas y medir el rendimiento de su aplicación CLI. El paquete de pruebas de Go le permite escribir pruebas unitarias, ejecutarlas en paralelo y generar informes de cobertura de pruebas. Utilice las siguientes técnicas para mejorar sus prácticas de pruebas:

• Cree funciones de prueba: Escriba funciones de prueba para los componentes de su aplicación CLI y póngales el prefijo Test, como TestMyFunction. Coloque estas funciones en un archivo _test. go independiente junto al archivo fuente que se está probando.
• Utilice tablas de prueba: Utilice tablas de prueba (también conocidas como pruebas basadas en tablas) para probar varias combinaciones de entrada-salida utilizando una única función de prueba. Este enfoque simplifica el código de prueba y lo hace más fácil de mantener.
• Ejecute pruebas en paralelo: Aproveche la función t.Parallel() de sus funciones de prueba para ejecutar pruebas simultáneamente. Esto puede acelerar la ejecución del conjunto de pruebas, especialmente cuando se trata de pruebas que consumen muchos recursos.
• Genere informes de cobertura de pruebas: Utilice el comando go test -cover para generar informes de cobertura del código. Esto le ayuda a identificar las áreas de su código que requieren pruebas más exhaustivas y garantiza un mayor grado de cobertura de las pruebas.

Para medir el rendimiento de los componentes de su aplicación CLI, Go proporciona soporte para benchmarking a través del mismo paquete de pruebas. Utilice los puntos de referencia de la siguiente manera:

• Cree funciones de benchmark: Escriba funciones de benchmark y antepóngalas con Benchmark, como BenchmarkMyFunction. Coloque estas funciones en el mismo archivo _test. go que contiene las funciones de prueba pertinentes.
• Utilice el parámetro testing .B: Ejecute el código que desea comparar dentro de un bucle controlado por el parámetro testing. B (por ejemplo, for i := 0; i < b.N; i++ { ... }). El parámetro testing . B es ajustado automáticamente por el paquete testing para lograr una medición estadísticamente significativa.
• Analice los resultados del benchmark: Utilice el comando go test -bench para ejecutar sus puntos de referencia y analizar los resultados. Esto puede ayudarle a determinar las áreas de su aplicación CLI que necesitan optimización y medir el impacto de las mejoras de rendimiento.

En conclusión, la gestión adecuada de las bibliotecas externas, la gestión de errores, el registro, las pruebas y la evaluación comparativa son vitales para crear aplicaciones CLI fiables y eficientes. Al aprovechar las diversas herramientas, técnicas y mejores prácticas descritas en este artículo, puede asegurarse de que su aplicación CLI basada en Go alcance un alto nivel de calidad y excelencia. Además, la combinación de la potencia de Go con plataformas versátiles como AppMaster puede agilizar enormemente los procesos de desarrollo de software, logrando así resultados sobresalientes.

Try AppMaster no-code today!

Platform can build any web, mobile or backend application 10x faster and 3x cheaper

Start Free

Despliegue y distribución de su aplicación CLI

Una vez que haya completado el desarrollo de su aplicación de interfaz de línea de comandos (CLI) en Go, el paso final es desplegarla y distribuirla para que los usuarios puedan acceder a ella y utilizarla. El lenguaje de programación Go y su cadena de herramientas de compilación te permiten crear ejecutables independientes, enlazados estáticamente, que son fáciles de distribuir y compartir entre plataformas.

Creación del ejecutable

Para construir su aplicación Go CLI, utilice el comando go build seguido del paquete o archivo de destino:

go build ./ruta/a/tu/paquete

O bien

go build main.go

Este comando creará un archivo binario ejecutable para su plataforma actual (por ejemplo, Windows, macOS, Linux) y lo colocará en el directorio de trabajo actual. Por defecto, el nombre del archivo binario coincide con el nombre del paquete o el nombre del archivo fuente sin la extensión (por ejemplo, main).

Sin embargo, puede especificar nombres de archivos binarios de salida y apuntar a diferentes plataformas utilizando la bandera -o y variables de entorno:

GOOS=linux GOARCH=amd64 go build -o nombre-personalizado ./ruta/para/tu/paquete

En el ejemplo anterior, establecemos las variables de entorno GOOS y GOARCH para indicar al proceso de compilación de Go que se dirija a Linux con una arquitectura AMD64, y establecemos el nombre del archivo binario de salida como custom-name.

Compilación cruzada para diferentes plataformas

Go simplifica la compilación cruzada, y puedes crear rápidamente ejecutables para varias plataformas sin complejas configuraciones de compilación. Para compilar de forma cruzada su aplicación Go CLI para múltiples plataformas, establezca las variables de entorno GOOS y GOARCH según corresponda. El siguiente ejemplo muestra cómo compilar de forma cruzada una aplicación Go CLI para Windows, macOS y Linux:

# Para Windows 64-bit GOOS=windows GOARCH=amd64 go build -o mycli-windows.exe ./ruta/a/paquete # Para macOS 64-bit GOOS=darwin GOARCH=amd64 go build -o mycli-macos ./ruta/a/paquete # Para Linux 64-bit GOOS=linux GOARCH=amd64 go build -o mycli-linux ./ruta/a/paquete

Distribución de la aplicación CLI

Puede distribuir sus archivos binarios ejecutables Go CLI proporcionando opciones de descarga directa en el sitio web de su proyecto o dentro de la documentación README. Alternativamente, distribuye como paquetes específicos de plataforma usando sistemas de empaquetado, repositorios o gestores de paquetes. Algunos de los sistemas de gestión de paquetes más conocidos son

• Homebrew - Un gestor de paquetes para macOS y Linux con una sintaxis fácil de usar para instalar y gestionar paquetes.
• APT ( sistemas basados en Debian) - Un gestor de paquetes para distribuciones Linux basadas en Debian como Ubuntu.
• RPM ( sistemas basados en Red Hat) - Un gestor de paquetes para distribuciones Linux basadas en Red Hat como Fedora.

Reflexiones finales y recursos

Crear potentes aplicaciones CLI con Go es un proceso agradable y gratificante. La simplicidad, el rendimiento y las ventajas de la distribución binaria hacen de Go una elección de lenguaje de programación ideal para este propósito. Mientras continúas desarrollando tus aplicaciones Go CLI, considera explorar recursos adicionales para expandir tu conocimiento y mejorar tus habilidades:

• Documentación oficial de Go - Una guía completa sobre el lenguaje de programación Go y su biblioteca estándar.
• Recursos de aprendizaje de Go - Una extensa lista de recursos de aprendizaje de Go, incluyendo tutoriales, libros y cursos.
• Awesome Go - Una lista de paquetes, bibliotecas y recursos Go, clasificados por temas.
• Go by Example - Una aproximación práctica a Go, con ejemplos concisos y explicaciones de varias características de Go.

Además, considere explorar plataformas no-code como AppMaster. io que utilizan Go (golang) como lenguaje de programación backend. AppMaster.io ofrece una interfaz intuitiva de arrastrar y soltar que permite desarrollar aplicaciones web, móviles y de backend sin escribir una sola línea de código. Al comprender tanto Go como las plataformas no-code como AppMaster.io, estarás bien equipado para desarrollar soluciones de software aún más sofisticadas en el futuro.