A popularidade de Go aumentou ao longo dos anos. Mais empresas estão adotando o Go, e o pool de desenvolvedores está crescendo à medida que mais casos de uso para a linguagem são lançados. As pessoas o usam para criar programas que variam de aplicativos da Web rápidos, soluções de blockchain e ferramentas de aprendizado de máquina.
Os desenvolvedores adoram o Go por causa de sua expressividade, facilidade de uso e alto desempenho de linguagem. Go tem uma curva de aprendizado mais rápida do que a maioria das linguagens com um ecossistema de pacotes e bibliotecas em rápido crescimento.
Introdução ao Go
A linguagem de programação Go não está pré-instalado no Windows, macOS ou na maioria das distribuições Linux. Você precisará instalar o Go para executar programas Go. Você pode verificar o oficial Ir downloads página para instalá-lo em sua máquina. Você desejará instalar uma versão recente do Go para aproveitar ao máximo o idioma, pois as versões mais recentes têm mais recursos e atualizações.
Depois de instalar o Go, você pode trabalhar com a linguagem, executar arquivos Go, criar espaços de trabalho e construir projetos em Go.
Você pode criar um arquivo Go e executar programas Go usando a biblioteca padrão. No entanto, se você quiser usar bibliotecas externas, precisará criar um arquivo de módulos Go para gerenciamento de dependências, rastreamento de versão e muito mais.
O arquivo de módulos Go
Em Go, um módulo é uma coleção de pacotes em uma árvore de arquivos com um go.mod arquivo na raiz. Esse arquivo define o caminho do módulo, o caminho de importação e os requisitos de dependência para um processo de construção bem-sucedido.
Você pode criar um arquivo de módulos Go com o Go mod comando e o iniciar subcomando antes de especificar o caminho ou diretório para o projeto.
vai diretório do projeto mod init
O comando cria o go.mod Arquivo. O argumento após o iniciar comando é o caminho do módulo. O caminho do módulo pode ser o caminho do arquivo em seu ambiente de host ou o caminho do domínio do repositório.
Quando você instala pacotes e dependências externas, o go atualiza o exigir declaração no go.mod arquivo para garantir que eles sejam incluídos.
Você pode usar o limpo subcomando do mod comando para baixar todas as dependências necessárias para o seu programa.
vai mod arrumado
O comando baixará todas as importações ausentes para o arquivo de módulos go.
O namespace do pacote Go
Cada arquivo de origem Go pertence a um pacote e você pode acessar o código dentro de um namespace de pacote usando seu identificador.
Você pode ter vários namespaces para seus pacotes. Depois de criar uma pasta, você criou um novo namespace. Você pode acessar outros namespaces com uma notação de ponto (.).
// pasta 1
pacote pasta
funçãoPasta()algum {
// algum corpo de função aqui
Retorna0;
}
Aqui está um exemplo de acesso a um namespace diferente de outro namespace.
// pasta 2, arquivo em namespace diferente
pacote diretório
funçãodiretório() {
// acessando a função Folder do namespace da pasta
pastaFunc := pasta. Pasta()
}
Você terá que exportar o identificador capitalizando o nome para acessar um identificador em um namespace externo.
A função principal
o a Principal A função serve como ponto de entrada para programas Go. Você não pode executar um arquivo ou pacote Go sem a função main. Você pode ter um a Principal função em qualquer namespace; no entanto, você deve ter apenas um a Principal função em um arquivo ou pacote.
Aqui está um simples Programa Alô Mundo para demonstrar o a Principal função:
pacote a Principal
importar "fm"
funçãoa Principal {
fmt. Println("Olá, Mundo!")
}
Este código declara a a Principal função no a Principal namespace do pacote. Em seguida, importa o fmt pacote e usa o Imprimir método para enviar uma string para o console.
Importando pacotes em Go
Comparado com muitas outras linguagens, importar pacotes e dependências é fácil. o importar palavra-chave fornece funcionalidade para importar pacotes. Você pode importar pacotes da biblioteca padrão e dependências externas com o importar palavra-chave.
importar "fm"
No exemplo acima, você está importando um pacote. Você pode importar vários pacotes. Você terá que especificar os pacotes entre parênteses após o importar declaração.
importar (
"fm" // fmt para impressão
"registro" // log para logar
"rede/http" // http para aplicações web
"codificação/json" // json para serializar e desserializar structs para JSON
)
A adição de qualquer delimitador em instruções de importação é inválida. Você pode declarar um nome personalizado para importações especificando o nome personalizado antes do nome do pacote.
importar (
"rede/http"
codificador "codificação/json" // alias importa aqui
)
Aqui, você importou o json pacote com o nome personalizado como codificador. Você terá que acessar as funções e tipos do pacote com o nome personalizado (encoder).
Alguns pacotes exigem que você importe outros pacotes para efeitos colaterais. Você terá que preceder o nome do pacote com um sublinhado.
importar (
_ "fm" // importação de efeitos colaterais
"registro"
)
Você não pode acessar os pacotes que importou para efeitos colaterais, mas as dependências podem, se você as configurar.
Vá correr vs. Ir construir
Você usará o corre e construir comandos para compilar e executar seu código Go. Eles têm funcionalidades semelhantes e você os usará para executar pacotes.
o corre O comando é uma combinação de instruções de compilação e execução. o corre O comando executa o pacote sem criar nenhum executável no diretório de trabalho. Você terá que especificar o nome do arquivo do nome do pacote após o corre comando.
vai executar o arquivo.vai// executa um arquivo
vai execute nomedopacote // executa o pacote
o construir command é um comando de compilação que compila um pacote ou arquivo em um executável binário.
Se você executar o construir comando sem nenhum argumento após o nome do arquivo ou pacote, go irá gerar um executável no diretório raiz do seu pacote.
vai construir principal.vai// compila um arquivo
vai construir "pacote nome" // compila um pacote
Você terá que recompilar o programa com o construir comando quando você altera um pacote.
Você pode especificar um diretório como um argumento e o construir O comando produzirá o executável no diretório especificado.
vai arquivo de compilação -o "diretório"
Há tanto que você pode fazer com o Go
A biblioteca padrão Go é poderosa e intuitiva. Você pode criar aplicativos modernos rapidamente sem precisar instalar nenhuma dependência externa.
Desde o lançamento do Go em 2009, desenvolvedores e empresas o usaram para vários casos de uso, em diversos campos. Seu sucesso se deve principalmente porque o Go fornece uma sintaxe semelhante ao Python juntamente com o desempenho semelhante ao C.