Resources
22. Structs
Working with different types together
Struct Type
Slice and array are good for storing collection of data which is of same type. What if our data is made up of smaller types which are different? This is where struct comes in handy.A struct is a type that contains named fields. Struct is a value that is constructed out of other values of many different types.
Slices and maps are used to store collection of similar data where as struct is used to groups together zero or more named values of arbitrary types as a single entity. Grouping together data of different types, that's where struct is useful.
Declaring Struct
A simple struct can be constructed using
struct keyword asstruct {field type}main.go
1
var person struct {
2
name string
3
age int
4
}
Copied!
name and age are called fields of struct.Generally, we will use multiple instance of struct in code. It is very common define struct as user defined type using
type keyword for reuse.main.go
1
type person struct {
2
name string
3
age int
4
}
5
var p1 person
6
var p2 person
Copied!
now
person is a user defined struct type. p1 and p2 variables are both of type person.Creating struct
Declaring a variable of a particular struct type creates a struct. There is no explicit call required to any other function.
main.go
1
var p1 person
2
var p2 person
3
fmt.Println(p1)
4
fmt.Println(p2)
Copied!
Accessing Struct Fields
Struct fields are accessed using dot operator
. This can be used to read as well as write to struct fields.main.go
1
p1.name = "Joey"
2
p1.age = 30
3
fmt.Println(p1)
Copied!
Zero Values
When a struct is declared, it gets initialized to zero values for its all the fields.
main.go
1
type show struct {
2
name string
3
price float64
4
isAvailable bool
5
rating int
6
}
7
var s show
8
fmt.Printf("%#v\n", s)
9
// output
10
// main.show{name:"", price:0, isAvailable:false, rating:0}
Copied!
Struct literals
We can use struct literals to declare and initialize struct with initial value instead of zero value. We can define person struct type using struct literal as
main.go
1
var p3 person = person{
2
name: "Chandler",
3
age: 32,
4
}
5
fmt.Printf("%#v\n", p3)
Copied!
Comparing structs
Two structs of same type are comparable if and only if all the fields of the struct are comparable using
==.main.go
1
var p4 person = person{
2
name: "Chandler",
3
age: 32,
4
}
5
var p5 person = person{
6
name: "Joey",
7
age: 30,
8
}
9
fmt.Println("are p4 and p5 equal? ==>", p4 == p5)
Copied!
Struct as another struct field
Like we can use data types like integers ,floats and strings as fields for a struct, we can also user another struct as field for building new structs. This is useful for reusing already created user defined types.
main.go
1
type human struct {
2
name string
3
age int
4
}
5
6
type superHuman struct {
7
human human
8
power string
9
}
10
11
superman := superHuman{
12
human: human{
13
name: "Clark Kent",
14
age: 30,
15
},
16
power: "Flying",
17
}
18
19
fmt.Printf("%#v\n", superman)
20
// output
21
// main.superHuman{human:main.human{name:"Clark Kent", age:30}, power:"Flying"}
Copied!
Note that if we need to access name of superman we need to use
superman.human.namemain.go
1
fmt.Println(superman.human
.name)
Copied!
Anonymous fields for struct
What if we wish to use
superman.name instead of superman.human.name in above code? Go supports this by providing type embedding. An inner struct that is stored within an outer struct using an anonymous field is said to be embedded within the outer struct.We are embedding
human type inside superHero type. There is no named field inside superHero to which we are assigning human type. Outside struct literal, we can access fields of human type directly as if these fields exists on superHero. This is called type promotion.main.go
1
type superHero struct {
2
livesSaved int
3
human // embedding type
4
}
5
batman := superHero{}
6
ironman := superHero{
7
livesSaved: 100000,
8
human: human{
9
name: "Tony",
10
age: 40,
11
},
12
}
13
14
batman.name = "Bruce" // accessing embedded type's field
15
batman.age = 50 // accessing embedded type's field
16
batman.livesSaved = 100
17
18
fmt.Printf("%#v\n", batman)
19
fmt.Printf("%#v\n", ironman)
Copied!
Embedding Types
Blog Post
Methods, Interfaces and Embedded Types in Go
Last modified 2yr ago