Um dos fatores que contribuem para a popularidade do Go é seu conjunto de ferramentas que suporta a produtividade do desenvolvedor.
o vai O comando tem muitos subcomandos e opções para trabalhar com seu código-fonte go. Ele permite que você crie e execute programas, gerencie dependências e muito mais.
Obtendo uma visão geral dos comandos e da configuração do Go
Você pode visualizar a lista de comandos Go disponíveis usando o ajuda comando:
vai ajuda Sem mais argumentos, este comando lista todos os comandos, descrevendo o que cada um faz. Ele também exibe tópicos que são páginas de ajuda adicionais que não se referem diretamente aos comandos:
Você pode usar o ajuda command com qualquer outro comando ou tópico Go para ver uma visão geral do que o comando faz:
vai teste de ajuda
Você pode usar o env comando para visualizar suas variáveis de ambiente Go:
vai env
Você pode usar variáveis de ambiente Go para reconfigurar o tempo de execução Go junto com outras configurações importantes.
Você pode acessar uma variável de ambiente específica especificando o nome da variável após o
env comando. Por exemplo, para imprimir o valor atual do GOPATH variável:vai ambiente GOPATH
GOPATH é a pasta raiz de uma área de trabalho Go e outras áreas de trabalho Go referem-se a GOPATH. A configuração do ambiente GOPATH é um pré-requisito para usar alguns pacotes Go.
Por padrão, o GOPATH está definido para $HOME/go ou %USERPROFILE%\go dependendo do seu sistema operacional. Você pode alterar o GOPATH adicionando-o ao arquivo de configuração do shell.
export GOPATH=/full/vai/path
O comando altera o GOPATH para o caminho especificado.
Instalando e compilando pacotes em Go
Você precisará instalar e gerenciar dependências externas à medida que trabalhar com ir.
Você pode usar o pegue comando para baixar dependências de seus pacotes. Você precisará especificar o local do recurso como um argumento para o pegue comando:
vai obter gorm.io/gorm
vai obtenha github.com/spf13/cobra
Esses comandos instalam o popular pacote GORM ORM para Bancos de dados SQL e o pacote Cobra para construir CLIs. Você pode importar o pacote em seu programa especificando o caminho do recurso:
importar (
"gorm.io/gorm"
"github.com/spf13/cobra"
)
Go fornece um construir comando para construir seus programas. O comando build compila pacotes em executáveis binários:
vai construir
vai construir "pacote nome"
O comando acima compila seu pacote em um executável em seu diretório de trabalho.
Você pode especificar um caminho com o construir comando para salvar o executável em um diretório especificado.
vai construa "seu caminho de diretório aqui"
Você pode usar o instalar comando para compilar e instalar módulos Go. Como o construir comando, instalar constrói seu programa. Mas também adiciona um pacote executável aos seus binários Go em seu $GOPATH/bin diretório de instalação.
vai instalar
O comando install instala os pacotes em seu diretório de trabalho sem argumentos adicionais. Você pode especificar um local de recurso opcional para instalar dependências externas.
vai instale golang.org/x/tools/gopls@latest
Este comando instala o pacote Go especificado e você pode executar o pacote como uma ferramenta de linha de comando.
Gerenciando dependências em Go
Os comandos de gerenciamento de dependência são alguns dos comandos mais comuns que você usará com qualquer idioma. Você precisará baixar, atualizar e visualizar as dependências do seu aplicativo durante a fase de desenvolvimento.
o mod O comando fornece acesso a operações em módulos Go e gerenciamento de dependência.
Você precisará de um subcomando adicional com o comando mod, dependendo da sua operação.
o iniciar O subcomando inicializa um arquivo de módulos Go no diretório de trabalho atual:
vai inicialização do mod
Ao executar o comando, você encontrará um go.mod arquivo em seu diretório de trabalho com uma lista de dependências do seu aplicativo.
Você pode usar o limpo subcomando para adicionar módulos ausentes e remover módulos não utilizados:
vai mod arrumado
Este comando é útil quando você tem arquivos Go e precisa baixar as dependências para o seu pacote.
o gráfico O subcomando retorna uma lista dos requisitos de um módulo:
vai gráfico mod
Este comando é útil para recuperar uma visão geral de suas dependências.
Você pode precisar verificar os pacotes e módulos em seu espaço de trabalho atual por vários motivos. o Lista O comando lista todos os pacotes e módulos em um formato especificado.
Execute este comando para listar todos os pacotes e módulos em um espaço de trabalho.
vai lista -m todos
O comando também lista as dependências diretas e indiretas no diretório de trabalho.
Comandos de teste de ir
O teste é outro aspecto importante do desenvolvimento Go. o teste O comando automatiza os pacotes de teste nomeados por seus caminhos de importação e gera um resumo dos resultados do teste.
Ao executar o teste comando, o compilador Go verifica os arquivos de teste Go, executa os testes e gera os resultados. A convenção de nomenclatura típica para arquivos de teste Go é usar um _teste sufixo:
toque em algo_test.vai
Este comando cria um arquivo de teste Go em sistemas baseados em Unix. Você pode continuar a escrever seus testes Go e executá-los com o teste comando.
Você não precisa necessariamente de comandos ou argumentos adicionais para executar seu teste Go.
vai teste
Sem parâmetros adicionais, o teste O comando gera resultados de teste neste formulário.
A primeira coluna é o status do teste, a segunda é o pacote e a terceira é a duração do teste.
Adicionando o -v sinalizador retorna uma saída detalhada dos resultados do teste:
vai teste -v
o -v sinalizador retorna o status de cada função de teste junto com os resultados da execução do teste comando sem a bandeira.
Você pode calcular a cobertura de teste do seu pacote com o --cobrir bandeira.
vai teste --capa
o --cobrir sinalizador retorna a porcentagem de código que os testes cobrem em seu pacote.
Você pode adicionar um parâmetro de diretório opcional antes do --cobrir sinalizador para acessar a cobertura de teste em um diretório específico.
vai test "diretório" --cover
Os aplicativos de linha de comando podem tornar certas tarefas muito mais rápidas, principalmente as repetitivas. Eles também tendem a ser mais leves, pois não envolvem operações gráficas mais complexas.
Um dos casos de uso pretendidos do Go é construir aplicativos de linha de comando interativos de alto desempenho. Muitos aplicativos CLI populares, do Docker ao Hugo, são criados em Go.
Go fornece um bandeiras pacote para construir ferramentas interativas de CLI como a Go CLI na biblioteca padrão. Você pode usar pacotes externos como Cobra, Viper e muitos outros no ecossistema Go para criar aplicativos de linha de comando rápidos e interativos em Go.