lessons

Documentation

Index

• func ArraysAndSlices()
• func AtomicAndMutexRaceCondition()
• func Channels()
• func ContextAndGoRoutines()
• func Errors()
• func Generics()
• func GoRoutines()
• func GoRoutinesWithSyncWaitGroup()
• func GoTools()
• func ImplementInterfaceSorting()
• func InterfaceAndAssertions()
• func Interfaces()
• func JsonParsing()
• func Logs()
• func Maps()
• func Pointers()
• func ReadersAndWriters()
• func Sqrt(n float64) (float64, error)
• func StructsAndMethods()
• type Animal
• type Book
• type BookByRate
  • func (f BookByRate) Len() int
  • func (f BookByRate) Less(i, j int) bool
  • func (f BookByRate) Swap(i, j int)
• type Car
  • func (Car) Run() string
• type Cat
  • func (c *Cat) Speak() string
• type CustomErrorWithStruct
  • func (e CustomErrorWithStruct) Error() string
• type Developer
• type Dog
  • func (Dog) Speak() string
• type Example
• type Fruit
• type MultipleConstraits
• type MultipleConstraitsWithCoreType
• type MyConstraint
• type MyString
  • func (MyString) SayHello()
• type MyType
  • func (MyType) Foo()
• type MyTypeString
• type Person
  • func (p Person) GetIDWithPrefix() string
  • func (p *Person) SetName(name string)
• type Someone
  • func (Someone) Run() string
• type SomeoneOrCarConstraint
• type SqrtError
  • func (e SqrtError) Error() string
• type User
  • func (u User) GetFullName() string
• type UserWithTags

Functions

func ArraysAndSlices

func ArraysAndSlices()

func AtomicAndMutexRaceCondition

func AtomicAndMutexRaceCondition()

func Channels

func Channels()

func ContextAndGoRoutines

func ContextAndGoRoutines()

func Errors

func Errors()

func Generics

func Generics()

func GoRoutines

func GoRoutines()

func GoRoutinesWithSyncWaitGroup

func GoRoutinesWithSyncWaitGroup()

func GoTools

func GoTools()

func ImplementInterfaceSorting

func ImplementInterfaceSorting()

func InterfaceAndAssertions

func InterfaceAndAssertions()

func Interfaces

func Interfaces()

func JsonParsing

func JsonParsing()

func Logs

func Logs()

func Maps

func Maps()

func Pointers

func Pointers()

func ReadersAndWriters

func ReadersAndWriters()

func Sqrt

func Sqrt(n float64) (float64, error)

func StructsAndMethods

func StructsAndMethods()

Types

type Animal

type Animal interface {
	Speak() string
}

type Book

type Book struct {
	Name string
	Rate int
}

type BookByRate

type BookByRate []Book

func (BookByRate) Len

func (f BookByRate) Len() int

func (BookByRate) Less

func (f BookByRate) Less(i, j int) bool

func (BookByRate) Swap

func (f BookByRate) Swap(i, j int)

type Car

type Car struct {
	Name string
}

func (Car) Run

func (Car) Run() string

type Cat

type Cat struct {
	Name string
}

• Caso uma variavel instancie uma struct com metodo com receiver por ponteiro que implementa uma interface, e chame um método da interface, o método da struct será chamado mesmo a variavel sendo nil. Isso acontece porque o Go chama o método diretamente da struct, e não da variavel. Só irá acontecer um panic se for chamado uma propriedade da struct que não foi inicializada.

func (*Cat) Speak

func (c *Cat) Speak() string

type CustomErrorWithStruct

type CustomErrorWithStruct struct {
	// contains filtered or unexported fields
}

func (CustomErrorWithStruct) Error

func (e CustomErrorWithStruct) Error() string

type Developer

type Developer struct {
	Person
	Language string
}

- Embbeded structs são structs que são usadas como campos de outras structs, bem semelhante a herança, mas os campos são de fato copiados para a struct que os contém.

type Dog

type Dog struct {
	Name string
}

func (Dog) Speak

func (Dog) Speak() string

• IMPORTANTE:
• Para Go, uma struct implementa uma interface se ela tiver todos os métodos da interface, independente se a interface é conhecida por quem implementa. Não existe palavra-chave `implements` em Go, então a implementação é sempre implícita.

type Example

type Example struct {
	Name string
	Temp float64
	List []string
}

type Fruit

type Fruit struct {
	Name   string `json:"name"`
	Color  string `json:"color"`
	Rate   int    `json:"rate"`
	IsGood bool   `json:"isGood"`
}

type MultipleConstraits

type MultipleConstraits interface {
	int | string
}

• Dentro dos generics, é possível utilizar multiplos constraints usando uma interface que possua os contraints desejados, nesse caso, os contraints ou tipos são separados por pipe (|) semelhante ao Typescript. Há duas formas de definir esses constraints multiplos: MyFunc[T interface { Foo | Bar }](): aceita a criação da interface inline MyFunc[T MyConstraint](): aceita uma interface já criada com as opções dentro -> MyConstraint interface { Foo | Bar }

type MultipleConstraitsWithCoreType

type MultipleConstraitsWithCoreType interface {
	// Se não for passado o `~` antes do tipo customizado, o compilador irá acusar erro
	// Pois nesse caso, o tipo `MyTypeStrin` não é um dos tipos definidos no constraint, mas internamento, lá no `core type` ele é uma string que é um dos tipos definidos no constraint
	int | ~string | constraints.Float
}

type MyConstraint

type MyConstraint interface {
	Foo()
}

• Há vários tipos de constraints que podem ser usados any: aceita qualquer tipo int, string, float64, etc: aceita apenas o tipo específico interface: aceita qualquer tipo que implemente a interface comparable: aceita qualquer tipo que possa ser comparado, ou seja, que implemente os métodos == e !=

type MyString

type MyString string

func (MyString) SayHello

func (MyString) SayHello()

• Para criar métodos é necessário usar um `receiver` que é um parâmetro especial que é passado para o método. É declarada como uma função normal, mas com um parâmetro antes do nome da função. Exemplo: func (<Struct>) <func_name>() {}

• O receiver pode ser um ponteiro ou um valor. Com ele é possível acessar os campos da struct. Quando a struct é passada como valor, uma cópia é feita e qualquer alteração não será refletida no original. Quando a struct é passada como ponteiro, a referência é passada e qualquer alteração será refletida no original. Quando não é necessário usar o valor da struct, pode omitir a variavel do receiver, passando apenas o tipo.

  Por convenção, o nome do receiver é a primeira letra do tipo da struct em minúsculo. Por convenção, quando um método altera o estado da struct, o receiver deve ser um ponteiro. Por consequência, todos os métodos da struct devem ser ponteiros.

  Não é possível adicionar metodos de structs fora do pacote que a struct foi definida.

type MyType

type MyType struct{}

Agora a função fooWithMyConstraint aceita o MyType porque ele implementa a interface MyConstraint

func (MyType) Foo

func (MyType) Foo()

type MyTypeString

type MyTypeString string

• Quando se tem multiplos constraints, o funcionamento é estrito, ou seja, o tipo passado como argumento deve ser um dos tipos definidos no constraint. Caso queira aceitar um tipo customizado mas que o `core type` dele esteja dentro das opções dos generics, é necessário usar o `~` antes do tipo informado

• inclusive, o Go tem um pacote com essas constraints que são usadas internamente, com o objetivo de facilitar a criação de generics com `core types` `golang.org/x/exp/constraints`

type Person

type Person struct {
	ID   uint64
	Name string
	Age  uint8
}

• Structs são tipos de dados que podem ser usados para agrupar diferentes tipos de dados. Uma struct é um tipo e pode ser criada com o `type` e `struct` keywords. Structs não são classes, mas são bem parecidas por terem propriedades e métodos.

func (Person) GetIDWithPrefix

func (p Person) GetIDWithPrefix() string

func (*Person) SetName

func (p *Person) SetName(name string)

A partir desse momento, eu precisaria alterar o metodo (p Person) para (p *Person) em todos os métodos da struct Person, inclusive os que não alteram o estado da struct.

type Someone

type Someone struct {
	Name string
}

func (Someone) Run

func (Someone) Run() string

type SomeoneOrCarConstraint

type SomeoneOrCarConstraint interface {
	Someone | Car
	Run() string
}

Uma maneira de driblar isso e pelo menos conseguir acessar os métodos, é passar uma constraint já construida com o método em comum nas structs

type SqrtError

type SqrtError struct{}

• Erros podem ser personalizados através da interface error Essa interface de Error tem apenas a função Error() string, então, qualquer struct que implemente essa função pode ser usada como um erro personalizado

func (SqrtError) Error

func (e SqrtError) Error() string

type User

type User struct {
	Name     string
	LastName string
}

• Erros previnem chamadas de ponteiros nulos Tratando esse tipo de erro antes de chamar métodos em ponteiros

func (User) GetFullName

func (u User) GetFullName() string

type UserWithTags

type UserWithTags struct {
	ID   uint64 `json:"id"`
	Name string `json:"name"`
	Age  uint8  `json:"age"`
}

• Struct Tags são strings que podem ser adicionadas aos campos de uma struct para fornecer metadados sobre o campo.
• Struct Tags são usadas para serializar e deserializar structs. Qualquer pacote que aceite structs serializadas e deserializadas pode usar essas tags. Inclusive é possível criar pacotes personalizados que aceitam essas tags. Exemplo: `json:"name"`, `xml:"name"`, `yaml:"name"`, `bson:"name"`, `db:"name"`, `validate:"name"`, etc.