Golang Struct

Para abreviar, uma estrutura ou estrutura é uma coleção de campos com tipos de dados definidos. As estruturas são muito úteis e melhoram a flexibilidade nos programas. As estruturas são provavelmente a sua melhor aposta se você tiver dados melhor representados como uma unidade. Pense nisso como uma versão leve da programação orientada a objetos.

GO permite que você crie e use estruturas usando tipos embutidos ou definidos pelo usuário.

Este guia fará uma viagem e explorará como as estruturas funcionam na linguagem de programação Go.

Declarando uma estrutura

A sintaxe abaixo mostra como criar a estrutura em Go:

typestruct_namestruct
campo_1 data_type
campo_2 data_type
..
field_ndata_type

Começamos chamando a palavra -chave do tipo. Em seguida vem o nome da estrutura. O nome da estrutura pode ser qualquer coisa definida pelo usuário (desde que siga as regras de nomeação em Go). Em seguida, usamos a palavra -chave da estrutura, seguida por um par de aparelhos encaracolados.

Dentro do aparelho, definimos vários campos que compõem a estrutura. O nome do campo é seguido por seu tipo de dados.

Declarar estrutura - exemplo

O código de exemplo abaixo define uma estrutura chamada funcionário. Ele contém 5 campos com vários tipos de dados.

struct typeemployee
String de nome
Idade int
Bool aposentado
String de departamento
Salário Float64

O acima cria uma estrutura de funcionários contendo campos de vários tipos.

Nota: Se você deseja exportar a estrutura e seus campos para outros pacotes, verifique se os nomes começam com letras maiúsculas. Caso contrário, o escopo é limitado a esse pacote.

Instanciação da estrutura

Definir uma estrutura significa que apenas criamos um plano. Para criar um objeto fora da estrutura, precisamos criar uma instância.

Para criar uma instância de uma classe em Go, comece com a palavra -chave var seguida pelo nome da instância.

O exemplo abaixo cria uma instância da estrutura do funcionário.

VAR EMP Funcionário

Depois de criarmos uma instância da estrutura, podemos acessar os campos usando a notação de ponto como mostrado:

VAR EMP Funcionário
Emp.Nome = "Thomas J"
Emp.Idade = 35
Emp.Aposentado = falso
Emp.Departamento = "DevOps Engineer"
Emp.Salário = 130000.50

Depois de definirmos os campos do Instituto, podemos imprimi -lo como:

fmt.Println (EMP)

O snippet acima retorna:

$ go run structs.ir
Thomas J 35 Engenheiro de DevOps falso 130000.5

Instanciação de estrutura - literal

Você também pode criar uma instância de uma estrutura usando o método literal da estrutura. O exemplo abaixo mostra que usa a estrutura literal para criar uma instância de uma estrutura.

var emp1 = funcionário "Mary A", 26, false, "Game Developer", 150000.10
fmt.Println (emp1)

O exemplo acima cria uma instância da classe e define os campos sem usar a notação de ponto.

Instanciação da estrutura - nova palavra -chave

Se você não deseja definir os valores durante a criação da instância, pode usar a nova palavra -chave. Por exemplo:

var emp2 = novo (funcionário)

Uma vez criado, podemos acessar os campos da instância e definir valores como:

EMP2.Nome = "Judy L"
EMP2.Idade = 60
EMP2.Aposentado = true
EMP2.Departamento = "Recursos Humanos"
EMP2.Salário = 119000.99

Acesso a campos da estrutura

Para acessar os campos de uma estrutura, vá nos fornecer o operador DOT. Começamos com o nome da instância da estrutura e depois o nome do campo.

Por exemplo, para obter o nome do EMP2, podemos fazer:

fmt.Println (emp2.Nome)

Isso deve retornar o valor armazenado pelo campo especificado.

Métodos de estrutura

Também podemos adicionar um método a uma estrutura usando o receptor de método. Considere o exemplo abaixo que cria um método para a estrutura do funcionário.

func (e funcionário) info () string
fmt.Printf ("Nome: %s \ n idade: %d \ n aposentado: %t \ n departamento: %s \ n Salário: %f \ n", e.Nome, e.Idade, e.Aposentado, e.Departamento, e.Salário)
retornar "feito"

Depois de declararmos o método, podemos criar uma instância e definir os campos como:

Var e funcionário
e.Nome = "Thomas J"
e.Idade = 35
e.Aposentado = falso
e.Departamento = "DevOps Engineer"
e.Salário = 130000.50

Finalmente, podemos chamar o método como:

fmt.Println (e.Info ())

Após a chamada do método, devemos obter uma saída como:

Nome: Thomas J
Idade: 35
Aposentado: Falso
Departamento: Engenheiro DevOps
Salário: 130000.500000
Feito

Tipo de campo de estrutura

Você pode descobrir o tipo de campo usando o pacote refletir. Por exemplo, para obter o tipo de campo aposentado, podemos fazer:

fmt.Println (reflita.Typeof (e.Aposentado))

O código acima retorna o tipo de campo como:

::saída
bool

Comparação de estrutura

Você pode verificar se uma estrutura é igual a outra usando o operador de comparação. Observe que uma estrutura é definida como igual se todos os campos tiverem valor igual.

Nota: nem todos os tipos de dados são comparáveis.

O exemplo abaixo cria duas estruturas e as compara usando o operador ==.

..
Var e funcionário
e.Nome = "Thomas J"
e.Idade = 35
e.Aposentado = falso
e.Departamento = "DevOps Engineer"
e.Salário = 130000.50
var emp2 = novo (funcionário)
EMP2.Nome = "Judy L"
EMP2.Idade = 60
EMP2.Aposentado = true
EMP2.Departamento = "Recursos Humanos"
EMP2.Salário = 119000.99
Se e == *emp2
fmt.Println ("estruturas são iguais")
outro
fmt.Println ("estruturas não iguais")

..

Como as estruturas não são iguais, o bloco else é executado.

DICA: Valores vazios e zero são considerados iguais.

Conclusão

Ufa!

Esse foi um excelente tutorial sobre o trabalho com estruturas em Go Lang. Este tutorial, no entanto, cobre apenas o básico. Existem muito mais operações que você pode fazer com estruturas.

Continue praticando e confira nossos tutoriais para aprender mais.