Las interfaces de línea de comandos (CLI) siguen siendo populares incluso frente a las interfaces gráficas de usuario (GUI) y sus componentes visuales interactivos. Las CLI todavía se usan debido a su simplicidad, facilidad, velocidad y menos recursos necesarios para configurar una aplicación CLI.

La mayoría de las aplicaciones CLI se ejecutan en la línea de comando o terminal del sistema operativo, lo que aumenta la flexibilidad sin requerir tantos recursos como las GUI.

Puede crear CLI con lenguajes populares desde Python hasta C++, Rust y Go. La mayoría de los idiomas proporcionan paquetes para crear aplicaciones CLI sin dependencias externas.

Aplicaciones de línea de comandos y Go

Uno de los casos de uso previstos para el lenguaje de programación Go es la creación de CLI interactivas de alto rendimiento. A lo largo de los años, Go ha ganado fuerza en el campo.

Go impulsa aplicaciones CLI populares como Docker CLI, Hugo, GitHub CLI y más. Go es uno de los lenguajes preferidos para crear aplicaciones CLI, dado su soporte de primera clase para ellas junto con su rendimiento.

instagram viewer

Hay una bandera paquete para el análisis de la línea de comandos, pero carece de muchas de las funciones que necesitará para crear aplicaciones de línea de comandos modernas. Además, el desarrollo de aplicaciones CLI con el bandera El paquete puede ser complejo a medida que aumenta el tamaño de su aplicación e incorpora más funciones.

El ecosistema de Go tiene muchos paquetes acreditados para crear CLI, con funciones que ayudan a reducir el tiempo de desarrollo.

El paquete cobra

Cobra es uno de los paquetes más populares para crear CLI en el ecosistema Go y más allá. Cobra es un paquete para crear aplicaciones CLI modernas e interactivas en cualquier entorno.

Cobra proporciona una interfaz simple para crear CLI de estándar industrial similar a las herramientas Go y Git. Cobra impulsa muchas aplicaciones CLI con las que ha interactuado, incluidas Docker, Kubernetes, Twitch, Hugo y muchas otras.

Cobra es una herramienta fácil de usar basada en subcomandos. Admite banderas compatibles con POSIX, subcomandos anidados y banderas globales, locales y en cascada.

Cobra también admite sugerencias inteligentes, generación de ayuda automática, reconocimiento de banderas y alias de comando. Permite el autocompletado de shell en Bash, Powershell, Fish y Zsh, y la integración con el víbora paquete para aplicaciones de 12 factores.

Ejecute este comando en la terminal de su directorio de trabajo para instalar la última versión del paquete Cobra y sus dependencias.

ir obtener -u github.com/spf13/cobra@latest

Cobra proporciona una aplicación CLI para un desarrollo más rápido y sencillo. El paquete Cobra—cli genera un código repetitivo que puede configurar para agregar nuevos comandos a su aplicación sin problemas.

Ejecute este comando en la terminal de su directorio de trabajo para instalar la última versión del paquete Cobra-cli.

ir instale github.com/spf13/cobra-cli@latest

Deberá configurar su variable GOPATH en su directorio de trabajo para usar el generador Cobra (Cobra-cli) y otras herramientas de línea de comandos de Go.

Después de una instalación exitosa, puede inicializar una aplicación Cobra en su proyecto con el en eso dominio.

inicio cobra-cli

Después de inicializar una aplicación Cobra, puede usar el agregar subcomando con el cobra-cli comando para crear y agregar un nuevo comando a su aplicación Cobra.

cobra-cli agregar nuevo comando

El comando crea un nuevo archivo con el código que necesita para el comando. Puede editar el archivo según su operación.

Aquí hay una función de controlador de comando simple para un comando generado con el comando Cobra-cli.

importar (
 "fmt"
 "github.com/spf13/cobra"
 "registro"
 "strconv"
)
// un comando generado por cobra


// newCmd representa el nuevo comando
variable nuevoCmd = &cobra. Dominio {
 Usar: "nuevoCmd",
 Corto: "La descripción de newCmd que especifique",
 Largo: `Una descripción más larga que abarca varias líneas y probablemente contiene ejemplos
y el uso de su comando. Por ejemplo:
Cobra es una biblioteca CLI para Vaya que potencia las aplicaciones.
Esta aplicación es una herramienta para generar los archivos necesarios.
para crear rápidamente una aplicación Cobra.`,


Correr: función(cmd *cobra. Comando, argumentos []cadena) { 
siLen(argumentos) < 1 { 
 registro. Fatal ("Sin argumentos adicionales")
 }
 argumentos := argumentos[0] 
 fmt. Println (argumentos) 
 }
}


funciónen eso() {
 rootCmd. AgregarComando (nuevoCmd)


// Aquí definirá sus banderas y ajustes de configuración.


// Cobra admite banderas persistentes que funcionarán para este comando
// y todos los subcomandos, por ejemplo:
// nuevoCmd. PersistentFlags().String("foo", "", "Una ayuda para foo")
// Cobra admite banderas locales que solo se ejecutarán cuando este comando
// se llama directamente, por ejemplo:
// nuevoCmd. Flags().BoolP("alternar", "t", falso, "Mensaje de ayuda para alternar")
}

Puede acceder a argumentos adicionales con el argumentos argumento de la función. La función anterior utiliza el si declaración para comprobar si hay un argumento adicional de la terminal e imprime el argumento.

El paquete CLI

El paquete CLI es un paquete minimalista con temática de expresividad para crear aplicaciones CLI rápidas y distribuibles en Go.

El paquete Cli admite argumentos de línea de comandos, indicadores y subcomandos con categorías. Tiene funcionalidad para atender opciones cortas, Finalizaciones de bash, ayuda generada y control de versiones.

El paquete Cli es interoperable con el integrado de Go bandera y contexto paquetes, y puede utilizar la mayoría de las características en el bandera paquete con el CLI.

Ejecute estos comandos en la terminal de su directorio de trabajo para agregar el paquete Graphql-go y sus dependencias a su proyecto.

ir obtener github.com/urfave/cli

Así es como puede agregar un comando a su aplicación CLI con el paquete CLI.

paquete principal
importar (
 "fmt"
 "registro"
 "os"


"github.com/urfave/cli/v2"
)


funciónprincipal() {
 aplicación := &cli. aplicación {
 Nombre: "nuevo",
 uso: "hacer a nuevo comando con el CLI paquete",
 Acción: función(*cl. Contexto)error {
 fmt. println("Aquí hay un nuevo dominio")
devolvernulo
 },
 }
si error := aplicación. Ejecutar (s. argumentos); error! = nulo {
 registro. fatal (error)
 }
}

En el principal función, la aplicación variable es una instancia de una aplicación CLI y la aplicación Acción El campo es la función de controlador de la aplicación. Aquí el nuevo El comando imprimiría el texto de la función o devolvería un error si hay algún error de la aplicación.

El paquete Cli es útil para proyectos más pequeños sin mucha complejidad o características.

El paquete Go-Arg

El paquete Go-arg es un paquete basado en estructuras para analizar argumentos CLI en Go. Con el paquete Go-arg, puede declarar estructuras para argumentos CLI y operar en los argumentos como estructuras de datos regulares de Go. El paquete Go-arg proporciona argumentos necesarios, argumentos posicionales, variables de entorno, cadenas de uso, valores predeterminados y muchas otras funciones.

El paquete admite tipos básicos como entero, punto flotante, cadena y booleano. También admite tipos más complejos como URL, duraciones de tiempo, direcciones de correo electrónico, direcciones MAC, punteros, sectores, mapas y el cualquier tipo.

Puedes usar el conseguir comando para agregar el paquete Go-arg a las dependencias de su paquete.

ir obtener github.com/alexflint/ir-arg

El paquete Go-arg es simple e intuitivo de usar. Así es como puede aceptar argumentos desde la línea de comandos e imprimirlos en la consola de la línea de comandos.

funciónprincipal() {
variable argumentos estructura {
 Foo cadena
 Bar bool
 }
 argumento Debe analizar(&argumentos)
 fmt. Println (argumentos. Foo, argumentos. Bar)
}

El argumentos struct es la instancia de estructura para la aplicación CLI. El debe analizar El método analiza los argumentos de la línea de comando en la instancia de estructura.

Puede ejecutar fácilmente el programa con el correr comando y especifique los argumentos después del nombre del archivo.

ir ejecutar principal.ir --foo=hola --bar

También puede utilizar el construir Comando para construir su aplicación en un ejecutable antes de ejecutar el ejecutable y especificar los argumentos.


ir construir principal.ir
./main --foo=hola --bar

Existen diferencias significativas entre las GUI y las CLI que deberá tener en cuenta

Durante el desarrollo, si tiene que elegir entre crear una CLI o una GUI para sus usuarios, deberá considerar muchos factores para tomar una decisión.

El uso de CLI sobre GUI da como resultado programas más rápidos, automatización fácil y menor utilización de recursos. Si alguna de esas ventajas no es crucial para su aplicación, es posible que esté mejor con una GUI, ya que son más populares entre los usuarios generales.