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!
últimas postagens
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.
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.
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 –
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!