# Goroutines

Vamos continuar a nossa jornada com as goroutines. Quero fazer mais um exemplo aqui.

package main

import (
	"fmt"
	"time"
)

func task(name string, n int) {

	for i := 0; i < n; i++ {
		fmt.Printf("Task: %s, i:%d/%d\n", name, i, n)
		time.Sleep(500 * time.Millisecond)

	}
}

func main() {

	go task("1", 5)
	go task("2", 7)

	time.Sleep(10 * time.Second)

}

Veja a saída desse programa:

Task: 2, i:0/7
Task: 1, i:0/5
Task: 1, i:1/5
Task: 2, i:1/7
Task: 2, i:2/7
Task: 1, i:2/5
Task: 1, i:3/5
Task: 2, i:3/7
Task: 2, i:4/7
Task: 1, i:4/5
Task: 2, i:5/7
Task: 2, i:6/7

Talvez esse exemplo seja mais elucidativo do que o anterior. Nele podemos ver claramente as duas goroutines rodando. O mais legal disso tudo foi a simplicidade de criar uma goroutine. No python, por exemplo, você teria que usar o threading ou multiprocessing para fazer isso. Perceba que o time.Sleep(10 * time.Second) é só um recursso técnico não convencional gambiarra. Uma das formas de resolver isso é um WaitGroup.

# Concorrência

A concorrência é um dos pilares do desenvolvimento moderno, permitindo que programas executem múltiplas tarefas simultaneamente para melhor aproveitamento dos recursos computacionais. Em sistemas tradicionais, a concorrência é frequentemente implementada usando threads gerenciadas pelo sistema operacional, o que pode introduzir sobrecarga significativa devido à necessidade de alternância de contexto (context switching) e sincronização complexa.

Go foi projetado com a concorrência em mente, oferecendo uma abordagem mais eficiente e acessível por meio das goroutines. Essas unidades leves de execução permitem a construção de programas altamente concorrentes sem os custos elevados das threads convencionais. O runtime do Go gerencia automaticamente o escalonamento das goroutines, otimizando o uso do processador e simplificando o desenvolvimento de aplicações escaláveis e performáticas.

# Requests para APIs Externas - Parte 3

Go possui um forte compromisso com a biblioteca padrão. Isso significa que a maioria das funcionalidades que você precisa já estão disponíveis na biblioteca padrão. Porém, em alguns casos, você pode precisar de uma biblioteca externa. Vamos implantar o mesmo código usando a biblioteca [github.com/go-resty/resty/v3](https://github.com/go-resty/resty), que é uma biblioteca de cliente HTTP muito popular e fácil de usar.

package main

import (
	"fmt"
	"net/http"

	"github.com/go-resty/resty/v2"
)

func main() {
	client := resty.New()

	// Faz a requisição GET
	resp, err := client.R().
		Get("https://the-one-api.dev/v2/book")
	if err != nil {
		fmt.Println("Erro ao fazer request:", err)
		return
	}
	defer resp.RawResponse.Body.Close()

	// Verifica o status da resposta
	if resp.StatusCode() != http.StatusOK {
		fmt.Println("Erro na resposta:", resp.Status())
		return
	}

	// Imprime o corpo da resposta
	fmt.Println("Resposta:", string(resp.Body()))
}

A biblioteca resty facilita a criação de requisições HTTP. No exemplo acima, usamos o método R() para criar uma nova requisição e o método Get() para fazer a requisição GET. A resposta é retornada como um objeto Response, que possui métodos para acessar o corpo da resposta, o status da resposta e outros detalhes. Vou adicionar um exemplo adicionar um bearer token no cabeçalho da requisição. A única coisa que temos que fazer é adicionar o método SetAuthToken na requisição.

# Requests para APIs Externas - Parte 2

Agora que já sabemos como fazer um request básico, vamos incrementar um pouco. Adiciar a API Key, fazer um request para uma rota que precisa de autenticação. Vamos fazer um request para a rota /movie da API do Senhor dos Anéis, que precisa de autenticação. Para isso, precisamos passar a chave de API no cabeçalho da requisição.

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	url := "https://the-one-api.dev/v2/movie"

	// Cria a request manualmente
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		fmt.Println("Erro ao criar request:", err)
		return
	}

	// Adiciona o header Authorization
	req.Header.Add("Authorization", "Bearer your-api-key-123")

	// Faz a requisição usando o client padrão
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		fmt.Println("Erro ao fazer request:", err)
		return
	}
	defer resp.Body.Close()

	// Lê a resposta
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Erro ao ler resposta:", err)
		return
	}


	fmt.Println("Resposta:", string(body))
}

A diferença nesse código é que criamos a requisição manualmente com o método http.NewRequest, onde passamos o método HTTP, a URL e o corpo da requisição (que no caso é nil). Depois, adicionamos o cabeçalho de autenticação com o método Header.Add. Por fim, fazemos a requisição com o método http.DefaultClient.Do, que retorna a resposta. Nesse caso o request vai falhar, pois não temos a chave de API. O último print vai imprimir o erro da requisição.

# Requests para APIs Externas - Parte 1

Vou tentar fazer alguma coisa mais prática, nesses últimos dias, foquei no estudo da base da linguagem, entender sintaxe, como as coisas funcionam, mas agora quero fazer algo mais prático. Vamos fazer uma aplicação que consome uma API externa, para isso, vamos usar a API do Senhor dos Anéis, que é uma API gratuita e fácil de usar. Para usar alguns endpoints, precisamos de uma chave de API, mas alguns endpoints não precisam. Para conseguir a chave, basta se cadastrar no site e gerar uma chave.

# 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: