Escrevendo aplicativos CLI com Go

Introdução a Go e aplicações CLI

Go, também conhecida como Golang, é uma linguagem de programação de código aberto projetada pelo Google. Ela enfatiza a simplicidade, a segurança e o desempenho, tornando-a uma excelente escolha para a criação de aplicativos de interface de linha de comando (CLI). As aplicações CLI são ferramentas com as quais os utilizadores podem interagir através de uma interface baseada em texto, normalmente utilizada para administração de sistemas, automação e tarefas de scripting. O Go é adequado para o desenvolvimento de CLI porque oferece:

1. Simplicidade: A sintaxe do Go é fácil de entender e escrever, permitindo que os desenvolvedores criem e mantenham rapidamente os aplicativos CLI.
2. Desempenho: Go é uma linguagem compilada e estaticamente tipada, o que significa que ela produz arquivos binários otimizados, resultando em aplicativos CLI rápidos e eficientes.
3. Suporte à concorrência: A linguagem Go possui primitivas de concorrência incorporadas, como goroutines e canais, permitindo um processamento paralelo contínuo e, em última análise, aplicações CLI mais rápidas e com melhor resposta.
4. Compilação binária estática: Go compila aplicativos em um único binário independente - um sem dependências externas - facilitando a distribuição e a implantação de seu aplicativo CLI.
5. Biblioteca padrão poderosa: A biblioteca padrão do Go fornece vários pacotes integrados, simplificando tarefas comuns de desenvolvimento de CLI, como trabalhar com arquivos, redes e manipular argumentos de linha de comando.

Neste artigo, você aprenderá os fundamentos do desenvolvimento de aplicativos CLI usando Go - desde a configuração do seu ambiente e a estruturação do seu aplicativo até a manipulação de argumentos de linha de comando e o aproveitamento de pacotes de terceiros.

Primeiros passos: Instalando o Go e configurando seu ambiente

Antes de começar a escrever aplicativos CLI com Go, você deve primeiro instalar a linguagem de programação Go em seu sistema.

1. Visite a página oficial de download do Go, selecione o pacote binário apropriado para sua plataforma (Windows, macOS ou Linux) e siga as instruções de instalação.
2. Quando a instalação estiver concluída, verifique se o Go está instalado corretamente executando go version no seu terminal. Esse comando deve exibir a versão do Go instalada.
3. Configure as variáveis de ambiente necessárias para o Go, incluindo GOPATH, que determina a localização do seu espaço de trabalho Go (onde seus projetos Go e dependências serão armazenados), e GOROOT, que aponta para o seu diretório de instalação do Go.
4. Certifique-se de que o comando go esteja na variável PATH do seu sistema. Isso permite que você execute comandos Go a partir de qualquer diretório.

Com o Go instalado e seu ambiente configurado, você está pronto para começar a construir seu primeiro aplicativo CLI.

Estruturando seu aplicativo CLI: Pacotes e módulos

A estruturação adequada do seu aplicativo CLI é essencial para a manutenção e escalabilidade, garantindo que seu código seja organizado e fácil de navegar. Em Go, a organização do código é obtida através de pacotes e módulos.

Pacotes: Os pacotes são a maneira do Go de organizar e compartimentar o código. Um pacote consiste em um ou mais arquivos fonte (com uma extensão .go ) localizados no mesmo diretório. Cada arquivo em um pacote deve declarar seu nome de pacote, especificado com a palavra-chave package no início do arquivo. Uma aplicação típica da CLI em Go tem pelo menos dois pacotes:

1. main: Este é o pacote padrão para o ponto de entrada do seu aplicativo. É onde a função main() reside e serve como ponto de partida para seu aplicativo CLI. Toda a lógica e comandos específicos da CLI devem ser colocados dentro do pacote main.
2. internal ou pkg: Esses pacotes contêm código reutilizável que é separado da lógica da CLI. Você pode usar internal para código que deve ser importado apenas pelo seu próprio código Go dentro do projeto, e pkg para código que pode ser importado por qualquer projeto Go.

Módulos: Os módulos são um meio de gerenciar dependências e controle de versão em aplicativos Go. Introduzidos no Go 1.11, eles permitem que os desenvolvedores declarem as dependências de pacotes e especifiquem a versão necessária. Para criar um novo módulo Go, navegue até o diretório raiz do seu projeto e execute o seguinte comando:

go mod init seu.nome.do.módulo

Este comando cria um arquivo go.mod no diretório raiz, que lista as dependências do seu projeto, e um arquivo go.sum, que contém as somas de verificação de cada dependência. Quando você importar pacotes ou usar bibliotecas de terceiros, o Go manterá automaticamente o controle das dependências nos arquivos go.mod e go.sum.

Fonte da imagem: A linguagem de programação Go

Ao usar pacotes e módulos de forma eficaz, você pode manter uma estrutura de código limpa e eficiente para seu aplicativo Go CLI, tornando mais simples desenvolver, depurar e estender seu projeto no futuro.

Argumentos e sinalizadores da linha de comando

Os argumentos e sinalizadores da linha de comando são componentes essenciais dos aplicativos CLI, permitindo que os usuários controlem o comportamento do aplicativo e forneçam a entrada necessária. Em Go, é possível trabalhar com argumentos e sinalizadores da linha de comando usando os pacotes flag e os.Args da biblioteca padrão.

Try AppMaster no-code today!

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

Start Free

Usando os.Args

O pacote os. Args fornece acesso direto aos argumentos da linha de comando. Ele é uma fatia de strings, onde os.Args[0] é o nome do programa em execução, e o resto das entradas representam os argumentos passados para o programa.

Aqui está um exemplo 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) }

Ao executar o programa, verá o número e a lista de argumentos fornecidos.

Usando o pacote flag

O pacote flag é uma forma mais sofisticada e flexível de trabalhar com flags de linha de comando. Ele permite definir sinalizadores com vários tipos de dados e analisar a entrada convenientemente.

Abaixo está um exemplo de utilização do pacote flag:

package main import ( "flag" "fmt" ) func main() { var ( name string age int height float64 ) flag.StringVar(&name, "name", "John Doe", "Your name") flag.IntVar(&age, "age", 21, "Your age") flag.Float64Var(&height, "height", 180.0, "A sua altura (em cm)") flag.Parse() fmt.Printf("Name: %s\n", name) fmt.Printf("Age: %d\n", age) fmt.Printf("Height: %.1f\n", height) }

Depois de definir os sinalizadores, invoque flag.Parse() para analisar a entrada de linha de comando fornecida e preencher as variáveis definidas. Você pode então usar essas variáveis em toda a sua aplicação.

Criação de comandos e subcomandos

Para aplicações CLI complexas, pode querer criar comandos e subcomandos para organizar melhor as suas funcionalidades e opções. Um pacote popular de terceiros para trabalhar com comandos e subcomandos em Go é o github.com/spf13/cobra.

Primeiros passos com o Cobra

Para começar, você precisará instalar o pacote Cobra:

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

Depois de instalado, você pode criar um novo aplicativo CLI com o Cobra:

cobra init my-cli --pkg-name=my-cli

Esse comando cria um novo diretório chamado my-cli com a estrutura e os arquivos necessários para um aplicativo CLI baseado em Cobra.

Definindo Comandos

Numa aplicação baseada em Cobra, cria-se comandos definindo instâncias de cobra.Command. Cada comando tem um campo Use (que indica como o comando é utilizado), um campo Short (que fornece uma descrição curta) e um campo Long (que fornece uma descrição mais detalhada).

Além disso, cada comando deve ter um campo Run, que contém uma função que executa a lógica do comando. É frequente definir esta função como um fecho para capturar os sinalizadores e argumentos do comando.

Aqui está um exemplo de criação de um simples comando "greet":

greetCmd := &cobra.Command{ Use: "greet", Short: "Cumprimentar alguém", Long: "Este comando cumprimenta alguém com uma mensagem personalizável.", Run: func(cmd *cobra.Command, args []string) { // Lógica para o comando greet }, }

Para criar um subcomando, pode definir outra instância cobra.Command e adicioná-la como um filho do comando principal utilizando o método AddCommand. Por exemplo, você pode criar um subcomando "goodbye" sob o comando "greet":

goodbyeCmd := &cobra.Command{ Use: "goodbye", Short: "Say goodbye to someone", Long: "This subcommand says goodbye to someone in a specific language.", Run: func(cmd *cobra.Command, args []string) { // Lógica para o subcomando goodbye }, } greetCmd.AddCommand(goodbyeCmd)

Prompts Interactivos e Entrada do Utilizador

Os prompts interativos podem melhorar a experiência do usuário do seu aplicativo CLI, guiando os usuários através de uma série de perguntas e coletando informações com base em suas respostas. Um pacote popular de terceiros para trabalhar com prompts interativos em Go é o github.com/AlecAivazis/survey/v2.

Primeiros passos com o Survey

Primeiro, você precisa instalar o pacote Survey:

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

Usando o Survey para prompts interativos

O Survey fornece um conjunto de tipos de prompt predefinidos, incluindo Input, Select, MultiSelect, Confirm e outros. Para criar um prompt, instancie o tipo de prompt desejado e chame a função survey.Ask.

package main import ( "fmt" "github.com/AlecAivazis/survey/v2" ) func main() { var name string namePrompt := &survey.Input{ Message: "Qual é o seu nome?", } err := survey.Ask([]*survey.Question{{ Nome:    "nome", Prompt: namePrompt, Validate: survey.Required, }}, &nome) if err != nil { fmt.Println("Erro:", err) return } fmt.Printf("Olá, %s!\n", nome) }

Este trecho de código demonstra o uso do prompt de entrada do questionário para coletar um nome e exibir uma mensagem de saudação. O campo Validar pode ser definido para implementar uma lógica de validação personalizada para a entrada do usuário.

Trabalhando com bibliotecas externas

Em muitos aplicativos CLI, é comum confiar em bibliotecas externas para melhorar a funcionalidade e simplificar o processo de desenvolvimento. O Go fornece uma abordagem moderna e eficiente para o gerenciamento de dependências que permite que os desenvolvedores trabalhem com bibliotecas externas sem problemas. Introduzidos no Go 1.11, os módulos Go permitem que você declare as dependências de pacotes dentro do seu projeto e automatize o processo de download, compilação e instalação dos pacotes necessários. Para gerenciar bibliotecas externas em seu aplicativo CLI, siga estas etapas:

1. Inicializar um módulo Go: No diretório raiz do seu aplicativo CLI, execute o comando go mod init <nome do módulo>, substituindo '<nome do módulo>' pelo nome do módulo desejado. Esse comando criará um novo arquivo chamado go.mod no diretório do seu projeto.
2. Adicionar bibliotecas externas: Sempre que quiser importar uma biblioteca externa, adicione as instruções de importação necessárias em seu código-fonte. Na primeira vez que você compilar ou executar seu projeto, o Go baixará e instalará automaticamente as versões necessárias dessas bibliotecas e atualizará os arquivos go.mod e go.sum.
3. Atualizar bibliotecas: Para atualizar uma biblioteca externa, você pode usar o comando go get -u seguido pelo nome do pacote. Isso atualiza o pacote para a versão mais recente, refletindo as alterações no seu arquivo go.mod.
4. Remover bibliotecas não usadas: Para limpar as bibliotecas não utilizadas do seu arquivo go.mod, execute o comando go mod tidy. Isso remove todas as bibliotecas que não são mais necessárias ou que se tornaram obsoletas durante o desenvolvimento.

Try AppMaster no-code today!

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

Start Free

O uso de módulos Go oferece várias vantagens ao trabalhar com bibliotecas externas. Por exemplo, ele promove a legibilidade do código e simplifica o gerenciamento de dependências, permitindo um aplicativo CLI mais sustentável e modular.

Manipulação de erros e registro em log

O tratamento adequado de erros e o registo são cruciais para garantir a robustez da sua aplicação CLI. A linguagem Go oferece uma abordagem altamente prática e ergonômica para trabalhar com erros e logs. Para lidar com erros em Go, você pode usar o pacote de erros padrão. Aqui estão algumas práticas recomendadas ao trabalhar com erros em seus aplicativos CLI:

• Retorne erros em vez de pânico: Em vez de causar pânico e travamento no seu aplicativo, retorne erros das funções e trate-os adequadamente. Isto permite um melhor fluxo de controlo e mecanismos de recuperação na sua aplicação CLI.
• Use tipos de erro personalizados: Crie seus próprios tipos de erro usando a função errors.New ou implementando a interface de erro. Os tipos de erro personalizados permitem-lhe transmitir informações mais específicas sobre o que correu mal quando ocorre um erro.
• Trate os erros perto da fonte: Sempre que possível, trate os erros o mais próximo possível da sua origem. Isso ajuda a manter a simplicidade do seu código e facilita o raciocínio sobre o tratamento de erros em situações complexas.

Para registro, a biblioteca padrão Go oferece o pacote log, que fornece uma interface de registro simples e flexível. Você pode usar o pacote para registrar mensagens com diferentes níveis de gravidade e personalizar o destino de saída. Para recursos de registro mais avançados, considere usar o registro estruturado com o popular pacote github.com/sirupsen/logrus. Aqui estão algumas dicas para o registro em log eficaz em seu aplicativo CLI:

• Escolha o nível de registro correto: Use os níveis de registro para diferenciar entre erros críticos, avisos e mensagens informativas regulares. Isso torna os logs mais acionáveis e ajuda a identificar problemas com mais eficiência.
• Incluir contexto nas mensagens de registo: Forneça contexto relevante ao registar, como valores de variáveis e nomes de funções. Isto facilita a localização de problemas durante a resolução de problemas.
• Considere o registo estruturado: Use o registro estruturado para emitir mensagens de registro em um formato legível por máquina, como JSON. Isso é particularmente útil para sistemas de log centralizados, agregação de log e ferramentas de análise.

Testando e avaliando aplicativos CLI

A garantia de qualidade é outro aspeto vital do desenvolvimento de aplicativos CLI confiáveis. O suporte integrado do Go para testes e benchmarking permite que você escreva testes unitários eficazes e meça o desempenho do seu aplicativo CLI. O pacote de testes do Go permite que você escreva testes unitários, execute-os em paralelo e gere relatórios de cobertura de teste. Use as técnicas a seguir para aprimorar suas práticas de teste:

• Criar funções de teste: Escreva funções de teste para os componentes do seu aplicativo CLI e prefixe-as com Test, como TestMyFunction. Coloque essas funções em um arquivo _test.go separado, junto com o arquivo de origem que está sendo testado.
• Use tabelas de teste: Empregue tabelas de teste (também conhecidas como testes orientados por tabela) para testar várias combinações de entrada e saída usando uma única função de teste. Essa abordagem simplifica seu código de teste e o torna mais fácil de manter.
• Execute testes em paralelo: Utilize a função t.Parallel() nas suas funções de teste para executar testes em simultâneo. Isso pode acelerar a execução do seu conjunto de testes, especialmente quando se trata de testes com uso intensivo de recursos.
• Gerar relatórios de cobertura de teste: Utilize o comando go test -cover para gerar relatórios de cobertura de código. Isso ajuda a identificar áreas do seu código que exigem testes mais completos e garante um grau mais alto de cobertura de teste.

Para medir o desempenho dos componentes do seu aplicativo CLI, o Go fornece suporte para benchmarking através do mesmo pacote de teste. Use os benchmarks da seguinte forma:

• Crie funções de benchmark: Escreva funções de benchmark e prefixe-as com Benchmark, como BenchmarkMyFunction. Coloque essas funções no mesmo arquivo _test.go que contém as funções de teste relevantes.
• Use o parâmetro testing.B: Execute o código que deseja comparar dentro de um loop controlado pelo parâmetro testing.B (por exemplo, for i := 0; i < b.N; i++ { ... }). O parâmetro testing.B é ajustado automaticamente pelo pacote testing para obter uma medida estatisticamente significativa.
• Analisar os resultados do benchmark: Use o comando go test -bench para executar seus benchmarks e analisar os resultados. Isso pode ajudar a determinar as áreas do aplicativo CLI que precisam de otimização e avaliar o impacto das melhorias de desempenho.

Try AppMaster no-code today!

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

Start Free

Em conclusão, o gerenciamento adequado de bibliotecas externas, o tratamento de erros, o registro, os testes e a avaliação comparativa são vitais para a criação de aplicativos CLI confiáveis e eficientes. Ao aproveitar as várias ferramentas, técnicas e práticas recomendadas descritas neste artigo, você pode garantir que seu aplicativo CLI baseado em Go atinja um alto nível de qualidade e excelência. Além disso, a combinação do poder do Go com plataformas versáteis, como o AppMaster, pode agilizar muito os processos de desenvolvimento de software, alcançando assim resultados excelentes.

Implantando e distribuindo seu aplicativo CLI

Depois de concluir o desenvolvimento do seu aplicativo de interface de linha de comando (CLI) em Go, a etapa final é implantá-lo e distribuí-lo para os usuários acessarem e utilizarem. A linguagem de programação Go e sua cadeia de ferramentas de compilação permitem que você crie executáveis autônomos, ligados estaticamente, que são fáceis de distribuir e compartilhar entre plataformas.

Compilando o executável

Para compilar seu aplicativo Go CLI, use o comando go build seguido pelo pacote ou arquivo de destino:

go build ./caminho/para/seu/pacote

Ou:

go build main.go

Esse comando criará um arquivo binário executável para sua plataforma atual (por exemplo, Windows, macOS, Linux) e o colocará no diretório de trabalho atual. Por padrão, o nome do arquivo binário corresponde ao nome do pacote ou ao nome do arquivo de origem sem a extensão (por exemplo, main).

No entanto, pode especificar os nomes dos ficheiros binários de saída e visar diferentes plataformas utilizando a bandeira -o e variáveis de ambiente:

GOOS=linux GOARCH=amd64 go build -o custom-name ./path/to/your/package

No exemplo acima, definimos as variáveis de ambiente GOOS e GOARCH para instruir o processo de compilação do Go a ter como alvo o Linux com uma arquitetura AMD64, e definimos o nome do arquivo binário de saída como nome personalizado.

Compilação cruzada para plataformas diferentes

O Go simplifica a compilação cruzada, e você pode criar rapidamente executáveis para várias plataformas sem configurações de compilação complexas. Para fazer a compilação cruzada do seu aplicativo Go CLI para várias plataformas, defina as variáveis de ambiente GOOS e GOARCH de acordo. O exemplo a seguir demonstra como fazer a compilação cruzada de um aplicativo Go CLI para Windows, macOS e Linux:

# Para Windows 64-bit GOOS=windows GOARCH=amd64 go build -o mycli-windows.exe ./path/to/package Para macOS 64-bit GOOS=darwin GOARCH=amd64 go build -o mycli-macos ./path/to/package Para Linux 64-bit GOOS=linux GOARCH=amd64 go build -o mycli-linux ./path/to/package

Distribuindo seu aplicativo CLI

Você pode distribuir seus arquivos binários executáveis da CLI em Go fornecendo opções de download direto no site do seu projeto ou na documentação README. Alternativamente, distribua como pacotes específicos da plataforma usando sistemas de empacotamento, repositórios ou gerenciadores de pacotes. Alguns sistemas populares de gerenciamento de pacotes incluem:

• Homebrew - Um gerenciador de pacotes para macOS e Linux com uma sintaxe amigável para instalar e gerenciar pacotes.
• APT (sistemas baseados em Debian) - Um gerenciador de pacotes para distribuições Linux baseadas em Debian, como o Ubuntu.
• RPM (sistemas baseados no Red Hat) - Um gerenciador de pacotes para distribuições Linux baseadas no Red Hat, como o Fedora.

Considerações finais e recursos

Criar poderosas aplicações CLI com Go é um processo agradável e gratificante. A simplicidade, o desempenho e as vantagens da distribuição binária tornam o Go uma escolha de linguagem de programação ideal para esse propósito. À medida que você continua a desenvolver seus aplicativos de CLI em Go, considere explorar recursos adicionais para expandir seu conhecimento e melhorar suas habilidades:

• Documentação oficial do Go - Um guia abrangente sobre a linguagem de programação Go e sua biblioteca padrão.
• Recursos de aprendizado em Go - Uma extensa lista de recursos de aprendizado em Go, incluindo tutoriais, livros e cursos.
• Awesome Go - Uma lista com curadoria de pacotes, bibliotecas e recursos Go, categorizados por tópico.
• Go by Example - Uma abordagem prática ao Go, com exemplos concisos e explicações para vários recursos do Go.

Além disso, considere explorar no-code plataformas como AppMaster.io que usam Go (golang) como sua linguagem de programação de backend. AppMaster O .io fornece uma interface intuitiva de arrastar e largar que lhe permite desenvolver aplicações Web, móveis e de backend sem escrever uma única linha de código. Ao compreender as plataformas Go e no-code como AppMaster.io, estará bem equipado para desenvolver soluções de software ainda mais sofisticadas no futuro.