Golang - Guia básico

Modulo: Coleção de pacotes
  - Pacote:
    - file.go
  - Pacote:
    - file.go
    - file.go

moduleFolder:
  cmd:
    - api:
      - main.go
    - cli:
      - main.go
    - client:
      - main.go
    - scripts:
      - main.go
  otherPackages:
    - something.go

package main

import "fmt"

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

const myConst // imutável ou constante
var myVar  // mutável porém de tipagem forte e estática

myVar = "some value" // tipo inferido (string)
myVar = 10 // erro, não podemos sobrescrever o tipo

var intNum int
anotherInt := 0 // inferência do tipo pelo operador ":="

var some, other = 1, 2
look, again := 3, 4 // look = 3, again = 4

Boolean:
  Default: false
  - bool: true ou false
Ponto Flutuante:
  Default: 0.0
  - float32: 32 bits = -3.4e+38 to 3.4e+38
  - float64: 64 bits = -1.7e+308 to +1.7e+308
Carácter:
  Default: 0
  - byte: alias for uint8
  - rune: alias for int32
Texto:
  Default: ''
  - string: coleção de bytes UTF-8
Inteiro:
  Default: 0
  - int: tamanho depende da arquitetura do sistema 32 ou 64 bits
  - int8: min -128 | max = -127
  - int16: min = -32768 | max = -32767
  - int32: min = -2147483648 | max = -2147483647
  - int64: min = -9223372036854775808 | max = -9223372036854775807
  - uint: 'u' vem de unassigned (sem atribuição de sinal)
  - uint8: min = 0 | max = -255
  - uint16: min = 0 | max = -65535
  - uint32: min = 0 | max = -4294967295
  - uint64: min = 0 | max = -18446744073709551615

// Quebrando linhas com \n
var simpleString string = "Hello \nworld!"
// Ou com string templates
var stringBlock string = `Hello
world!`

// Ambos com o mesmo resultado
fmt.Println(simpleString)
fmt.Println(stringBlock)

// Aqui a coisa começa a ficar estranha
fmt.Println(len("atenção")) // 9 | número de bytes em ASCII 256
fmt.Println(len("atencao")) // 7 | parece estar certo, mas não funciona sempre

// A forma mais assertiva é utilizando o pacote "unicode/utf8"
fmt.Println(utf8.RuneCountInString("atenção")) // resultado correto sempre

// Outro exemplo
var myString = "atenção"

// Ao buscar o 'a' teremos o valor correto dele na tabela ascii
var stringIndex uint8 = myString[0]
fmt.Println(stringIndex) // 97

// Ao buscar o 'ç' teremos o valor do primeiro byte
// porém como 'ç' precisa de mais de um byte, o valor correto seria 231
var stringIndex4 uint8 = myString[4]
fmt.Println(stringIndex4) // 167
for i, v := range myString {
  fmt.Println(i, v)
}
/*
  0 97
  1 116
  2 101
  3 110
  4 231 <- 'ç' | ocupa o espaço do 4 e do 5
  6 227 <- 'ã' | ocupa o 6 e o 7
  8 111 <- 'o' | ocupa um espaço só
*/

var myRune rune = 'a'
fmt.Println(myRune) // 97 | int32 ele imprime o valor numérico

// Manipulando Strings
var strSlice = []string{"H", "e", "l", "l", "o"}
var concatStr = ""
for i := range strSlice {
  // podemos fazer uma concatenação básica
  // a cada iteração uma nova string será gerada
  concatStr += strSlice[i]
}

var strBuilder strings.Builder
for i := range strSlice {
  // ou usando um string builder, melhor alternativa
  strBuilder.WriteString(strSlice[i])
}
fmt.Println(strBuilder.String())

// cast é necessário para fazer os cálculo
var numFloat32 float32 = 10.1
var numInt32 int32 = 2
var result float32 = numFloat32 + float32(numInt32)
fmt.Println(result)

var numInt1 int = 3
var numInt2 int = 2
fmt.Println(numInt1 / numInt2) // 1 | arredondamento para int
fmt.Println(numInt1 % numInt2) // 1 | operação com resto de divisão

var myBoolean bool = false // como qualquer linguagem, simples

// if, switch, for, não tem parêntesis
value := "something"

if value == "Hi" {
  fmt.Println("It's hi")

  // else if e else, tem que estar na mesma linha das chaves
} else if value != "something" {
  fmt.Println("it's not something")

} else {
  fmt.Println("it's " + value)
}

// no switch, o break é implícito sobre cada condição
switch {
case value == "Hi":
  fmt.Println("It's hi")

case value != "something":
  fmt.Println("it's not something")

default:
  fmt.Println("it's " + value)
}

// ele também pode ser condicional, atribuindo uma variável diretamente
switch value {
case "Hi":
  fmt.Println("It's hi")

// podendo validar mais de um valor para cada cenário
case "another thing", "anything":
  fmt.Println("it's not something")

default:
  fmt.Println("it's " + value)
}

// Loop básico 'while'
var i int = 0
for i<10 {
  fmt.Println(i)
  i += 1
}

// Loop sem condição
i=0 // reset
for {
  // removendo esse if interno, loop infinito
  if i>=10{
    break
  }
  fmt.Println(i)
  i += 1
}

// for clássico
for i=0; i<10; i++ {
  fmt.Println(i)
  i += 1
}

// for range (ou foreach in range)
intSlice := []int32{1, 2, 3}
for index, value := range intSlice {
  fmt.Println("Index: " + index + " Value: " + value)
}

// podemos ignorar o índice também
for _, value := range intSlice {
  fmt.Println("Index: " + index + " Value: " + value)
}

// Forma comum vista em outras linguagens
func functionName(param1 string, param2 int) string {
  return "result"
}

// retornando mais de um resultado
func multipleReturns(param1 string, param2 int) (string, int) {
  return "result", 10
}

// ao chamar a função devemos receber os dois dados
var first, second = multipleReturns("something", 1)

func namedReturn(param1 int, param2 int) (sum int) {
  // sum foi declarado na assinatura do método
  sum = param1 + param2
  return // o retorno vai ser sempre sum
}

import "errors" // pacote de error da biblioteca padrão
// golang não tem try-catch
// então todos os erros são tratados no retorno da função
func withError(wrong bool) bool, error {
  var err error // default: nil
  if wrong {
    err = errors.New("Something went wrong")
  }
  return err, wrong
}
// devemos receber este erro e verificar se ele tem algo
err, response := withError(true)
// forma padrão de lidar com erros
if err!=nil {
  fmt.Printf(err.Error())
}

// ou podemos ignorar este erro explicitamente usando '_'
// por padrão devemos retornar primeiro o erro
// para que ele não seja ignorado acidentalmente
_, response2 := withError(false)

// funções também podem ser atribuídas a objetos
func (b ball) roll() {
  b.position++
}
// assim quando declaramos uma nova bola
newBall := ball.New()
// temos o método novo acessivel a ele
// este design permite estender estruturas de bibliotecas externas
// ou até mesmo da biblioteca padrão
// podemos atribuir métodos novos para o tipo string por exemplo
newBall.roll()

var intArr[3]int32
intArr[1] = 123 // atribuindo no index
fmt.Println(intArr[0]) // imprimindo posição 0
fmt.Println(intArr[1:3]) // imprimindo de 1 até 2 (intervalo aberto no 3)

fmt.Println(&intArr[0]) // imprimindo o endereço de memória
fmt.Println(&intArr[1]) // assim temos como ver que eles ficam
fmt.Println(&intArr[2]) // um do lado do outro

// poderíamos ter inicializado o array assim também
anotherIntArr := [3]int32{3, 2, 1}
fmt.Println(anotherIntArr[0:3])

// se omitir o tamanho, temos um slice de tamanho dinâmico
intSlice := []int32{1, 2, 3}

// tamanho do slice, é a quantidade de items, capacidade, é a memória alocada
fmt.Printf("O tamanho do array interno é %v porém a capacidade é %v = ", len(intSlice), cap(intSlice)) // 3 & 3
fmt.Println(intSlice)

// podemos adicionar valores extras
intSlice = append(intSlice, 7)
// ao exceder a capacidade do array original, a capacidade é DOBRADA
// porém não podemos acessar estes valores que estão fora do array
fmt.Printf("O tamanho do array é %v porém a capacidade é %v = ", len(intSlice), cap(intSlice)) // 4 & 6
fmt.Println(intSlice)

// poderíamos criar um novo array especificando tamanho e capacidade
// make é uma função 'fábrica' para os tipos básicos
// int[] é o tipo, 3 o tamanho, 8 a capacidade
var intSlice2 []int32 = make([]int32, 3, 8)

// podemos inserir os dados no FIM de outro array via função append com o operador spread (...)
intSlice2[0] = 10
intSlice2 = append(intSlice, intSlice2...) // [10, 0, 0, 1, 2, 3, 7]
fmt.Println(intSlice2)

// iterando...
for index, value := range intSlice2 {
  fmt.Println("Index: " + index + " Value: " + value)
}

// podemos criar um mapa desta forma
var myMap map[string]uint8 = make(map[string]uint8)
fmt.Println(myMap)

// ou diretamente atribuindo valores
MyMap2 := map[string]uint8}{"James":5 "Tiberius":8 "Kirk":4 }
fmt.Println(myMap2["James"]) // 7

// nesse caso, ele retorna o valor padrão do tipo, nesse caso do uint8 é 0
fmt.Println(myMap2["Spock"])
// podemos deletar um valor usando a função delete
delete(myMap2, "Tiberius")

// para saber se o valor estava no mapa ou ele era realmente 0
// temos um segundo no mapa
var nameLen, found = myMap2["Spock"] // 0 & false
if  found {
  fmt.Println("The name length is " + nameLen)
}

// iterando...
for key, value := range myMap2 {
  fmt.Println("Name: " + key + " Name length: " + value)
}

// structs podem ser declaradas de forma anonima
// porém assim não podem ser reutilizadas
var person = struct{
  name string
  age uint8
}{"Spock", 83}

// desta forma podemos reutilizar esta interface
type person struct{
  name string
  age uint8
}

type owner struct {
  name string
}

type gasCar struct {
  kml     uint8
  tankCap uint8
  owner   // caso tipo e variável tenham o mesmo nome, podemos omitir
}

// desta forma atribuímos uma função para a struct gasEngine
func (e gasCar) kmLeft() uint {
  return uint(e.tankCap) * uint(e.kml)
}

type electricCar struct {
  kpkwh      uint8
  batteryCap uint8
  owner      owner // podemos por ambos sem problemas também
}

// desta forma atribuímos uma função para a struct gasEngine
func (e electricCar) kmLeft() uint {
  return uint(e.batteryCap) * uint(e.kpkwh)
}

// ao declarar a interface, tanto o carro a gasolina quanto o elétrico
// poderão satisfazer este requisito e serem considerados somente carros
type car interface {
  kmLeft() uint
}

func willReachDestination(c car, distance uint) bool {
  return c.kmLeft() >= distance
}

func main() {
  // uma struct pode ser inicializada desta forma
  var myCar gasCar = gasCar{kml: 15, tankCap: 40, owner: owner{"Someone"}}
  // e ser alterada desta forma (pegando estrada né)
  myCar.kml = 20
  fmt.Println(myCar.kmLeft())

  // nomes de variáveis podem ser omitidos, enviando os parâmetros em ordem
  var myOtherCar electricCar = electricCar{4, 100, owner{"Someone"}}
  fmt.Println(myOtherCar.kmLeft())

  // ao usar a função podemos utilizar ambos os carros
  // pois ambos satisfazem os requisitos da interface
  var distance uint = 500
  fmt.Println("Gas Car: ", willReachDestination(myCar, distance))
  fmt.Println("Electric car: ", willReachDestination(myOtherCar, distance))
}

var x int32 = 10
// ao inicializar um ponteiro desta forma, estamos criando um novo valor na memória
// neste caso 0 (default do int32) e armazenando uma referencia para ele em 'a'
var a *int32 = new(int32)

// com o '*' antes do ponteiro, estamos de-referenciando
// indo até o espaço de memória que é apontado
fmt.Printf("'a' point to the value: %v \n", *a)
fmt.Printf("'x' value is: %v \n", x)

// caso queira atualizar o valor de 'a' use '*'
// caso contrário, estará atualizando o endereço de memória
*a = 5

var y int32 = 70
// '&' é usado para capturar o endereço de memória de uma variável
// neste caso, estamos referenciando a variável 'y'
var b *int32 = &y
fmt.Printf("'b' point to the value: %v \n", *b)
fmt.Printf("'y' value is: %v \n", y)

// agora como 'b' e 'y' apontam para o mesmo local na memória
// qualquer mudança em no valor de um deles, causa um efeito no outro
*b = 80
fmt.Println("updating by reference...")
fmt.Printf("'b' point to the value: %v \n", *b)
fmt.Printf("'y' value is: %v \n", y)

//e se nao fosse um ponteiro?
c := 2
d := c
fmt.Printf("'c' value is: %v \n", c)
fmt.Printf("'d' value is: %v \n", d)

d = 5
fmt.Println("updating by value...")
fmt.Printf("'c' value is: %v \n", c)
fmt.Printf("'d' value is: %v \n", d)

var slice = []int32{1, 2, 3}
var sliceCopy = slice
// ao atualizar um, atualizamos o outro
sliceCopy[2] = 4
fmt.Println(slice)
fmt.Println(sliceCopy)

func square(thing2 [5]int32) [5]int32 {
 fmt.Printf("Memory location of thing2: %p \n", &thing2)
 for i := range thing2 {
  thing2[i] = thing2[i] * thing2[i]
 }
 return thing2
}

func squareRef(thing3 *[5]int32) [5]int32 {
 // aqui nao precisa do '&' esta variável já é um ponteiro
 // usando '&' o resultado será o endereço do ponteiro (ponteiro do ponteiro)
 fmt.Printf("Memory location of thing3: %p \n", thing3)
 for i := range thing3 {
  thing3[i] = thing3[i] * thing3[i]
 }
 return *thing3
}

var thing1 = [5]int32{1, 2, 3, 4, 5}
fmt.Printf("Memory location of thing1: %p \n", &thing1)

var resultSquare [5]int32 = square(thing1)
fmt.Printf("Result value: %v \n", resultSquare)
fmt.Printf("thing1 value: %v \n", thing1)

var resultSquareRef [5]int32 = squareRef(&thing1)
fmt.Printf("Result ref value: %v \n", resultSquareRef)
fmt.Printf("thing1 new value: %v \n", thing1)

\*
Memory location of thing1: 0xc0000200c0
Memory location of thing2: 0xc0000200d8
Result value: [1 4 9 16 25]
thing1 value: [1 2 3 4 5]

Memory location of thing3: 0xc0000200c0
Result ref value: [1 4 9 16 25]
thing1 new value: [1 4 9 16 25]
*\

var wg = sync.WaitGroup{}
var dbData = []string{"ID[1]", "ID[2]", "ID[3]", "ID[4]", "ID[5]"}

func main() {
 t0 := time.Now()
 for i := 0; i < len(dbData); i++ {
  // adiciona 1 ao contador
  wg.Add(1)
  go dbCall(i)
 }
 wg.Wait()
 fmt.Printf("Total execution time: %v \n", time.Since(t0))
}

// simulando delay da chamada ao banco
func dbCall(i int) {
 var delay float32 = rand.Float32() * 2000
 time.Sleep(time.Duration(delay) * time.Millisecond)
 fmt.Println("Result from DB:", dbData[i])
 // remove 1 do contador
 wg.Done()
}

var m = sync.Mutex{}
var wg = sync.WaitGroup{}
var dbData = []string{"ID[1]", "ID[2]", "ID[3]", "ID[4]", "ID[5]"}
var results = []string{}

func main() {
 t0 := time.Now()
 for i := 0; i < len(dbData); i++ {
  // adiciona 1 ao contador
  wg.Add(1)
  go dbCall(i)
 }
 wg.Wait()
 fmt.Printf("Total execution time: %v \n", time.Since(t0))
 fmt.Printf("The results are: %v \n", results)
}

// simulando delay da chamada ao banco
func dbCall(i int) {
 // fixando o tempo para forçar cenários concorrentes
 var delay float32 = 2000
 time.Sleep(time.Duration(delay) * time.Millisecond)
 fmt.Println("Result from DB:", dbData[i])
 save(dbData[i])
 // remove 1 do contador
 wg.Done()
}

func save(result string) {
 // bloqueando a escrita para evitar condição de corrida
 m.Lock()
 results = append(results, result)
 // liberando o acesso para outras Goroutines
 m.Unlock()
}

var m = sync.RWMutex{}
var wg = sync.WaitGroup{}
var dbData = []string{"ID[1]", "ID[2]", "ID[3]", "ID[4]", "ID[5]"}
var results = []string{}

func main() {
 t0 := time.Now()
 for i := 0; i < len(dbData); i++ {
  // adiciona 1 ao contador
  wg.Add(1)
  go dbCall(i)
 }
 wg.Wait()
 fmt.Printf("Total execution time: %v \n", time.Since(t0))
}

// simulate DB call delay
func dbCall(i int) {
 // fixando o tempo para forçar cenários concorrentes
 var delay float32 = 2000
 time.Sleep(time.Duration(delay) * time.Millisecond)
 save(dbData[i])
 log()
 // remove 1 do contador
 wg.Done()
}

func save(result string) {
 // bloqueando a escrita para evitar condição de corrida
 m.Lock()
 results = append(results, result)
 // liberando o acesso para outras Goroutines
 m.Unlock()
}

func log() {
 // bloqueia somente a leitura
 m.RLock()
 fmt.Printf("Current results: %v \n", results)
 // desbloqueia a leitura
 m.RUnlock()
}

// Declarando um channel de tamanho 1
var ch1 = make(chan int)
// adicionando o valor 1 no channel ch1=[1]
// Exatamente aqui, teremos um lock
ch1 <- 1
// removendo o primeiro valor do channel e armazenando na variável
var i = <-ch1
// criando um channel com um valor inicial pré determinado
var ch2 = make(chan int, 10)
ch2 <- i
// ERRO
fmt.Println("Valor processado:", <-ch2)

func main() {
 var c = make(chan int)
 go process(c)
 fmt.Println("Valor processado:", <-c)
}

func process(c chan int) {
 c <- 1
}

func main() {
  // Inicializando o chan com 5 irá liberar espaço para a execução toda neste caso
  // teste removendo o 5 e veja o que muda
 var c = make(chan int, 5)
 go process(c)
 for i := range c {
  fmt.Println("Valor processado:", i)
 }
 fmt.Println("Fim do processamento")
}

func process(c chan int) {
  // defer??? é uma palavra reservada
  // uma expressão que será executada no momento antes da função terminar
 defer close(c)
 for i := 0; i < 5; i++ {
  c <- i
 }
}

func main() {
 oddChan := make(chan int)
 pairChan := make(chan int)
 numbers := []int{1, 3, 6, 8, 9, 10}

 for i := range numbers {
  go processNumber(numbers[i], oddChan, pairChan)
 }
 for range numbers {
  results(oddChan, pairChan)
 }

}

func results(oddChan chan int, pairChan chan int) {
 select {
 case value := <-oddChan:
  fmt.Println("Valor ímpar encontrado:", value)
 case value := <-pairChan:
  fmt.Println("Valor Par encontrado:", value)
 }
}

func processNumber(number int, oddChan chan int, pairChan chan int) {
 if number%2 > 0 {
  oddChan <- number
 } else {
  pairChan <- number
 }
}

func main() {
 intSlice := []int{1, 3, 6, 8, 9, 10}
 intSum := processNumbers(intSlice)
 fmt.Println("Sum of Integers:", intSum)

 floatSlice := []float32{1.2, 3.1, 6.4, 8.3, 9.2, 10.8}
 floatSum := processNumbers(floatSlice)
 fmt.Println("Sum of Floats:", floatSum)
}

// Aqui definimos que o tipo T pode ser [int | float32 | float64]
// podemos utilizar o any também assim como outras linguagens como Typescript
// outro detalhe any nada mais é do que um alias para uma interface vazia :P
func processNumbers[T int | float32 | float64](slice []T) T {
  sum:= 0
 for _, v := range slice {
  sum += v
 }
 return sum
}

type electricCar struct {
 kpkwh      uint8
 batteryCap uint8
}

func (e electricCar) kmLeft() uint {
 return uint(e.batteryCap) * uint(e.kpkwh)
}

type car[T gasCar | electricCar] struct {
 owner
 engine T
}

type engine interface {
 kmLeft() uint
}

func willReachDestination(e engine, distance uint) bool {
 return e.kmLeft() >= distance
}

func main() {
 // uma struct pode ser inicializada desta forma
 var myCar car[gasCar] = car[gasCar]{owner: owner{"Someone"}, engine: gasCar{kml: 15, tankCap: 40}}
 // e ser alterada desta forma
 myCar.engine.kml = 20
 fmt.Println(myCar.engine.kmLeft())

 // nomes de variáveis podem ser omitidos, enviando os parâmetros em ordem
 var myOtherCar car[electricCar] = car[electricCar]{owner{"Someone"}, electricCar{4, 100}}
 fmt.Println(myOtherCar.engine.kmLeft())

 // ao usar a função podemos utilizar ambos os carros
 // pois ambos satisfazem os requisitos da interface
 var distance uint = 500
 fmt.Println("Gas Car: ", willReachDestination(myCar.engine, distance))
 fmt.Println("Electric car: ", willReachDestination(myOtherCar.engine, distance))
}