Estruturas em Golang

As estruturas em Golang são uma das mais usadas e uma maneira de criar tipos definidos pelo usuário.

Neste, estarei cobrindo todos os fundamentos sobre structs e como usá-los em seus programas go com alguns exemplos.

Vamos começar!

Introdução

UMA estrutura é uma coleção de vários campos de dados com seus tipos de dados definidos agrupados. Eles são úteis para agrupar dados para formar registros personalizados. Uma struct consiste em tipos internos e definidos pelo usuário (a própria struct é um tipo definido pelo usuário).

As estruturas em Golang são mutáveis, ou seja, podem ser modificadas ao longo do programa.

Os structs ajudam a melhorar a qualidade geral do código, permitindo-nos criar e passar estruturas de dados complexas em vários módulos. Imagine passar 10 parâmetros para uma função, logo você vai fugir do código. É exatamente por isso que as structs são úteis, agora, em vez de 10 parâmetros, você simplesmente passa uma única struct para essa função.

Uma struct é declarada usando duas palavras-chave – modelo e estrutura. Ele é envolto por chaves (assim como as classes em java) – que contém um conjunto de campos que possuem um tipo definido e um identificador (nome). Discutimos os detalhes da implementação na próxima seção.

  Como encontrar seu ID de equipe no Slack

Se você tem experiência em Programação Orientada a Objetos (OOP), pode pensar em struct como uma classe, mas sem herança.

Declarando estruturas

Agora que você já entendeu o que é struct e para que serve, é hora de aprender a declarar structs. O esqueleto básico de uma estrutura se parece com –

type name_of_struct struct { 
     field1 data_type_field1 
     field2 data_type_field2 
 }

Aqui, type e struct são palavras-chave, enquanto struct contém vários campos com seus tipos de dados definidos.

Vejamos um exemplo –

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
}

func main() {
	var user User
	fmt.Println(user)
}

Aqui, definimos uma estrutura de usuário que consiste nos campos string, int e float32. No main () declaramos nosso struct como usuário e o imprimimos! A saída que obtemos é o valor zero/vazio de struct, pois ainda não o inicializamos! o valor zero é basicamente valores zero de cada campo.

{ 0 0}

Inicializando estruturas

Na seção anterior, aprendemos como declarar structs. Agora, gostaríamos de inicializar ou atribuir valores a eles. Verifique o código abaixo sobre como fazemos isso –

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
}

func main() {
	// With field names
	user1 := User{
		name:        "Mohit",
		age:         24,
		bankBalance: 100.0,
	}
	
	// Without field names
	user2 := User{"Nidhi", 21, 1000.0}
	
	fmt.Println(user1)
	fmt.Println(user2)
}

O próprio código explica como inicializamos duas estruturas com e sem nomes de campo. Aqui, a saída será –

{Mohit 24 100}
 {Nidhi 21 1000}

No caso acima, se um dos campos não for inicializado, esse campo será padronizado para seu valor zero.

user1 := User{
	name:        "Mohit",
	age:         24,
}

 // Output - { Mohit 24 0.0 }

Existe mais uma maneira de criar structs usando a nova palavra-chave. Veremos como usá-lo na próxima seção.

  Prática com chamadas de voz e vídeo do Skype para Outlook.com

Acessando campos de uma struct

Agora que sabemos como criar e inicializar structs, vamos ver como acessar os campos de uma struct. Para isso, Golang nos fornece o operador ponto. Continuando com o exemplo anterior, vamos acessar os campos nome e idade e imprimi-los.

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
}

func main() {
	// With field names
	user := User{
		name:        "Mohit",
		age:         24,
		bankBalance: 100.0,
	}

	fmt.Println(user.name)
	fmt.Println(user.age)
	fmt.Println(user.bankBalance)
}

Aqui, usamos struct_name.field_name para acessar campos em uma estrutura. A saída do código acima será –

Mohit
 24
 100

Como mencionado anteriormente, podemos criar structs com a nova palavra-chave. Vamos ver como –

user := new(User)
 user.name = "Mohit"
 user.age = 24
 user.bankBalance = 100.0

 fmt.Println(user)

 // Output - &{Mohit 24 100}

A palavra-chave new retorna o ponteiro para a estrutura inicializada. Em Golang, você não precisa desreferenciar explicitamente o ponteiro, mas fmt.Println(*user) resultaria na mesma saída.

estruturas aninhadas

Estruturas em golang também podem conter outros tipos definidos pelo usuário. Portanto, uma estrutura pode conter outras estruturas aninhadas.

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
	roleDetails RoleDetails
}

type RoleDetails struct {
	position string
	team     string
}

func main() {
	roleDetailForMohit := RoleDetails{
		position: "Software Engineer",
		team:     "Transport",
	}
	user := User{
		name:        "Mohit",
		age:         24,
		bankBalance: 100.0,
		roleDetails: roleDetailForMohit,
	}

	fmt.Println(user)
}

No código acima, temos a estrutura RoleDetails como parte da estrutura do usuário. A saída será –

{Mohit 24 100 {Software Engineer Transport}}

Se você deseja acessar roleDetails, pode fazer isso usando o mesmo operador de ponto –

  Como usar o novo aplicativo Compass no Apple Watch

user.roleDetails.position

Igualdade Estrutural

Duas structs são iguais se cada um dos campos que elas possuem for igual (ambos integrados e definidos pelo usuário), mas nem todos os tipos de dados são comparáveis. (o mapa não é comparável diretamente). Vejamos um exemplo para demonstrar a igualdade.

package main

import (
	"fmt"
)

type User struct {
	name        string
	age         int
	bankBalance float32
}

func main() {
	user1 := User{
		name:        "Mohit",
		age:         24,
		bankBalance: 100.0,
	}
	user2 := User{
		name:        "Mohit",
		age:         24,
		bankBalance: 100.0,
	}
	user3 := User{
		name:        "Nidhi",
		age:         21,
		bankBalance: 1000.0,
	}

	if user1 == user2 {
		fmt.Println("user1 and user2 are equal")
	} else {
		fmt.Println("user1 and user2 are not equal")
	}

	if user1 == user3 {
		fmt.Println("user1 and user3 are equal")
	} else {
		fmt.Println("user1 and user3 are not equal")
	}
}

Estruturas vazias e de valor zero são iguais. A ordem dos campos não importa, basicamente, cada campo deve corresponder à igualdade. A saída para o código acima será –

user1 and user2 are equal
user1 and user3 are not equal

Conclusão

Incrível!

Agora você está pronto para usar structs em golang. Cobrimos todos os fundamentos, como declaração, inicialização e acesso a campos struct. Também vimos como comparar duas estruturas e até implementamos uma estrutura aninhada. Aqui estão alguns recursos para aprender mais sobre structs –

Há muito mais para aprender sobre structs, mas é um bom começo por enquanto. Espero que você tenha aprendido algo novo!

Continue explorando. Continue aprendendo!