Meus aprendizados em GO

00_instalation.md

Para instalar, execute:

$ sudo apt-get update && apt-get install golang

01_hello_word.md

Crie um arquivo do tipo .go para dar um Hello Word:

$ touch ola_go.go

No arquivo, adicione o código:

package main

import "fmt"

func main() {
    fmt.Printf("olá, mundo\n")
}

Considerações

• O import do fmt é um pacote para formatação de dados de saída;

• A função main é a espinha dorsal de um programa em go, é a partir dela que poderemos chamar outras funções, ou seja, o nome precisa ser esse.

Para executar esse código, execute o comando:

$ go run ola_go.go

02_comments.md

O godoc é usado para extrair comentários do código go para gerar documentação. Podemos documentar pacotes, variáveis e funções. Vale lembrar que para todos os casos o comentário deve finalizar com um ponto final.

Documentando pacotes

O comentário deve iniciar com o prefixo Package seguido pelo nome do pacote, descrição do que ele fornece e ponto final. Exemplo:

// Package weather provides tools to know about weather.
package weather

Documentando variáveis

O comentário deve iniciar com o nome da variável, seguido do que ela representa e ponto final.Exemplo:

// CurrentCondition represents a current condition.
var CurrentCondition string

Documentando funções

O comentário deve iniciar com o nome da função, seguido do que ela retorna (e não o que o código faz) e ponto final. Exemplo:

// Forecast returns a string value equal to current weather condition.
func Forecast(city, condition string) string {
  CurrentLocation, CurrentCondition = city, condition
  return CurrentLocation + " - current weather condition: " + CurrentCondition
}

03_numbers.md

No GO trabalha-se com tipos de número e se representa o tipo com o número de bits, como 32 ou 64, isso porque ele lida muito bem com gerenciamento de memória, o que torna a linguagem performatica.

Exemplos de tipos de números:

int representam números inteiros positivos e negativos. Se o número de bits forem 32, o range é de -2147483648 até 2147483647, e se for 64, o range será de -9223372036854775808 até 9223372036854775807

float64 representam números "quebrados", com ponto flutuante com o mesmo range descrito acima

uint representam número inteiros apenas positivos (incluindo o zero), com 4294967295 para 32 bits e 18446744073709551615 para 64 bits. Em ambos os casos o lado positivo do uint é o dobro do lado positivo do int, pois no primeiro caso não ocupase memoria com o lado negativo.

Conversao de inteiro para ponto flutuante

converted := float64(int_number)

04_boolean.md

Em GO, um booleano é representado pelo bool podendo ser true ou false

var closed bool    // ao declarar uma variável do tipo bool, implicitamente ela será false
speeding := true   // inicializa variável como true
hasError := false  // inicializa variável como false

Usando operadores

Negado

func CanFastAttack(knightIsAwake bool) bool {
  return !knightIsAwake
}

OU

func CanSpy(knightIsAwake, archerIsAwake, prisonerIsAwake bool) bool {
  return knightIsAwake || archerIsAwake || prisonerIsAwake
}

&&

func CanSignalPrisoner(archerIsAwake, prisonerIsAwake bool) bool {
  return prisonerIsAwake && !archerIsAwake
}

05_strings.md

Convertendo string para caixa alta/baixa

import "strings"

func ToUpperString(customString string) string {
    return strings.ToUpper(customString)   // para caixa baixa, substitua para ToLower
}

Repetição de strings

import "strings"

func RepeatString() string {
    return strings.Repeat("Go", 3)   // "GoGoGo"
}

Limpa carateres e espaços em branco de uma mensagem

// CleanupMessage cleans up an old marketing message.
func CleanupMessage(oldMsg string) string {    
    replaced := strings.ReplaceAll(oldMsg, "\n", "") // remove multiplas linhas 
    trimed := strings.Trim(replaced, "*") // remove asteristicos
    trimedLeft := strings.TrimLeft(trimed, " ") // remove espaço em branco da esquerda
    trimedRight := strings.TrimRight(trimedLeft, " ") // remove espaço em branco da direita

    newMsg := trimedRight
    
    return newMsg
}

06_functions.md

Funçoes publicas em GO sao declaradas com letra maiuscula e privadas com letra minuscula

package greeting

// Hello is a public function (callable from other packages).
func Hello(name string) string {
    return "Hello " + name
}

// hello is a private function (not callable from other packages).
func hello(name string) string {
    return "Hello " + name
}

07_structs.md

Uma struct é equivalente a uma classe em linguagem orientada a objetos.

Declarando uma struct:

type Car struct {
    price float64
    color string
}

No Go segue-se o principio de que funções, variáveis, etc com a letra maiuscula são publicas e funções, variáveis, etc com letra minuscula são privadas, ou seja, caso seja privada quer dizer que será acessivel apenas ao pacote onde está sendo declarado e usado, mas caso for publica, será disponível em outros pacotes caso o pacote que está sendo declarado for importado

Atualizado e acessando valores de uma struct:

// Update the price and the color
s.price = 1000.0
s.color = "red"
fmt.Printf("Preço: %f Cor: %s\n", s.price, s.color)
// Output: Preço: 1000,00 Cor: red

08_random.md

Trabalhando com números randomicos

import "math/rand"

// getRange returns a random int d with 1 <= d <= 20.
func getRange() int {
  return rand.Intn(20) + 1
}

// getFloatRange returns a random float64 f with 0.0 <= f < maxFloat.
func getFloatRange(maxFloat float64) float64 {
  return rand.Float64() * maxFloat
}

getFloatRange(12.0)

// ShuffleAnimals returns a slice with all eight animal strings in random order. 
// (retorna um slice de string de forma aleatória)
func ShuffleAnimals() []string {
  x := []string{"ant", "beaver", "cat", "dog", "elephant", "fox", "giraffe", "hedgehog"}

  rand.Shuffle(len(x), func(i, j int) {
    x[i], x[j] = x[j], x[i]
  })

  return x
}