Go: crie Métodos, Generics e Interface

Métodos e funções em Go - Apresentação

Boas-vindas! Meu nome é Guilherme Lima, sou instrutor na Alura, e irei te acompanhar ao longo dessa jornada de aprendizagem sobre a incrível linguagem Go.

Audiodescrição: Guilherme se descreve como um homem branco, de cabelo curto, liso e castanho-escuro, barba curta castanha, e olhos castanho-claros. Ele usa óculos de armação retangular preta, um relógio preto no pulso direito, veste uma camisa azul, e está sentado em frente a uma parede clara iluminada em gradiente azul e lilás, com um quadro de moldura prateada à sua direita e uma luminária de luz amarela logo abaixo do quadro.

O que vamos aprender?

Neste curso, vamos explorar o que são métodos em Go, criando um projeto baseado em um estoque no qual inserimos itens. Iremos modularizar o projeto, e aprender sobre generics e interfaces.

Conclusão

Você sairá deste curso com uma base sólida sobre o que de fato acontece nos códigos dessa linguagem na realidade. Caso tenha se interessado, nos encontramos no próximo vídeo!

Métodos e funções em Go - Iniciando o projeto

Vamos dar início ao curso e aprender ainda mais sobre a linguagem Go?

Iniciando o projeto

Para começar, vamos criar um sistema baseado em estoque. Na atividade anterior a este vídeo, disponibilizamos um documento PDF com a documentação do sistema que vamos desenvolver.

Dois pontos importantes a serem destacados são:

1. Visão geral — O sistema tem como objetivo gerenciar itens em estoque. Assim, poderemos realizar operações como adicionar um item ao estoque, remover, listar os itens disponíveis, ou calcular o custo total do estoque, com base no valor e na quantidade de cada produto;
2. Diagramas — Entretanto, é importante que cada alteração no estoque seja registrada em uma estrutura baseada em logs. Dessa forma, saberemos, por exemplo, qual ação uma pessoa usuária realizou com um item do estoque, como inserir ou remover um item. No documento, há um guia sobre como funcionam essas observações e classes; você pode acessar o documento e ler posteriormente.

Um ponto que ainda não enfatizamos nos cursos anteriores de Go são os métodos. Quando criamos uma struct, podemos criar funções vinculadas a ela. Vamos entender como isso funciona?

Criando o projeto estoque

Na área de trabalho, criaremos uma nova pasta chamada "estoque-go". Feito isso, usaremos o Visual Studio Code para editar a aplicação, como fizemos nos cursos anteriores de Go.

No terminal, iniciaremos o projeto com o comando go mod init seguido do nome do projeto (estoque). Isso criará o arquivo go.mod com a versão do Go utilizada.

go mod init estoque

go.mod:

module estoque

go 1.22.5

Criando a estrutura de pastas do projeto

Agora, podemos criar as estruturas de pastas necessárias para o projeto. Usaremos o comando mkdir -p para criar duas pastas:

• A pasta internal, onde manteremos o código relacionado ao módulo que estamos desenvolvendo;
• E a pasta cmd, que será o ponto inicial da nossa aplicação.

mkdir -p internal cmd

Criando o arquivo main.go

Em seguida, criaremos o arquivo main.go na pasta "cmd" com o comando:

touch cmd/main.go

O código principal será criado em main.go. Primeiro, usaremos o atalho pkgm para criar a estrutura. Em seguida, usaremos fmt.Println() para exibir "Sistema de Estoque".

Feito isso, podemos executar o código com go run cmd/main.go.

main.go:

package main

import "fmt"

func main() {
    fmt.Println("Sistema de Estoque")
}

go run cmd/main.go

Retorno do comando:

Sistema de Estoque

Desenvolvendo a pasta "internal"

Agora, vamos começar a desenvolver a pasta "internal", onde criaremos os módulos e estruturas necessárias. Teremos duas estruturas importantes:

• "models", onde definiremos as struct;
• E "services", onde definiremos as ações disponíveis, como inserir um item, removê-lo e visualizar o log, por exemplo.

Criando o arquivo item.go

Começando pela pasta "models", vamos criar um novo arquivo chamado item.go, que fará parte do pacote (package) models. Logo abaixo, iremos declarar uma struct chamada Item, com campos como ID, Name, Quantity e Price, dos tipos int, string, int e float64, respectivamente.

item.go:

package models

type Item struct {
    ID       int
    Name     string
    Quantity int
    Price    float64
}

Feito isso, vamos criar um método específico para Item struct. Na linguagem Go, podemos definir métodos para tipos (type) definidos por nós.

Declarando o método Info()

A ideia é criar um método que exiba informações como ID, Name e Quantity. Para isso, vamos declarar uma func — dado que esse método também é uma função — chamada Info(), que não receberá parâmetros e retornará uma string.

A estrutura de um método em Go é um pouco diferente. Primeiro, usamos a palavra reservada func, seguida do nome do receptor, que é i Item.

package models

type Item struct {
    ID       int
    Name     string
    Quantity int
    Price    float64
}

func (i Item) Info() string {

}

No escopo, o método Info() retornará uma string formatada com fmt.Sprintf(), exibindo os valores de ID, Name, Quantity e Price. Para acessar os atributos da struct, utilizamos o receptor i, seguido do nome do atributo, como i.ID, i.Name, i.Quantity e i.Price.

package models

import "fmt"

type Item struct {
    ID       int
    Name     string
    Quantity int
    Price    float64
}

func (i Item) Info() string {
    return fmt.Sprintf("ID %d | Name: %s | Quantidade: %d | Price: %.2f", i.ID, i.Name, i.Quantity, i.Price)
}

Observação: essa estrutura será comum com métodos e funções em Go, semelhante a outras linguagens de programação. Entenderemos mais sobre métodos ao longo do curso.

Conclusão

Nosso próximo desafio será criar um item e reutilizar essa função no código do arquivo main.go!

Métodos e funções em Go - Métodos e funções

Neste vídeo, vamos criar o primeiro item da nossa aplicação.

Métodos e funções

Começaremos acessando o arquivo main.go, localizado na pasta "cmd". No escopo da função main(), criaremos um item para o nosso sistema de estoque.

Criando o item item1

Primeiramente, vamos chamá-lo de item1, seguido de := para definir que virá de models.Item. Entre chaves, podemos definir os campos do item. Ele possui um ID, que será 1, pois criamos o primeiro item. Além disso, o item terá um Name, que será "Primeiro Produto". Na sequência, adicionaremos uma Quantity, que será 10. Por fim, teremos um Price, que será 19.99.

main.go:

package main

import (
    "estoque/internal/models"
    "fmt"
)

func main() {
    fmt.Println("Sistema de Estoque")

    item1 := models.Item{
        ID:       1,
        Name:     "Primeiro Produto",
        Quantity: 10,
        Price:    19.99,
    }
}

Utilizando o item item1

Após salvar, o sistema informa que declaramos o item, mas ainda não o utilizamos. Para utilizá-lo e visualizá-lo no terminal, usamos fmt.Println() recebendo item1.

// código omitido

func main() {
    fmt.Println("Sistema de Estoque")

    item1 := models.Item{
        ID:       1,
        Name:     "Primeiro Produto",
        Quantity: 10,
        Price:    19.99,
    }
    
    fmt.Println(item1)
}

Executando o código

No terminal, podemos executar o código com o comando go run cmd/main.go. Como resultado, visualizamos o primeiro produto e todas as suas informações.

go run cmd/main.go

Retorno do comando:

Sistema de Estoque
{1 Primeiro Produto 10 19.99}

O problema é que as informações estão literais e não sabemos o que é o 1. Em item.go, há um método para a struct que retorna uma string formatada.

Visualizando o método Info()

Para visualizar o método Info(), podemos imprimir apenas item1.ID:

main.go:

// código omitido

func main() {
    fmt.Println("Sistema de Estoque")

    item1 := models.Item{
        ID:       1,
        Name:     "Primeiro Produto",
        Quantity: 10,
        Price:    19.99,
    }
    
    fmt.Println(item1.ID)
}

Ao executar no terminal novamente, é exibido o valor 1.

go run cmd/main.go

Retorno do comando:

Sistema de Estoque
1

Da mesma forma, podemos visualizar apenas item1.Name, e assim por diante. Ao selecionar apenas um, o sistema avisa quais campos não foram informados.

Utilizando o método Info()

Se quisermos a informação completa, há um método para isso: o Info(). O VS Code destaca o método de forma diferente. Quando executamos, temos o sistema de estoque com ID 1, Name: Primeiro Produto, Quantidade: 10 e Price: 19.99.

main.go:

// código omitido

func main() {
    fmt.Println("Sistema de Estoque")

    item1 := models.Item{
        ID:       1,
        Name:     "Primeiro Produto",
        Quantity: 10,
        Price:    19.99,
    }
    
    fmt.Println(item1.Info())
}

go run cmd/main.go

Retorno do comando:

Sistema de Estoque
ID 1 | Name: Primeiro Produto | Quantidade: 10 | Price: 19.99

Criando o item item2

Se tivermos outro produto, basta cadastrar o item2 com ID definido como 2, o Name definido como "Segundo Produto", e assim por diante. Além disso, vamos visualizar as informações do segundo produto utilizando fmt.Println() com item2 entre parênteses.

main.go:

// código omitido

func main() {
    fmt.Println("Sistema de Estoque")

    item1 := models.Item{
        ID:       1,
        Name:     "Primeiro Produto",
        Quantity: 10,
        Price:    19.99,
    }

    item2 := models.Item{
        ID:       2,
        Name:     "Segundo Produto",
        Quantity: 2,
        Price:    9.99,
    }
    fmt.Println(item1.Info())
    fmt.Println(item2.Info())
}

Executando novamente o comando no terminal, temos as informações do primeiro e segundo produtos, reutilizando o método criado para a struct de Item.

go run cmd/main.go

Retorno do comando:

Sistema de Estoque
ID 1 | Name: Primeiro Produto | Quantidade: 10 | Price: 19.99
ID 2 | Name: Segundo Produto | Quantidade: 2 | Price: 9.99

Importante! Ao falar sobre métodos em Go, precisamos lembrar do receptor. Diferente de outras linguagens de programação, não usamos self ou this, mas sim o receptor. A abreviação do receptor é curta, geralmente, a primeira letra do item, comum em projetos Go.

Método e função na linguagem Go

Uma diferença fundamental entre método e função em Go é que, ao tratar de métodos, devemos declará-los no pacote utilizado. Não podemos definir um método fora do pacote da struct. Já uma função pode ser declarada em qualquer lugar do projeto, fazendo parte do módulo em desenvolvimento. Assim, é importante seguir a nomenclatura idiomática da linguagem.

Da mesma forma, é essencial declarar funções no pacote correto.

Sobre o curso Go: crie Métodos, Generics e Interface

O curso Go: crie Métodos, Generics e Interface possui 98 minutos de vídeos, em um total de 51 atividades. Gostou? Conheça nossos outros cursos de GoLang em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Métodos e funções em Go
• Receiver de valor
• Métodos especiais
• Generics
• Interfaces