Exercício – Olá, Mundo

  • 6 minutos

Nesta seção, você criará seu primeiro programa do Go para exibir uma mensagem na tela. Este exercício é uma maneira comum de começar a usar uma linguagem de programação. Você aprenderá mais sobre a CLI (interface de linha de comando) do Go e como compilar e executar um aplicativo Go.

Configurar o IDE para ser aberto por meio da CLI

Você pode abrir o IDE do Visual Studio Code no prompt da CLI e começar a editar os arquivos em seu workspace atual. Esse recurso do IDE é implementado usando a variável de ambiente do sistema $PATH (ou $Path). Quando o recurso estiver habilitado, você poderá usar o comando code . por meio da CLI para abrir o IDE e editar os arquivos no diretório atual.

Algumas instalações do Visual Studio Code adicionam suporte da CLI à variável $PATH por padrão. Você pode ver essa opção durante o processo de instalação. Se você já tiver essa configuração definida, estará tudo pronto. Caso contrário, talvez seja necessário executar as etapas a seguir para usar esse recurso.

Linux ou macOS

Siga estas etapas para registrar a CLI do Visual Studio Code na variável de ambiente $PATH:

  1. Abra o Visual Studio Code.

  2. Em Exibir, selecione Paleta de Comandos.

  3. Na caixa de pesquisa, insira comando do shell. Conforme você digita, os resultados são filtrados.

  4. Escolha o comando Shell Command: Install 'code' command in PATH.

  5. Feche o prompt do terminal ou o comando aberto.

    Importante

    Se você tiver um prompt aberto do exercício anterior, feche o prompt e abra um novo. Essa etapa é necessária para que o novo valor de $PATH entre em vigor.

  6. Feche o Visual Studio Code.

Windows

Siga estas etapas para adicionar o local da CLI do Visual Studio Code à sua variável de ambiente do sistema $Path:

Observação

Se você tiver familiaridade com variáveis de ambiente e souber como adicionar um novo local à variável do sistema $Path, poderá usar o método que funciona melhor para você. O procedimento a seguir é um pouco longo, mas é um método confirmado para garantir que a variável seja atualizada corretamente.

  1. Abra o Painel de Controle do Windows.

  2. Selecione Sistema e depois Configurações avançadas do sistema.

  3. Na caixa de diálogo Propriedades do sistema, em Avançado, selecione Variáveis de ambiente. A caixa de diálogo Editar variáveis de ambiente é aberta.

    A caixa de diálogo Editar variáveis de ambiente mostra duas listas:

    • Variáveis de usuário para <user-name>: definições de variáveis locais para o usuário específico.
    • Variáveis do sistema: definições de variável do sistema para todos os usuários.

    Neste procedimento, estamos trabalhando com as variáveis do sistema.

  4. Na caixa de diálogo Variáveis de ambiente, na caixa de listagem Variáveis do sistema, role a tela para localizar a variável Path.

  5. Selecione a variável Path para realçar a linha. Selecione Editar. A caixa de diálogo Editar variáveis de ambiente é aberta. A caixa de diálogo lista todos os locais de pasta definidos na variável.

  6. Na caixa de diálogo Editar variáveis de ambiente, selecione Novo. Uma linha vazia é aberta no final da lista.

  7. Na linha vazia, insira o local do executável da CLI do Visual Studio Code. Substitua <user-name> por seu nome de usuário.

    C:\Users\<user-name>\AppData\Local\Programs\Microsoft VS Code\bin

  8. Selecione OK para fechar as caixas de diálogo.

  9. Feche a caixa de diálogo Propriedades do sistema e o Painel de controle do Windows.

Etapa 1: abrir o workspace do Go e o IDE

Depois de confirmar que o Visual Studio Code está pronto para uso por meio da CLI, você pode abrir seu workspace do Go.

  1. Abra um novo comando ou prompt do terminal.

  2. Abra seu diretório do workspace do Go executando o seguinte comando:

    cd $GOPATH/src

    cd %GOPATH%/src

  3. Use o seguinte comando para abrir o Visual Studio Code pelo workspace:

    code .

O Visual Studio Code é iniciado. A exibição do Explorador é mostrada à esquerda, e uma Página inicial está à direita.

Na exibição do Explorador, a seção SRC de seu projeto do Go deve ser aberta (expandida). Essa seção é a pasta /src do seu projeto. Ela está vazia no momento, mas adicionaremos algum conteúdo na próxima etapa.

Etapa 2: criar uma pasta e um arquivo do Go

Vamos adicionar uma pasta e um arquivo ao seu projeto do Go. No Visual Studio Code, há várias maneiras de criar itens:

  • Ações no menu da barra de ferramentas:
    • Selecione Arquivo>Abrir pasta e crie uma Pasta.
    • Selecione Arquivo>Novo arquivo e inicie um novo arquivo.
  • Links na Página inicial semelhantes às ações de menu da barra de ferramentas.
  • Ícones na exibição do Explorador, à direita da seção SRC:
    • Selecione o ícone Nova pasta. Na caixa de texto, digite o nome da pasta e pressione Enter.
    • Selecione o ícone Novo arquivo. Na caixa de texto, digite o nome do arquivo e pressione Enter.

Conclua as etapas a seguir no Visual Studio Code. Para criar o arquivo e a pasta, use o processo que funciona melhor para você.

  1. Crie uma pasta chamada helloworld.

  2. Crie um arquivo chamado main.go para o código do aplicativo.

  3. Expanda a exibição Explorador>SRC para mostrar a árvore de estrutura de pastas. Ele será semelhante a este exemplo:

    SRC/
        helloworld/
            main.go

Instalar ferramentas da extensão do Go

Se main.go for o primeiro arquivo do Go que você abrir no Visual Studio Code, poderá ser preciso a instalar outras ferramentas da extensão do Go. Quando solicitado, selecione Instalar. Um terminal é aberto na parte inferior do IDE para mostrar a saída do processo. Você verá uma saída como este exemplo:

Ambiente de ferramentas: GOPATH=C:\Projects\Go
Instalação de cinco ferramentas em C:\Projects\Go\bin no modo de módulo.
Instalação de github.com/uudashr/gopkgs/v2/cmd/gopkgs (C:\Projects\Go\bin\gopkgs.exe) bem-sucedida

Durante o processo de instalação, verifique a barra de status no Visual Studio Code. Se você vir uma mensagem no canto inferior direito, como "Todas as ferramentas não instaladas", selecione a mensagem. No pop-up, selecione Instalar.

Quando o processo de instalação for executado com sucesso, a saída do terminal exibirá um resumo:

Todas as ferramentas foram instaladas com êxito. Tudo pronto para usar o Go :).

Etapa 3: adicionar código ao arquivo do Go

Agora vamos adicionar código ao seu arquivo do Go.

  1. No arquivo main.go, adicione o seguinte código:

    package main

import "fmt"

func main() {
    fmt.Println("Hello World!")
}

  2. Salve o arquivo.

Não se preocupe com a formatação de código, como guias ou espaços. O Visual Studio Code formata o código automaticamente sempre que você salva o arquivo.

Etapa 4: executar o programa do Go

O programa do Go pode ser executado em um prompt do terminal ou comando ou em um terminal que é executado dentro do Visual Studio Code.

Você pode usar um prompt existente ou abrir um novo. Se abrir um novo prompt, lembre-se de alterar o local do diretório para seu workspace do Go. Além disso, execute o programa pela pasta que tem o arquivo do Go: $GOPATH/src/HelloWorld.

Abrir um terminal no Visual Studio Code

Se você quiser executar o programa no Visual Studio Code, e não em um prompt de terminal ou comando autônomo, siga estas etapas:

  1. No Visual Studio Code, selecione Terminal e Novo Terminal.

  2. Na caixa suspensa na parte superior direita do terminal, selecione Novo Prompt de Comando.

  3. No terminal, execute o seguinte comando a fim de alterar o local do diretório para seu workspace do Go e a pasta que tem o arquivo do Go:

    cd $GOPATH/src/helloworld

    cd %GOPATH%/src/helloworld

Executar o aplicativo do Go

Para executar seu aplicativo do Go, use o seguinte comando em seu terminal ou prompt:

go run main.go

Você deve ver o seguinte resultado:

Hello World!

O comando go run realiza duas tarefas. Ele compila o aplicativo e, após a compilação bem-sucedida, executa o aplicativo.

Criar um executável

Para gerar um executável para seu programa, use este comando:

go build main.go

Quando o comando go build é concluído, ele gera um aplicativo executável que você pode executar a qualquer momento, sem processamento adicional. O comando só produz um executável. Ele não executa o programa como o comando go run.

Examinar o conteúdo do /src

Confira como deve ser a aparência do seu projeto agora na exibição Explorador>SRC:

SRC/
    helloworld/
        main
        main.go

Na exibição do Explorador, o nome do arquivo sem a extensão é o arquivo executável que você pode usar para executar seu programa. (No Windows, esse arquivo realmente tem a extensão .exe.) Quando você estiver desenvolvendo, use o comando go run. Para criar os binários para o aplicativo, use o comando go build e implante o executável binário em um ambiente adequado.

O que você acabou de escrever em Go?

Você criou seu primeiro aplicativo do Go e confirmou a compilação e execução dele. Vamos examinar cada linha do código.

Começaremos com a primeira instrução em seu arquivo do Go:

package main

A instrução package main é como podemos dizer ao Go que o aplicativo que estamos criando é um programa executável (um arquivo que você pode executar). Nosso aplicativo "Olá, Mundo!" faz parte do pacote main. Um pacote é um conjunto de arquivos de código-fonte comuns. Cada aplicativo executável tem essa primeira linha, mesmo que o projeto ou arquivo tenha um nome diferente.

Veremos mais detalhadamente esses conceitos no próximo módulo. Por enquanto, precisamos saber que cada programa executável deve fazer parte do pacote main.

Desafio: alterar o nome do pacote

Você pode confirmar a importância do pacote main?

  1. No arquivo do Go, altere o nome do pacote na primeira linha.
  2. Salve o arquivo e execute o programa novamente no terminal.

  O que acontece? Você vê "Olá, Mundo!"? Um executável binário é produzido?

 

Mostrar resposta
"Olá, Mundo!" não é exibido. Um executável binário não é produzido. Você verá um erro: `go run: cannot run non-main package`. Por quê? Cada programa executável deve fazer parte do pacote 'main'.

Esta é a próxima linha do arquivo do Go:

import "fmt"

A instrução import dá acesso ao seu programa para outro código em pacotes diferentes. Nesse caso, fmt é um pacote de biblioteca padrão. Você pode ler sobre o pacote fmt no site de documentação oficial do Go.

Você precisa dessa instrução import porque usará uma função desse pacote para exibir uma mensagem na tela mais tarde no programa. Você poderá incluir em seu programa quantas instruções import quiser ou precisar. No entanto, o Go é idiomático nesse sentido. Se você importar um pacote, mas não usar uma função correspondente dele, o aplicativo não será compilado. Um ótimo recurso do Visual Studio Code é que ele remove automaticamente as importações não usadas em um programa quando você salva o arquivo.

O Visual Studio Code removeu a importação quando você salvou o arquivo? Tente editar o arquivo sem o Visual Studio Code e executar o aplicativo. Que saída você vê agora?

Desafio: adicionar outra importação

Você pode verificar o que aprendeu sobre importações não usadas?

  1. Restaure o arquivo do Go para o código original.
  2. Adicione outra instrução de importação, como math ou io.
  3. Salve o arquivo e execute o programa novamente no terminal.

  O que acontece? O Visual Studio Code remove a importação não usada? Em caso afirmativo, quando ela é removida?

  1. Edite o arquivo do Go novamente, mas não use o Visual Studio Code.
  2. Salve o arquivo e execute o programa em um novo prompt.

  O que acontece? Que saída você vê agora?

 

Mostrar resposta
Se você editar seu arquivo Go no IDE, ao salvar seu arquivo, o Visual Studio Code detectará todos os pacotes não utilizados e removerá as instruções `import` correspondentes. Quando você edita seu arquivo Go fora do Visual Studio Code, o código falha. Você verá um erro como: `# command-line-arguments .\main.go:5:2: imported and not used: "math"`.

Vamos examinar o bloco de código no arquivo do Go:

func main() {
   fmt.Println("Hello World!")
}

A instrução func é uma palavra reservada usada para declarar uma função. Essa primeira função é chamada de "main" porque é o ponto de partida de nosso programa. Você pode ter apenas uma função main() no package main (aquela que você definiu na primeira linha). Na função main(), você chamou a função Println do pacote fmt. Você enviou uma mensagem de texto que gostaria de ver na tela.

Há mais conteúdo referente a funções a ser abordado, e faremos isso no próximo módulo.