## Estruturas

- As estruturas Golang nos permitem agrupar dados.
- São semelhantes às estruturas de outras linguagens de programação.
- Estruturas são tipos de dados definidos pelo usuário e permitem criar seus próprios tipos personalizados.
- As estruturas podem conter qualquer tipo de dados, incluindo outras estruturas.

Definição da estrutura:

``` vá
tipo estrutura_nome estrutura {
nome_membro tipo1
nome_membro tipo2
...
nome_membro tipoN
}
```

- Isto define uma estrutura chamada `structure_name` com membros `member_name`. Cada membro possui um tipo, que pode ser qualquer tipo Go válido.

Criando estruturas:

``` vá
var nome_estrutura =tipo_estrutura {
nome_membro1:valor1,
nome_membro2:valor2,
...
nome_membroN:valorN
}
```
- Isso cria uma variável do tipo `nome_estrutura` e inicializa seus membros com os valores fornecidos.

Acessando membros:

- Para acessar um membro da estrutura, use o operador ponto:`nome_da_estrutura.nome_do_membro`.

Exemplo:
``` vá
// Define uma estrutura chamada pessoa com membros nome e idade.
digite pessoa estrutura {
Sequência de nome
Idade interna
}
função principal() {
// Crie uma pessoa chamada "John Doe".
pessoa1 :=pessoa{"John Doe", 30}

// Imprime o nome e a idade de John.
fmt.Println("Nome:", pessoa1.Nome)
fmt.Println("Idade:", pessoa1.Idade)
}
```

Estruturas nomeadas:
- Se uma estrutura contém campos de tipos de dados básicos, ela pode ser declarada sem uma palavra-chave struct.
``` vá
digite MyStruct estrutura {
não
b float32
string c
}

digite sua estrutura {
f int 'json:"primeiro"'
l string 'json:"último"'
}
```

- Para `MyStruct` e `your struct` acima, a palavra-chave struct é opcional

Estruturas anônimas

- Estruturas anônimas podem ser usadas para criar tipos de dados ad hoc sem definir explicitamente um tipo de estrutura.
- Quando uma estrutura anônima é usada como campo de outra estrutura ou como elemento de uma fatia/mapa, o tipo do campo é a estrutura anônima e a tag do campo é o nome do tipo.
``` vá
tipo Pessoa estrutura {
sequência de nome
idade interna
}
```

- Alternativamente, estruturas anônimas podem ser usadas para instanciar uma estrutura sem definir um tipo de struct.
``` vá
var pessoa =estrutura {
sequência de nome
idade interna
}{nome:"Bob", idade:20}
```
- Neste caso, a variável person do tipo `struct{ name string; age int }` é criado e inicializado.

Incorporando Estruturas

- Incorporar uma estrutura em outra estrutura permite uma forma de herança em Go.
``` vá
tipo Pessoa estrutura {
sequência de nome
idade interna
}
tipo Estrutura do funcionário {
salário interno
Pessoa
}
```

- Aqui `Employee` incorpora `Person` para que uma variável `Employee` inclua os campos de `Person` (nome e idade), bem como seus próprios campos.
``` vá
emp :=Funcionário{salário:100.000, Pessoa:Pessoa{nome:"John", idade:30}}
fmt.Println(emp.salário) // 100000
fmt.Println(emp.nome) // João
```

- Os campos da estrutura incorporada são promovidos para a estrutura externa (que contém) como se tivessem sido declarados na estrutura que contém. Aqui, os campos `nome` e `idade` de `Person` agora podem ser acessados ​​​​na variável `Employee` (`emp`).

Tags em estruturas

- Tags podem ser anexadas aos campos da estrutura para fornecer informações adicionais. Essas tags são usadas por reflexão e codificadores/decodificadores.
``` vá
tipo Pessoa estrutura {
string de nome `json:"nome"` // tag json
idade int `xml:"idade"` // tag xml
}
```

- As tags são colocadas entre crases (‘`’) se contiverem espaços ou outros caracteres especiais.

Conclusão

- As estruturas fornecem uma maneira de agrupar dados relacionados e criar seus tipos de dados personalizados em Go.
- Estruturas nomeadas e anônimas podem ser usadas dependendo da situação, e a incorporação permite uma forma de herança.
- Tags podem ser anexadas a campos de estrutura para metadados adicionais e compatibilidade com bibliotecas padrão.