Introdução
Go é uma linguagem de programação de código aberto e projetada para tornar os programadores mais produtivos. Foi criado no Google em 2009 por Robert Griesemer, Rob Pike e Ken Thompson, que desejavam uma linguagem que fosse rápida, simples, confiável e escalável. Alguns dos principais recursos do Go incluem:
download go 1.20.1
Suporte para ambiente adotando padrões semelhantes a linguagens dinâmicas
Tempo de compilação rápido
Suporte de simultaneidade embutido: processos leves (via goroutines), canais, instrução select
Simplicidade
Biblioteca padrão poderosa
Suporte de teste
Compilador poderoso
Ir binários
O Go tem sido usado por muitas organizações em todos os setores para alimentar seus softwares e serviços. Alguns exemplos de projetos famosos que usam Go são Docker, Kubernetes, Terraform, Hugo e gRPC. Você pode encontrar mais histórias de empresas que usam o Go .
Baixe e instale Go
Para compilar e executar um programa simples em Go, você precisa baixar e instalar a versão mais recente do Go do . O processo de instalação é diferente para diferentes sistemas operacionais. Aqui estão as etapas para Linux, Mac e Windows:
Linux
Remova qualquer instalação anterior do Go excluindo o /usr/local/go pasta (se existir), em seguida, extraia o arquivo que você acabou de baixar /usr/local, criando uma nova árvore Go em /usr/local/go:$ rm -rf /usr/local/go && tar -C /usr/local -xzf go1.20.4.linux-amd64.tar.gz(Talvez seja necessário executar o comando como root ou através do sudo).
Adicionar /usr/local/go/bin para a variável de ambiente PATH. Você pode fazer isso adicionando a seguinte linha ao seu $HOME/.profile ou /etc/profile (para uma instalação em todo o sistema):export PATH=$PATH:/usr/local/go/binObservação: as alterações feitas em um arquivo de perfil podem não ser aplicadas até a próxima vez que você fizer login no computador. Para aplicar as alterações imediatamente, basta executar os comandos do shell diretamente ou executá-los no perfil usando um comando como fonte $HOME/.profile.
Verifique se você instalou o Go abrindo um prompt de comando e digitando o seguinte comando:versão $ goConfirme se o comando imprime a versão instalada do Go.
Mac
Abra o arquivo do pacote que você baixou e siga as instruções para instalar o Go.O pacote instala a distribuição Go em /usr/local/go. A embalagem deve colocar o /usr/local/go/bin diretório em sua variável de ambiente PATH. Pode ser necessário reiniciar qualquer sessão aberta do Terminal para que a alteração entre em vigor.
Verifique se você instalou o Go abrindo um terminal e digitando o seguinte comando:versão $ goConfirme se o comando imprime a versão instalada do Go.
janelas
Abra o arquivo MSI que você baixou e siga as instruções para instalar o Go.O instalador deve colocar o C:\Go\bin diretório em sua variável de ambiente PATH. Pode ser necessário reiniciar qualquer prompt de comando aberto para que a alteração entre em vigor.
Verifique se você instalou o Go abrindo um prompt de comando e digitando o seguinte comando:C:\> ir versãoConfirme se o comando imprime a versão instalada do Go.
Escreva algum código em Go
Agora que você instalou o Go, pode escrever algum código em Go. Os programas Go são organizados em pacotes, que são coleções de arquivos de origem que compartilham um namespace comum e um conjunto de dependências. Um pacote pode ser executável ou uma biblioteca. Um pacote executável deve ter um arquivo chamado main.go que define uma função chamada principal(), que é o ponto de entrada do programa. Um pacote de biblioteca pode ser importado por outros pacotes para usar seus identificadores exportados, como tipos, variáveis, constantes e funções.
Olá Mundo!
Vamos começar com um programa simples que imprime "Hello, world!" para a saída padrão. Crie uma pasta chamada olá e dentro dele crie um arquivo chamado main.go. Em seguida, escreva o seguinte código no arquivo:
package main import "fmt" func main() fmt.Println("Olá, mundo!")
A primeira linha do código declara o nome do pacote, que é principal nesse caso. A segunda linha importa o fmt pacote da biblioteca padrão, que fornece funções de E/S formatadas. A terceira linha define o principal() função, que imprime "Hello, world!" usando o fmt.Println() função.
Para executar o programa, abra um terminal ou prompt de comando e navegue até o olá pasta. Em seguida digite o seguinte comando:
$ vá correr main.go
Você deve ver a saída "Hello, world!" em sua tela.
Código de chamada em um pacote externo
Você pode usar código de outros pacotes importando-os em seu programa. Por exemplo, você pode usar o pacote para gerar números aleatórios. Vamos modificar nosso programa para imprimir um número aleatório entre 1 e 10 em vez de "Hello, world!". Edite seu main.go arquivo e altere-o para:
package main import ( "fmt" "math/rand" "time" ) func main() // Semeie o gerador de números aleatórios com a hora atual rand.Seed(time.Now().UnixNano()) // Gere um número aleatório entre 1 e 10 n := rand.Intn(10) + 1 // Imprima o número fmt.Println(n)
A primeira linha do código permanece inalterada, ainda declara o nome do pacote como principal. A segunda linha importa três pacotes: . Usamos parênteses para agrupar várias importações em uma instrução. A terceira linha define o principal() função, que faz três coisas:
Ele chama o , que retorna a hora atual em nanossegundos. Isso é necessário para inicializar o gerador de números aleatórios com uma semente diferente toda vez que executamos o programa, caso contrário, obteríamos a mesma sequência de números aleatórios todas as vezes.
Ele chama o função com o argumento 10, que retorna um inteiro aleatório entre 0 e 9. Adicionamos 1 a esse resultado para obter um número entre 1 e 10.
Ele chama o função com o argumento n, que imprime o número na saída padrão.
Para executar o programa, abra um terminal ou prompt de comando e navegue até o olá pasta. Em seguida, digite o mesmo comando de antes:
$ vá correr main.go
Você deve ver um número aleatório entre 1 e 10 na tela. Tente executar o programa várias vezes e veja como a saída muda.
Escreva mais código em Go
Agora que você sabe como escrever e executar um programa simples em Go, vamos escrever mais alguns códigos em Go. Go tem muitos recursos e construções que tornam fácil e divertido escrever código. Alguns deles são:
Tipos de dados: Go tem tipos de dados básicos, como números, strings, booleanos e arrays, bem como tipos de dados compostos, como structs, slices, maps e interfaces.
Variáveis: Go tem uma sintaxe simples e concisa para declarar e atribuir variáveis. Você pode usar o var palavra-chave ou o operador de declaração curta :=.
Constantes: Go tem constantes que são declaradas com o const palavra-chave e não pode ser alterada.
Funções: Go possui funções que são declaradas com o função palavra-chave e pode ter zero ou mais parâmetros e valores de retorno. Você também pode definir funções anônimas e atribuí-las a variáveis ou passá-las como argumentos para outras funções.
Estruturas de controle: Go possui estruturas de controle como se, outro, trocar, para, e adiar que permitem controlar o fluxo do seu programa.
Tratamento de erros: Go tem um tipo de erro embutido que é retornado por funções que podem falhar. Você pode usar o erro value para verificar se há erros e tratá-los adequadamente.
Goroutines e canais: Go possui recursos de simultaneidade que permitem executar várias tarefas simultaneamente e se comunicar entre elas. Você pode usar o ir palavra-chave para iniciar uma função como uma goroutine, que é um thread leve de execução. Você pode usar canais para enviar e receber valores entre goroutines.
Uma calculadora simples
Para demonstrar alguns desses recursos, vamos escrever um programa de calculadora simples que executa operações aritméticas básicas em dois números. Crie uma pasta chamada calcular e dentro dele crie um arquivo chamado main.go. Em seguida, escreva o seguinte código no arquivo:
// Um programa de calculadora simples na importação principal do pacote Go ( "fmt" "os" "strconv" ) // Uma função que recebe dois números e um operador como strings // e retorna o resultado da operação como um float64 func calculate(num1, num2, op string) (float64, error) // Converte os números de strings em float64s n1, err1 := strconv.ParseFloat(num1, 64) n2, err 2 := strconv.ParseFloat(num2, 64) // Verifica se há erros na análise if err1 != nil func main() // Check if the number of arguments is correct if len(os.Args) != 4 fmt.Println("Usage: calc num1 op num2") os.Exit(1) // Get the arguments from the command line num1 := os.Args[1] op := os.Args[2] num2 := os.Args[3] // Call the calculate function with the arguments result, err := calculate(num1, num2, op) // Check for errors in calculation if err != nil fmt.Println("Error:", err) os.Exit(1) // Print the result fmt.Println(result)
A primeira linha do código é um comentário que descreve o programa. Comentários em Ir começam com // e são ignorados pelo compilador.A segunda linha declara o nome do pacote como principal. A terceira linha importa três pacotes: . O fmt O pacote fornece funções de E/S formatadas, o os pacote fornece acesso à funcionalidade do sistema operacional, e o strconv O pacote fornece conversões de e para representações de string de tipos de dados básicos.
O próximo bloco de código define uma função chamada calcular que recebe dois números e um operador como strings e retorna o resultado da operação como float64. A função também retorna um valor de erro que indica se o cálculo foi bem-sucedido ou não. A função usa o strconv.ParseFloat() função para converter os números de strings em float64s e verifica erros na análise. Então ele usa um trocar instrução para executar a operação com base no operador e verifica a divisão por zero. Se o operador for inválido, retorna um erro com uma mensagem.
O último bloco de código define o principal() função, que é o ponto de entrada do programa. A função usa o os.Args slice para obter os argumentos da linha de comando e verifica se o número de argumentos está correto. Então ele chama o calcular() função com os argumentos e verifica se há erros no cálculo. Se não houver erro, imprime o resultado usando o fmt.Println() função.
Para executar o programa, abra um terminal ou prompt de comando e navegue até o calcular pasta. Em seguida, digite um comando como este:
$ vá correr main.go 12 + 34
Você deve ver a saída 46 na tela. Você pode tentar diferentes números e operadores e ver como a saída muda.
Use o comando ir
O é uma ferramenta que você pode usar para gerenciar seu código Go e dependências. Possui muitos subcomandos que executam diferentes tarefas, como:
: compila seu código e produz um arquivo executável.
: compila e executa seu código sem produzir um arquivo executável.
: executa testes para seu código usando arquivos que terminam com _test.go.
: compila seu código e instala o arquivo executável em um diretório especificado.
: gerencia módulos, que são coleções de pacotes que podem ser versionados e distribuídos.
: mostra a documentação de um pacote ou um símbolo dentro de um pacote.
: formata seu código de acordo com um estilo padrão.
: verifica seu código em busca de erros comuns e possíveis bugs.
: lista informações sobre pacotes.
: baixa e instala pacotes de repositórios remotos.
Você pode usar esses subcomandos digitando ir seguido pelo nome do subcomando e quaisquer argumentos ou sinalizadores. Por exemplo, para construir seu programa de calculadora, você pode digitar:
$ vai construir main.go
Isso produzirá um arquivo executável chamado principal (ou main.exe no Windows) no mesmo diretório do arquivo de origem. Você pode executar este arquivo digitando:
$ ./principal 12 + 34
Você deve ver a mesma saída de antes.
Use a ferramenta de descoberta de pacotes Go
Uma das grandes vantagens do Go é que ele possui uma comunidade grande e ativa de desenvolvedores que criam e compartilham pacotes que você pode usar em seu próprio código. Existem milhares de pacotes disponíveis para diversos fins, como desenvolvimento web, processamento de dados, criptografia, teste, log e muito mais. Você pode encontrar esses pacotes usando o , que é um site que permite pesquisar e explorar pacotes do ecossistema Go.
Para usar a ferramenta, você pode visitar o site e digite uma palavra-chave ou um nome de pacote na caixa de pesquisa. Você também pode navegar por categorias, como web, banco de dados, aprendizado de máquina etc. Para cada pacote, você pode ver informações como nome, descrição, caminho de importação, licença, documentação, exemplos e código-fonte. Você também pode ver quantos outros pacotes dependem dele e quantas estrelas ele tem no GitHub.
Por exemplo, se você deseja localizar um pacote que forneça funcionalidade de cliente e servidor HTTP, digite http na caixa de pesquisa e veja uma lista de pacotes que correspondem à sua consulta. Um deles é o pacote da biblioteca padrão, que é o pacote mais usado para comunicação HTTP em Go. Você pode clicar nele e ver sua documentação e exemplos. Você também pode ver que ele tem mais de 1.000 pacotes dependentes e mais de 1.000 estrelas no GitHub.
Para usar um pacote em seu código, você precisa importá-lo usando seu caminho de importação. Por exemplo, para usar o rede/http package, você precisa adicionar esta linha ao seu código:
importar "rede/http"
Em seguida, você pode usar os identificadores exportados do pacote, como tipos, variáveis, constantes e funções. Por exemplo, para criar um servidor web simples que responda com "Hello, world!" a qualquer solicitação, você pode escrever este código:
package main import ( "fmt" "net/http" ) func main() // Define uma função de manipulador que escreve "Hello, world!" para o manipulador de resposta := func(w http.ResponseWriter, r *http.Request) fmt.Fprintln(w, "Hello, world!") // Registra a função do manipulador para o caminho raiz http.HandleFunc("/", handler) // Começa a ouvir solicitações HTTP na porta 8080 http.ListenAndServe(":8080", nil)
Para executar este programa, abra um terminal ou prompt de comando e navegue até a pasta onde você salvou o código. Então digite:
$ vá correr main.go
Isso iniciará o servidor da Web na porta 8080. Você pode abrir um navegador e visitar e veja a mensagem "Hello, world!" em sua tela.
Conclusão
Neste artigo, você aprendeu como baixar e instalar o Go, como escrever um código simples em Go e como usar algumas das ferramentas e bibliotecas fornecidas pelo Go. Você também aprendeu como usar o comando go para gerenciar seu código e dependências e como usar a ferramenta de descoberta de pacotes Go para localizar pacotes que você pode usar em seu próprio código.Você viu alguns exemplos de como o Go torna a programação fácil e divertida.
Go é uma linguagem poderosa e versátil que pode ajudá-lo a criar software rápido, confiável e escalável. Ele tem muitos recursos e benefícios que o tornam uma ótima opção para desenvolvimento web, serviços de nuvem e rede, devops e confiabilidade do site, interfaces de linha de comando e muito mais. Ele também possui uma comunidade grande e ativa de desenvolvedores que criam e compartilham pacotes que você pode usar em seu próprio código.
Se você quiser aprender mais sobre o Go, aqui estão alguns recursos que você pode conferir:
: o site oficial do Go, onde você pode encontrar documentação, tutoriais, postagens de blog, vídeos, podcasts e muito mais.
: um tutorial interativo que ensina os fundamentos do Go através de uma série de exercícios.
: um documento que dá dicas sobre como escrever um código Go claro e idiomático.
: um site da Web que mostra como usar vários recursos do Go por meio de programas de exemplo anotados.
: uma ferramenta on-line que permite escrever e executar código Go em seu navegador.
: Um curso on-line abrangente que cobre tudo o que você precisa saber sobre Go, desde o básico até os tópicos avançados.
perguntas frequentes
Aqui estão algumas perguntas frequentes sobre o Go:
Qual é a diferença entre Go e Golang?
Go e Golang são dois nomes para a mesma linguagem de programação. Go é o nome oficial do idioma, mas Golang é frequentemente usado como um nome alternativo, principalmente em buscas online, para evitar confusão com outros termos que também significam "go". Por exemplo, se você pesquisar "go tutorial" no Google, poderá obter resultados sobre o jogo de tabuleiro Go, o verbo go ou a linguagem de programação Go. Mas se você pesquisar por "tutorial golang", obterá apenas resultados sobre a linguagem de programação.
Go é uma linguagem compilada ou interpretada?
Go é uma linguagem compilada, o que significa que o código-fonte é traduzido em código executável por um compilador antes de poder ser executado. Isso torna os programas Go mais rápidos e eficientes do que as linguagens interpretadas, que executam o código-fonte diretamente sem compilá-lo. No entanto, o Go também possui alguns recursos que o fazem parecer uma linguagem interpretada, como tempo de compilação rápido, digitação dinâmica e desenvolvimento interativo.
Go é uma linguagem orientada a objetos?
Go não é uma linguagem tradicional orientada a objetos, o que significa que não possui classes, herança ou construtores. No entanto, Go tem alguns recursos que suportam programação orientada a objetos, como structs, métodos, interfaces e incorporação. Estruturas são estruturas de dados que podem ter campos e métodos. Métodos são funções associadas a um tipo específico. As interfaces são tipos abstratos que definem um conjunto de métodos. A incorporação é uma maneira de compor structs de outras structs ou interfaces.
Go é uma linguagem funcional?
Go não é uma linguagem funcional pura, o que significa que não impõe imutabilidade, recursão ou funções de ordem superior. No entanto, Go tem alguns recursos que suportam programação funcional, como funções de primeira classe, encerramentos e vários valores de retorno. Funções de primeira classe são funções que podem ser atribuídas a variáveis ou passadas como argumentos para outras funções. Closures são funções que podem acessar variáveis de seu escopo externo. Múltiplos valores de retorno são funções que podem retornar mais de um valor.
Go é uma linguagem de baixo nível ou de alto nível?
Go não é uma linguagem de baixo nível nem de alto nível, mas sim uma linguagem de nível médio. Isso significa que ele possui alguns recursos que o aproximam do hardware, como ponteiros, gerenciamento de memória e primitivas de concorrência. Mas também possui alguns recursos que o aproximam do desenvolvedor, como coleta de lixo, tratamento de erros e suporte a testes.Isso torna o Go uma boa escolha para escrever programas que precisam de desempenho e produtividade.
0517a86e26
Comments