Go é uma linguagem de fácil entendimento, de alto desempenho e excelente nível prático. Confira agora como instalar e funciona a linguagem GO.
Tempo de Leitura: 5 minutos
Go é uma linguagem de programação de código aberto.
Ela foi desenvolvida pelo Google em 2007, mas foi lançada em código aberto apenas em 2009. Acredita-se que ela possa substituir o Java no futuro.
Fortemente tipada e compilada, seu código-fonte é executado diretamente pelo sistema operacional ou pelo processador.
Essa linguagem permite a programação simultânea, bem como o gerenciamento de memória e a execução adiada de algumas funções.
Basicamente, ela é semelhante à linguagem C, porém bastante robusta e bem aceita entre os developers.
Go é uma linguagem de fácil entendimento, de alto desempenho e excelente nível prático. Portanto, para os que já estão acostumados com o estilo C ou Java podem se adaptar mais facilmente a ela. Não é à toa, aliás, que se comenta que essa linguagem veio para substituir o Java.
Cases da Linguagem GI
Go tem feito sucesso nas equipes de desenvolvimento de empresas e startups.
Confira algumas das marcas e plataformas que utilizam essa linguagem: Netflix, Mercado Livre, Magalu, Dropbox, Uber, Imgur, Medium, Booking, SpaceX
Instalando o Go
Instalação Windows
Confira o passo a passo da instalação da Linguagem GO no Windows:
- Entrar no site de downloads da Go e baixar a última versão para Windows com a extensão .msi;
- Abra o arquivo MSI que você baixou e siga as instruções para instalar o Go.
Por padrão, será instalado em Program Files ou Program Files (x86). Você pode alterar o local conforme necessário. Após a instalação, você precisará fechar e reabrir todos os prompts de comando, abertos para que as alterações no ambiente feitas pelo instalador sejam refletidas no prompt de comando. - Verifique se você instalou o Go:
No Windows , clique no menu Iniciar .
Na caixa de pesquisa do menu, digite cmd e pressione a tecla Enter .
Na janela Prompt de Comando que aparece, digite o seguinte comando:
go version - Confirme se o comando imprime a versão instalada do Go.
Instalação Linux (Ubuntu)
Confira o passo a passo da instalação da Linguagem GO no Linux (Ubuntu):
- Instalar ubuntu updates
sudo apt-get update
sudo apt-get -y upgrade - Download do binário
O próximo passo lógico é baixar o arquivo binário Go, o software mais recente estará disponível em https://golang.org/dl/ e instalar a versão do Ubuntu, execute os comandos abaixo no terminal
Criar uma pasta temp: mkdir temp
Acessar a pasta temp: cd temp
baixar o binario: wget https://dl.google.com/go/go1.19.linux-amd64.tar.gz - Extraia o arquivo baixado e instale no local desejado no sistema.
Execute os comandos abaixo no terminal para instalação:
sudo tar -xvf go1.19.linux-amd64.tar.gz
Mova a pasta go para o caminho /user/local :
sudo mv go /usr/local - As três variáveis de ambiente da linguagem Go que estamos configurando são GOROOT, GOPATH e PATH.
GOROOT é o caminho onde o Go está instalado na máquina
GOPATH é o local de trabalho.
Adicione isso em um arquivo .bashrc e de acordo com sua configuração de shell.
export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH
Após renovar as sessões de shell: source .bashrc - Go agora deve ter sido instalado com sucesso na máquina.
Para verificar se ele é executado abaixo do comando
go version
e se estiver bem instalado e configurado, você deve ver a versão instalada do Go
Go Module:
A partir da versão 1.13, foi adicionada uma nova maneira de gerenciar as bibliotecas de um projeto em Go com dependencias. chamado Gomod.
Pré-requisitos:
Para seguir este tutorial, você precisará de:
- Go versão 1.16 ou superior instalada.
- Familiaridade com a escrita de pacotes em Go.
Criando um novo módulo:
Criar uma pasta onde ficará o seu projeto. Nessa pasta poderá dar o comando gomod init <nome do projeto>
ex: go mod init thiago.alves\<projeto>
Após a execução do código será criado um arquivo go.mod onde será gerenciado os módulos desse projeto.
Criando um projeto:
Agora vamos "pôr a mão na massa". Comecemos com um projeto simples
Vamos criar uma arquitetura de pastas nos meus documentos com o nome go -> exemplos -> exemplo01:
Na pasta exemplo01 iniciaremos o módulo aqui farei go mod init thiago.alves\exemplo01
Agora vamos criar um arquivo main.go e inserir esse código
clique para ver maior
Ao executar o comando "go run main.go" ele irá escrever na tela Olá mundo!. Simples né.
Agora vamos entender sobre a sintaxe da linguagem.
Variáveis:
Declaração e atribuições de variáveis:
Você pode iniciar uma variável em qualquer contexto na linguagem Go. Dentro ou fora de uma função.
var i int
i = 10
var f, g string = "Olá", "Mundo"
Você pode apenas pode declarar e atribuir valor a uma variável de uma única vez se você estiver dentro do escopo de uma função.
package main //descrição do pacote
import "fmt" // importação da biblioteca
var f, g string = "Duas", "Frases" //declaração de variáveis tipo string alinhadas
var h = `Outra maneira de
declarar uma
string`
func main() {
msg := "Olá mundo!" //declaração de variável dentro de uma função
fmt.Println(msg) // método que retorna o texto em tela.
fmt.Println(f + " " + g)
fmt.Println(h)
}
Principais tipos de variáveis:
package main //descrição do pacote
import "fmt" // importação da biblioteca
func main() {
// Principais tipos de variáveis
a := 10
b := "Hello"
c := 10.33
d := false
e := 'W'
f := `você
pode quebrar
todo o texto `
// Imprime valores
fmt.Printf("%v \n", a)
fmt.Printf("%v \n", b)
fmt.Printf("%v \n", c)
fmt.Printf("%v \n", d)
fmt.Printf("%v \n", e)
fmt.Printf("%v \n", f)
// Imprime tipos
fmt.Printf("%T \n", a) // int
fmt.Printf("%T \n", b) // string
fmt.Printf("%T \n", c) // float64
fmt.Printf("%T \n", d) // bool
fmt.Printf("%T \n", e) //int32
fmt.Printf("%T \n", f) // string
}
Constantes:
Uma constante basicamente é uma “variável” que não pode ter seu valor alterado. Na linguagem Go você precisa declarar uma constante utilizando apenas o “=” e não “:=”. Ela pode ser definida globalmente em seu pacote ou mesmo localmente em uma função.
Exemplo:
package main //descrição do pacote
import "fmt" // importação da biblioteca
const xyz int = 222
const x = 10
const (
aa string = "x"
bb = 66
cc int = 567
)
func main() {
fmt.Println(xyz) // método que retorna o texto em tela.
fmt.Println(x)
fmt.Println(aa)
fmt.Println(bb)
fmt.Println(cc)
}
Funções:
A sintaxe de uma função é a seguinte:
func RetornaString(a string) string {
}
No caso acima, “RetornaString” é o nome da função, “a” que é do tipo string é o parâmetro de entrada e “string” é o tipo de retorno. Existe uma leve sutileza quando trabalhamos com funções em Go, veja no exemplo a seguir.
package main //descrição do pacote
import "fmt" // importação da biblioteca
func main() {
fmt.Println(RetornaString("Teste")) // método que retorna o texto em tela.
}
func RetornaString(a string) string {
var x = "retornando a string: " + a
return x
}
Nesse caso, especificamente qual variável devemos retornar após o “return”, verifique que na definição da função, estamos especificando a variável “x”, logo, nesse caso, por padrão a função retornará o valor de “x + a”.
Finalizando. Esse foi somente o básico do básico para iniciar com a Linguagem Go, ela é muito poderosa e versátil para uma infinidade de soluções.
Caso queira aprender mais, aconselho dar uma olhada nesses tutoriais:
go.dev/tour e gobyexample.com/
O melhor de tudo, eles são grátis.
E que tal continuar a conversa sobre linguagens de programação lá no fórum? Clique no botão abaixo e nos encontramos por lá 😉
