# Generics

Seguindo com nosso exemplo do pacote utils, vamos analisar nossa função Soma

func Soma(a, b int) int {
    return a + b
}

Essa função Soma possui uma lógica muit simples, ele recebe dois inteiros e retorna um inteiro. Agora, imagine que queremos somar dois floats, teríamos que criar outra função SomaFloat que aceita dois floats e retorna um float.

func SomaFloat(a, b float64) float64 {
    return a + b
}

Essa função SomaFloat é praticamente igual a função Soma, a única diferença é que ela aceita dois floats e retorna um float. Aí agora tenho que fazer isso para todos os tipos de dados que eu quero somar e repetir para todas as operações matemáticas. Parece meio contra produtivo, não é mesmo? Antes da versão 1.18 do Go, resolveríaamos esse problema com interfaces, mas agora temos Generics! Veja como podemos resolver esse problema com Generics:

# Pacotes e Módulos

Temos várias funções e tipos em Go, mas é importante organizar essas funções e tipos em pacotes. Um pacote é um conjunto de arquivos Go no mesmo diretório que compartilham o mesmo package statement no topo do arquivo. O package statement é a primeira linha de um arquivo Go e define o nome do pacote. Por exemplo, o pacote fmt é um pacote padrão em Go que fornece funções para formatação de entrada e saída. Golang possui ínumeros pacotes que são padrão da linguagem. No site pkg.go.dev você pode encontrar todos os pacotes padrão da linguagem e os pacotes de terceiros, veja o exemplo do pacote Gin, que é um framework web para Go. Vamos criar um pacote utils com diversas funções.

# Ponteiros

Ponteiros são variáveis que armazenam endereços de memória de outras variáveis. Eles são um conceito fundamental na programação, permitindo a manipulação eficiente da memória e referências a valores. O Golang possui gerenciamento automático de memória, mas ainda oferece suporte explícito a ponteiros para maior controle. Veja este exemplo em Go:

var count int = 10
var ptrCount *int = &count

fmt.Println("Valor de count:", count)
fmt.Println("Endereço de count:", &count)
fmt.Println("Valor de ptrCount:", ptrCount)
fmt.Println("Valor apontado por ptrCount:", *ptrCount)

Valor de count: 10
Endereço de count: 0xc000104040
Valor de ptrCount: 0xc000104040
Valor apontado por ptrCount: 10

Veja a explicação deste código, linha por linha. Na primeira linha, temos uma variável count do tipo int que armazena o valor 10.

# Interfaces

Interfaces são um conceito muito presente em linguagens com orientação a objetos, de forma geral, as interfaces são um contrato que outras estruturas podem “assinar”, garantindo que elas implementem os métodos definidos na interface. Diferentemente de outras linguagens, como Java ou C#, Go adota um modelo de interface implícita, no qual qualquer tipo que implemente os métodos exigidos automaticamente satisfaz a interface.

type Animal interface {
    EmitirSom() string
}

Agora, vamos criar duas structs que implementam a interface Animal. Note que, em nenhum momento, precisamos declarar explicitamente que a struct implementa a interface.

# Structs

Só para revisar o que vimos no Dia 5 - Structs. Structs são tipos de dados compostos que são usados para agrupar diferentes tipos de dados. Eles são usados para criar tipos de dados personalizados. A sintaxe para criar um struct é a seguinte:

type linguagem_de_programacao struct {
	nome string
	ano  int
	criador []string	
}

var go = linguagem_de_programacao{
	nome: "Go",
	ano: 2009,
	criador: []string{"Robert Griesemer", "Rob Pike", "Ken Thompson"},
}

fmt.Println(go.nome) // Go
go.nome = "Golang"
fmt.Println(go.nome) // Golang

# Structs com métodos

Structs podem ter métodos associados a eles, como se fosse os métodos de uma classe em POO. Métodos são funções que pertencem a um tipo de dados específico. Veja a sintaxe para criar um método:

# Funções

Já vimos várias funções até agora, len, cap, append e outras. Vamos ver como criar nossas funções.

# Sintaxe da função

A sintaxe de uma função é a seguinte:

func nome_da_funcao(parametro1 tipo, parametro2 tipo) (retorno1 tipo, retorno2 tipo) {
	// Lógica da função
}

A função nome_da_funcao recebe dois parâmetros, parametro1 e parametro2, ambos do tipo tipo. A função retorna dois valores, retorno1 e retorno2, ambos do tipo tipo. Veja esse exemplo mais “real”:

# Prática

Vamos praticar os conceitos que aprendemos até agora, com alguns exercícios de LeetCode. As soluções desses problemas não são as ótimas, elas estão aqui mais com o intuito de praticar a sintaxe da linguagem Go e as estruturas.

# 9. Palindrome Number

Dado um número inteiro x, retornar true se x é um palíndromo inteiro. Link para o problema: LeetCode - 9

x := 121

// Converte o número para string
number_as_string := strconv.Itoa(x)

// Pegamos o tamanho da string
length := len(number_as_string)

// Fazemos um for para percorrer a string, mas somente até a metade
for i := 0; i < length/2; i++ {
    // Pegamos o caracter da posição i
    left := number_as_string[i]

    // Pegamos o caracter da posição length - i - 1
    // length - i - 1 é a posição do caracter oposto ao da posição i
    // Exemplo: se i for 0, então length - i - 1 será o último caracter
    // Lembre que o índice começa em 0, então o último caracter é length - 1
    right := number_as_string[length-i-1]

    // Se os caracteres forem diferentes, então não é um palíndromo
    if left != right {
        println("Não é um palíndromo")
    }
}

println("É um palíndromo")

Nesse código, a mensagem “É um palíndromo” sempre será impressa, pois o código não faz nada quando os caracteres são diferentes. No leetcode iremos retornar um valor booleano, ao invés de imprimir uma mensagem. O legal do LeetCode é que mostra o tempo de execução e o uso de memória da sua solução e compara com outras soluções.

# If, For, Switch e GoTo

Algumas estruturas são básicas em praticamente todas as linguagens, pois permitem o controle do fluxo de execução do código. No Go, não é diferente: if, for, switch e goto (sim, existe goto) são fundamentais para criar lógica condicional, laços de repetição e até saltos diretos dentro do código.

# If

O if é uma das estruturas fundamentais de controle de fluxo em Go, permitindo que o programa tome decisões com base em condições lógicas. Seu funcionamento é semelhante ao de outras linguagens, mas possui algumas particularidades que fazem parte do estilo idiomático do Go.

# Structs

Structs são tipos de dados compostos que permitem agrupar múltiplos campos de diferentes tipos em uma única estrutura. Elas são semelhantes às structs em C e C++, servindo como uma forma de criar objetos. Porém sem ser uma classe! Go não é uma linguagem orientada a objetos, mas podemos simular objetos com structs. Veja como definir uma struct:

type Person struct {
    Name string
    Age  int
}

Aqui temos uma struct chamada Person com dois campos: Name e Age. Para criar uma variável do tipo Person, fazemos da seguinte forma:

# Maps

Maps são hash tables. Eles são uma coleção de pares chave-valor. Para quem já programou em Python os maps são muito similares aos dicionários. Como a liguagem é tipada, temos que todas as chaves devem ser do mesmo tipo e todos os valores devem ser do mesmo tipo. Para definirmos um map, onde as chaves são do tipo string e os valores do tipo int, fazemos da seguinte forma: