Introdução
Uma estrutura (struct) é um tipo composto que pode ser usado para armazenar diferentes tipos de dados. Ela pode ser utilizada para implementar estruturas de dados mais complexas. Por exemplo, os itens em uma loja de conveniência possuem atributos como nome do produto, categoria e preço. Podemos usar uma estrutura para representá-los.
Neste laboratório, aprenderemos sobre como definir e usar estruturas.
Pontos de Conhecimento:
- Definição de uma estrutura
- Métodos de uma instância de estrutura
Definição de Estrutura
Podemos usar as palavras-chave type e struct para definir uma estrutura. A sintaxe é a seguinte:
type StructName struct {
FieldName Type
// ...
}
Onde:
- Type representa o tipo específico do nome do campo, que pode ser um inteiro, string, etc.
- StructName deve ser único dentro do mesmo pacote.
- Os nomes dos campos devem ser únicos dentro da mesma estrutura.
Vamos experimentar. Vamos definir uma loja de conveniência:
type Store struct {
ProductType string // tipo do produto
ProductName string // nome do produto
Price int // preço do produto
}
No código acima, definimos uma estrutura chamada Store para a loja de conveniência, que inclui o tipo, nome e preço do produto.
Como os campos tipo do produto e nome do produto são do mesmo tipo, podemos simplificar o código da seguinte forma:
type Store struct {
ProductName, ProductType string
Price int
}
Instanciação usando var
Na seção anterior, definimos uma estrutura de loja de conveniência Store, que descreve o espaço de memória. A memória só será alocada e os campos da estrutura serão utilizados após a instanciação.
Podemos usar a palavra-chave var para instanciar uma estrutura:
var InstanceName Structure
Vamos dar uma olhada em um exemplo de instanciação. Crie um arquivo chamado struct.go e escreva o seguinte código:
cd ~/project
touch struct.go
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
// Instanciar uma estrutura usando `var`
var store1 Store
// Atribuir valores aos campos relacionados à instância store1
store1.productType = "Drinks"
store1.productName = "Coca-Cola"
store1.price = 3
fmt.Printf("store1:\n\t%s\n\t%s\n\t%d\n",
store1.productType, store1.productName, store1.price)
}
Execute o programa:
go run struct.go
Após a execução, o seguinte resultado é exibido:
store1:
Drinks
Coca-Cola
3
Neste programa, instanciamos uma loja de conveniência usando var e, em seguida, atribuímos valores aos seus campos usando o operador ..
Valor Inicial de uma Estrutura
Qual será o valor de uma estrutura instanciada se a inicializarmos apenas sem atribuir um valor? Vamos dar uma olhada no código a seguir:
package main
import "fmt"
type Store struct {
ProductName string
ProductType string
Price int
}
func main() {
// Instanciar uma estrutura usando `var`
var lan1 Store
// Imprimir o valor da estrutura usando %#v
fmt.Printf("lan1: %#v\n", lan1)
}
Execute o programa:
go run struct.go
O resultado é o seguinte:
lan1: main.Store{ProductName:"", ProductType:"", Price:0}
Podemos ver que, quando nenhum valor inicial é especificado, o valor da estrutura instanciada é o valor zero do tipo correspondente. Por exemplo, a string está vazia e o inteiro é 0.
Instanciação usando new
Além de usar a palavra-chave var para instanciação, também podemos usar a palavra-chave new:
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
store := new(Store)
// Use %T para exibir o tipo
fmt.Printf("Type of store: %T\n", store)
store.productType = "Daily Necessities"
store.productName = "Umbrella"
store.price = 20
fmt.Printf("store:\n\t%s\n\t%s\n\t%d\n",
store.productType, store.productName, store.price)
}
Execute o programa:
go run struct.go
O resultado é o seguinte:
Type of store: *main.Store
store:
Daily Necessities
Umbrella
20
Ao usar a palavra-chave new para instanciação, a "instância" que ela cria é, na verdade, um ponteiro para a instância. A operação de atribuir um valor ao ponteiro da estrutura é a mesma que atribuir um valor a uma estrutura normal.
Instanciação usando :=
Da mesma forma, podemos usar := para instanciar uma estrutura:
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
lan3 := Store{}
lan3.productType = "Fresh Food"
lan3.productName = "Taiwanese Meatballs"
lan3.price = 20
fmt.Printf("lan3:\n\t%s\n\t%s\n\t%d\n",
lan3.productType, lan3.productName, lan3.price)
}
Execute o programa:
go run struct.go
O resultado é o seguinte:
lan3:
Fresh Food
Taiwanese Meatballs
20
Podemos escrever a inicialização e a atribuição juntas, assim:
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
lan3 := Store{
productType: "Fresh Food",
productName: "Taiwanese Meatballs",
price: 4,
}
fmt.Printf("lan3:\n\t%s\n\t%s\n\t%d\n",
lan3.productType, lan3.productName, lan3.price)
}
Execute o programa:
go run struct.go
O resultado é o seguinte:
lan3:
Fresh Food
Taiwanese Meatballs
4
Quando precisamos atribuir valores a todos os campos de uma estrutura, podemos escrever os valores na ordem em que são definidos na estrutura.
Por exemplo, reescrevemos a instância lan3 da seguinte forma:
lan3 := Store{
"Fresh Food",
"Taiwanese Meatballs",
4,
}
Nota: Esta sintaxe é adequada apenas para casos em que os valores são atribuídos a todos os campos.
Resumo
Neste laboratório, introduzimos estruturas e resumimos os seguintes pontos de conhecimento:
- Estruturas são tipos de dados compostos que podem conter múltiplos tipos de dados diferentes.
- O valor de uma estrutura não inicializada é o valor zero do tipo correspondente.
- Três métodos de instanciação de uma estrutura.
