O Go é uma linguagem de programação que nasceu de frustrações no Google. Os desenvolvedores tinham que escolher continuamente entre uma linguagem eficaz na execução, mas que levava muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que não era eficaz na produção. A linguagem Go foi projetada para ter todas as três vantagens disponíveis ao mesmo tempo: velocidade de compilação, facilidade da programação e a eficiência da execução na produção.
Embora o Go seja uma linguagem de programação versátil que pode ser usada para muitos projetos de programação diferentes, ela é adequada particularmente para programas de sistemas de rede/distribuídos e ganhou uma reputação como “a linguagem da nuvem”. Essa linguagem se dedica a ajudar o programador moderno a produzir mais com um conjunto forte de ferramentas, tirando de cena os debates sobre a formatação e fazendo da formatação parte das especificações da linguagem, além de tornar a implantação fácil por meio da compilação em um binário único. A linguagem Go é fácil de aprender, com uma série pequena de palavras-chave que a tornam uma ótima escolha tanto para desenvolvedores iniciantes, quanto para experientes.
Este tutorial guiará você na instalação do Go em sua máquina local do Windows 10 e na configuração de um ambiente de programação através da linha de comando.
Você precisará de uma máquina com Windows 10 - com acesso administrativo e conectada à Internet.
Você concluirá a maior parte da instalação e configuração em uma interface de linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar em botões, você vai digitar em texto e receberá o feedback de seu computador por texto também. A linha de comando, também conhecida como shell, pode ajudar você a modificar e automatizar muitas das tarefas que você faz em um computador diariamente. Trata-se de uma ferramenta essencial para os desenvolvedores de software.
O PowerShell é um programa da Microsoft que fornece uma interface de shell de linha de comando. As tarefas administrativas são realizadas executando cmdlets, pronunciadas command-lets, que são classes especializadas do . NET Framework (software), que pode realizar as operações. De código aberto em agosto de 2016, o PowerShell agora está disponível para uso entre as plataformas, tanto para sistemas em Windows, como em Unix (incluindo Mac e Linux).
Para encontrar o Windows PowerShell, clique com o botão direito no ícone Start (Iniciar), no canto inferior esquerdo de sua tela. Quando o menu aparecer, clique em Search (Pesquisa) e, em seguida, digite PowerShell
na barra de busca. Quando as opções forem exibidas para você, clique com o botão direito no Windows PowerShell do aplicativo Desktop. Para os fins deste tutorial, selecione Run as Administrator (Executar como administrador). Quando a caixa de diálogo surgir com a questão Do you want to allow this app to make changes to your PC? (Deseja permitir que este aplicativo faça alterações no seu computador?) clique em Yes (Sim).
Assim que fizer isso, verá uma interface baseada em texto que tem uma string de palavras que se parece com esta:
Troque de pasta de sistema, digitando o seguinte comando:
- cd ~
Então, você estará em um diretório home, como o PS C:\Users\sammy
.
Para continuar com o processo de instalação, primeiro você deve definir as permissões através do PowerShell. Configurado para executar no modo mais seguro por padrão, existem alguns níveis de permissões que você pode configurar como administrador:
Neste tutorial, você usará a política de execução RemoteSigned
para definir as permissões do usuário atual. Isso permitirá que o PowerShell aceite scripts confiáveis sem criar as permissões tão amplas quanto elas seriam com uma permissão Unrestricted
. Digite o seguinte no PowerShell:
- Set-ExecutionPolicy -Scope CurrentUser
O PowerShell solicitará que você forneça uma política de execução. Digite o seguinte para usar o RemoteSigned
:
- RemoteSigned
Assim que pressionar ENTER
, será solicitado que confirme a mudança para a política de execução. Digite a letra y
para permitir que as alterações entrem em vigor. Você pode confirmar se isso funcionou, solicitando as permissões atuais na máquina:
- Get-ExecutionPolicy -List
Você deve receber um resultado que se parece com este:
Output Scope ExecutionPolicy
----- ---------------
MachinePolicy Undefined
UserPolicy Undefined
Process Undefined
CurrentUser RemoteSigned
LocalMachine Undefined
Isso confirma que o usuário atual pode executar scripts confiáveis baixados da Internet. Agora, você pode seguir em frente para baixar os arquivos que precisaremos para configurar nosso ambiente de programação em Go.
Um gerenciador de pacotes é uma coleção de ferramentas de software que funcionam para automatizar processos de instalação. Isso inclui a instalação inicial, o upgrade e a configuração do software, bem como a remoção de software - conforme necessário. Eles mantêm as instalações de software em um local central e podem manter todos os pacotes de software no sistema, nos formatos em que são habitualmente usados.
O Chocolatey é um gerenciador de pacotes de linha de comando criado para o Windows que funciona como o apt-get
funciona no Linux. Disponível em uma versão de código aberto, o Chocolatey ajudará você a instalar aplicativos e ferramentas rapidamente. Você o usará para baixar o que for necessário para o seu ambiente de desenvolvimento.
Antes de instalar o script, leia-o para confirmar que está satisfeito com as alterações que ele fará em sua máquina. Para fazer isso, use o framework de script .NET para baixar e exibir o script do Chocolatey na janela do seu terminal.
Comece criando um objeto WebClient chamado $script
que compartilha as configurações de conexão da Internet com o Internet Explorer:
- $script = New-Object Net.WebClient
Examine as opções disponíveis, canalizando o objeto $script
com uma |
para a classe Get-Member
:
- $script | Get-Member
Isso retornará todos os membros (propriedades e métodos) deste objeto WebClient:
. . .
[secondary_label Snippet of Output]
DownloadFileAsync Method void DownloadFileAsync(uri address, string fileName), void DownloadFileAsync(ur...
DownloadFileTaskAsync Method System.Threading.Tasks.Task DownloadFileTaskAsync(string address, string fileNa...
DownloadString Method string DownloadString(string address), string DownloadString(uri address) #method we will use
DownloadStringAsync Method void DownloadStringAsync(uri address), void DownloadStringAsync(uri address, Sy...
DownloadStringTaskAsync Method System.Threading.Tasks.Task[string] DownloadStringTaskAsync(string address), Sy…
. . .
Examinando o resultado, você consegue identificar o método DownloadString
, usado para exibir o script e a assinatura na janela do PowerShell. Use este método para verificar o script:
- $script.DownloadString("https://chocolatey.org/install.ps1")
Após verificar o script, instale o Chocolatey, digitando o seguinte no PowerShell:
- iwr https://chocolatey.org/install.ps1 -UseBasicParsing | iex
O cmdlet iwr
, ou Invoke-WebRequest
, permite que você extraia dados da Web. Isso passará o script para iex
, ou o cmdlet Invoke-Expression
, que executará o conteúdo do script e a instalação para o gerenciador de pacotes Chocolatey.
Permita que o PowerShell instale o Chocolatey. Assim que ele estiver totalmente instalado, comece a instalar as ferramentas adicionais com o comando choco
.
Se você precisar fazer o upgrade do Chocolatey no futuro, execute o seguinte comando:
- choco upgrade chocolatey
Com o gerenciador de pacotes instalado, instale o resto do que for necessário para o ambiente de programação em Go.
Neste passo, você instalará o nano, um editor de texto que usa uma interface de linha de comando. Você pode usar o nano para escrever programas diretamente dentro do PowerShell. Este não é um passo obrigatório, já que é possível usar um editor de texto com uma interface de usuário gráfica, como o Bloco de notas. Este tutorial recomenda que use o nano, uma vez que ele ajudará você a se acostumar a usar o PowerShell.
Use o Chocolatey para instalar o nano:
- choco install -y nano
O identificador -y
confirma automaticamente que você deseja executar o script, sem ser solicitado a confirmar.
Assim que o nano estiver instalado, utilize o comando nano
para criar novos arquivos de texto. Você usará isso mais tarde neste tutorial para escrever seu primeiro programa Go.
Assim como fez com o nano no passo anterior, você usará o Chocolatey para instalar o Go:
- choco install -y golang
Nota: como o go é uma palavra muito pequena, tornou-se comum usar golang
como um termo para instalar pacotes e procurar artigos relacionados ao Go na Internet. O termo Golang nasceu do domínio para a linguagem Go, que é o golang.org
.
O PowerShell instalará o Go, gerando resultados dentro do PowerShell durante o processo. Assim que a instalação for concluída, você deve ver o seguinte resultado:
OutputEnvironment Vars (like PATH) have changed. Close/reopen your shell to
see the changes (or in powershell/cmd.exe just type `refreshenv`).
The install of golang was successful.
Software installed as 'msi', install location is likely default.
Chocolatey installed 1/1 packages.
See the log for details (C:\ProgramData\chocolatey\logs\chocolatey.log).
Com a instalação finalizada, você agora confirmará que Go está instalado. Para ver as alterações, feche e abra novamente o PowerShell como administrador e, em seguida, verifique a versão do Go disponível em sua máquina local:
- go version
Você receberá um resultado parecido com este:
Outputgo version go1.12.1 windows/amd643.7.0
Assim que o Go estiver instalado, você poderá configurar um espaço de trabalho para seus projetos de desenvolvimento.
Agora que você tem o Chocolatey, o nano e Go instalados, crie seu espaço de trabalho de programação.
O espaço de trabalho em Go terá dois diretórios como sua raiz:
src
: o diretório que contém os arquivos fonte do Go. Um arquivo fonte é um arquivo que você escreve usando a linguagem de programação Go. Os arquivos fonte são usados pelo compilador Go para criar um arquivo binário executável.bin
: o diretório que contém executáveis compilados e instalados pelas ferramentas do Go. Os executáveis são arquivos binários que são executados no seu sistema e executam tarefas. Esses são programas tipicamente compilados pelo seu código fonte ou outro código fonte baixado do Go.O subdiretório src
pode conter vários repositórios de controle de versão (tais como o Git, o Mercurial, e o Bazaar). Você verá diretórios como o github.com
ou golang.org
quando seu programa importar bibliotecas de terceiros. Se estiver usando um repositório de códigos como o github.com
, você também colocará seus projetos e arquivos fonte sob aquele diretório. Isso permite uma importação canônica do código no seu projeto. As importações Canônicas são importações que referenciam um pacote totalmente qualificado, como o github.com/digitalocean/godo
.
Aqui está como um espaço de trabalho típico se parece:
.
├── bin
│ ├── buffalo # command executable
│ ├── dlv # command executable
│ └── packr # command executable
└── src
└── github.com
└── digitalocean
└── godo
├── .git # Git repository metadata
├── account.go # package source
├── account_test.go # test source
├── ...
├── timestamp.go
├── timestamp_test.go
└── util
├── droplet.go
└── droplet_test.go
A partir da versão 1.8, o diretório padrão para o espaço de trabalho do Go é o seu diretório home de usuário com um subdiretório go
, ou $HOME/go
. Se estiver usando uma versão anterior à versão 1.8 do Go, ainda é considerada como melhor prática usar o local $HOME/go
como o seu espaço de trabalho.
Emita o comando seguinte para navegar até o diretório $HOME
:
- cd $HOME
Em seguida, crie a estrutura de diretório para seu espaço de trabalho do Go:
- mkdir go/bin, go/src
Isso garantirá que a seguinte estrutura de diretório em funcionamento:
└── $HOME
└── go
├── bin
└── src
Antes do Go 1.8, era necessário definir uma variável local do ambiente chamada $GOPATH
. Embora já não seja necessário fazer isso, ainda é considerada uma boa prática, já que muitas ferramentas de terceiros ainda precisam que seja definida.
Como você usou o Chocolatey para a instalação, essa variável de ambiente já deverá estar definida. Verifique isso com o seguinte comando:
- $env:GOPATH
Você deve ver o seguinte resultado, com seu nome de usuário no lugar de sammy
:
OutputC:\Users\sammy\go
Quando o Go compila e instala ferramentas, ele as coloca no diretório $GOPATH/bin
. Por conveniência, é comum adicionar o subdiretório bin
do espaço de trabalho ao seu $PATH
. É possível fazer isso usando o comando setx
no PowerShell:
- setx PATH "$($env:path);$GOPATH\bin"
Isso permitirá que você execute qualquer programa que compilar ou baixar através das ferramentas Go - em qualquer lugar em seu sistema.
Agora que você tem a raiz do espaço de trabalho criada e sua variável de ambiente $GOPATH
definida, crie seus projetos futuros com a seguinte estrutura de diretório. Este exemplo supõe que esteja usando o github.com como seu repositório:
$GOPATH/src/github.com/username/project
Se estivesse trabalhando no projeto https://github.com/digitalocean/godo, você o colocaria no seguinte diretório:
$GOPATH/src/github.com/digitalocean/godo
Estruturar seus projetos dessa maneira irá torná-los disponíveis com a ferramenta go get
. Isso também ajudará mais adiante com a legibilidade.
É possível verificar isso usando o comando go get
para buscar a biblioteca godo
:
- go get github.com/digitalocean/godo
Nota: se não tiver o git
instalado, o Windows abrirá uma caixa de diálogo perguntando se deseja instalá-lo. Clique em Yes para continuar e siga as instruções de instalação.
É possível ver se ele baixou corretamente o pacote godo
, listando o diretório:
- ls $env:GOPATH/src/github.com/digitalocean/godo
Você receberá um resultado semelhante a este:
Output Directory: C:\Users\sammy\go\src\github.com\digitalocean\godo
Mode LastWriteTime Length Name
---- ------------- ------ ----
d----- 4/10/2019 2:59 PM util
-a---- 4/10/2019 2:59 PM 9 .gitignore
-a---- 4/10/2019 2:59 PM 69 .travis.yml
-a---- 4/10/2019 2:59 PM 1592 account.go
-a---- 4/10/2019 2:59 PM 1679 account_test.go
-rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md
-rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md
.
.
.
-a---- 4/10/2019 2:59 PM 5076 vpcs.go
-a---- 4/10/2019 2:59 PM 4309 vpcs_test.go
Neste passo, você criou um espaço de trabalho em Go e configurou as variáveis do ambiente necessárias. No próximo passo, você testará o espaço de trabalho com algum código.
Agora que você tem o espaço de trabalho em Go configurado, crie um programa “Hello, World!” simples. Isso garantirá que seu espaço de trabalho fique devidamente configurado, bem como dará a você a oportunidade de se familiarizar com o Go. Como está criando um único arquivo fonte em Go e não um projeto real, você não precisa estar em seu espaço de trabalho para fazer isso.
Do seu diretório home, abra um editor de texto de linha de comando, como o nano e crie um novo arquivo:
- nano hello.go
Assim que o arquivo de texto abrir no nano, digite seu programa:
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
Saia do nano
, pressionando as teclas CTRL
e X
. Quando solicitado a salvar o arquivo, pressione Y
e, então, ENTER
.
Esse código usará o pacote fmt
e chamará a função Println
com o Hello, World!
como argumento. Isso fará a frase Hello, World!
imprimir no terminal quando o programa for executado.
Assim que sair do nano
e retornar ao seu shell, execute o programa:
- go run hello.go
O programa hello.go que você acabou de criar deve fazer com que o PowerShell produza o seguinte resultado:
OutputHello, World!
Neste passo, você usou um programa básico para verificar se seu espaço de trabalho em Go foi configurado corretamente.
Parabéns! Neste ponto, você tem um espaço de trabalho de programação em GO configurado em sua máquina local (com Windows) e pode começar um projeto de codificação!
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!
Sign up for Infrastructure as a Newsletter.
Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.
Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.