Tutorial: Criar um módulo Go

Esta é a primeira parte de um tutorial que apresenta alguns recursos fundamentais da linguagem Go. Se você está começando agora com Go, não deixe de ler Tutorial: Primeiros passos com Go, que apresenta o comando go, os módulos Go e um código Go bem simples.

Neste tutorial você vai criar dois módulos. O primeiro é uma biblioteca feita para ser importada por outras bibliotecas ou aplicações. O segundo é uma aplicação chamadora que vai usar o primeiro.

A sequência deste tutorial inclui sete tópicos curtos, cada um ilustrando uma parte diferente da linguagem.

  1. Criar um módulo -- Escrever um módulo pequeno com funções que você pode chamar de outro módulo.
  2. Chamar seu código a partir de outro módulo -- Importar e usar o seu novo módulo.
  3. Retornar e tratar um erro -- Adicionar um tratamento de erro simples.
  4. Retornar uma saudação aleatória -- Trabalhar com dados em slices (os arrays de tamanho dinâmico do Go).
  5. Retornar saudações para várias pessoas -- Armazenar pares chave/valor em um map.
  6. Adicionar um teste -- Usar os recursos de testes unitários embutidos no Go para testar seu código.
  7. Compilar e instalar a aplicação -- Compilar e instalar seu código localmente.

Pré-requisitos

Comece um módulo que outras pessoas possam usar

Comece criando um módulo Go. Em um módulo, você reúne um ou mais pacotes relacionados para um conjunto discreto e útil de funções. Por exemplo, você poderia criar um módulo com pacotes que tenham funções para análise financeira, para que outras pessoas que escrevem aplicações financeiras possam usar o seu trabalho. Para saber mais sobre o desenvolvimento de módulos, veja Desenvolvendo e publicando módulos.

O código Go é agrupado em pacotes, e os pacotes são agrupados em módulos. O seu módulo especifica as dependências necessárias para executar o seu código, incluindo a versão do Go e o conjunto de outros módulos que ele exige.

À medida que você adiciona ou melhora funcionalidades no seu módulo, publica novas versões do módulo. Desenvolvedores que escrevem código que chama funções do seu módulo podem importar os pacotes atualizados do módulo e testar com a nova versão antes de colocá-la em uso em produção.

  1. Abra um prompt de comando e use cd para ir até o seu diretório pessoal.

    No Linux ou Mac:

    cd
    

    No Windows:

    cd %HOMEPATH%
    
  2. Crie um diretório greetings para o código-fonte do seu módulo Go.

    Por exemplo, a partir do seu diretório pessoal use os seguintes comandos:

    mkdir greetings
    cd greetings
    
  3. Inicie o seu módulo usando o comando go mod init.

    Execute o comando go mod init, passando o caminho do seu módulo -- aqui, use example.com/greetings. Se você publicar um módulo, isso precisa ser um caminho a partir do qual o seu módulo possa ser baixado pelas ferramentas do Go. Esse seria o repositório do seu código.

    Para mais detalhes sobre como nomear o seu módulo com um caminho de módulo, veja Gerenciando dependências.

    $ go mod init example.com/greetings
    go: creating new go.mod: module example.com/greetings
    

    O comando go mod init cria um arquivo go.mod para rastrear as dependências do seu código. Até agora, o arquivo inclui apenas o nome do seu módulo e a versão do Go que o seu código suporta. Mas, à medida que você adicionar dependências, o arquivo go.mod vai listar as versões das quais o seu código depende. Isso mantém as builds reproduzíveis e dá a você controle direto sobre quais versões de módulos usar.

  4. No seu editor de texto, crie um arquivo para escrever o seu código e chame-o de greetings.go.
  5. Cole o código a seguir no seu arquivo greetings.go e salve o arquivo.
    package greetings
    
    import "fmt"
    
    // Hello returns a greeting for the named person.
    func Hello(name string) string {
        // Return a greeting that embeds the name in a message.
        message := fmt.Sprintf("Hi, %v. Welcome!", name)
        return message
    }
    

    Este é o primeiro código do seu módulo. Ele retorna uma saudação para qualquer chamador que pedir uma. Você vai escrever código que chama esta função no próximo passo.

    Neste código, você:

    • Declara um pacote greetings para reunir funções relacionadas.
    • Implementa uma função Hello para retornar a saudação.

      Esta função recebe um parâmetro name cujo tipo é string. A função também retorna uma string. Em Go, uma função cujo nome começa com letra maiúscula pode ser chamada por uma função que não está no mesmo pacote. Isso é chamado em Go de nome exportado. Para saber mais sobre nomes exportados, veja Nomes exportados no Tour do Go.

    • Declara uma variável message para guardar a sua saudação.

      Em Go, o operador := é um atalho para declarar e inicializar uma variável em uma única linha (o Go usa o valor à direita para determinar o tipo da variável). Pelo caminho longo, você poderia ter escrito assim:

      var message string
      message = fmt.Sprintf("Hi, %v. Welcome!", name)
      
    • Use a função Sprintf do pacote fmt para criar a mensagem de saudação. O primeiro argumento é uma string de formato, e Sprintf substitui o valor do parâmetro name no verbo de formato %v. Inserir o valor do parâmetro name completa o texto da saudação.
    • Retorna o texto formatado da saudação para quem chamou.

No próximo passo, você vai chamar esta função a partir de outro módulo.