How to create a Struct Instance Using a Struct Literal in Golang?
Last Updated :
21 Feb, 2022
A structure or struct in Golang is a user-defined data type which is a composition of various data fields. Each data field has its own data type, which can be a built-in or another user-defined type. Struct represents any real-world entity which has some set of properties/fields.
For Example, a student has a name, roll number, city, department. It makes sense to group these four properties into a single structure address as shown below.
type Student struct {
name string
roll_no int
city string
department string
}
Syntax for declaring a structure:
var x Student
The above code creates a variable of type Student in which fields by default are set to their respective zero values.
Since struct is a composite data type, it is initialized using composite literals. Composite literals construct values for structs, arrays, slices, and maps where a single syntax is used for those types. Struct literals are used to create struct instances in Golang. You can create a struct instance using a struct literal as follows:
var d = Student{"Akshay", 1, "Lucknow", "Computer Science"}
We can also use a short declaration operator.
d := Student{"Akshay", 1, "Lucknow", "Computer Science"}
You must keep the following rules in mind while creating a struct literal:
- A key must be a field name declared in the struct type.
- An element list that does not contain any keys must list an element for each struct field in the order in which the fields are declared.
- An element list that contains keys does not need to have an element for each struct field. Omitted fields get the zero value for that field.
- A literal may omit the element list; such a literal evaluates to the zero value for its type.
- It is an error to specify an element for a non-exported field of a struct belonging to a different package.
Example 1:
C
package main
import "fmt"
type Student struct {
name string
roll_no int
city string
department string
}
func main() {
var x Student
fmt.Println("Student0:", x)
x1 := Student{"Akshay", 1, "Lucknow", "Computer Science"}
fmt.Println("Student1: ", x1)
x2 := Student{name: "Anita", roll_no: 2,
city: "Ballia", department: "Mechanical"}
fmt.Println("Student2: ", x2)
}
|
Output:
Student0: { 0 }
Student1: {Akshay 1 Lucknow Computer Science}
Student2: {Anita 2 Ballia Mechanical}
Uninitialized fields are set to their corresponding zero-values.
Example 2:
C
package main
import "fmt"
type Address struct {
name, city string
Pincode int
}
func main() {
add1 := Address{name: "Ram"}
fmt.Println("Address is:", add1)
}
|
Output:
Address is: {Ram 0}
It must be noted that uninitialized values are set to zero values when field:value initializer is used during instantiation. The following code will output an error.
Example:
C
package main
import "fmt"
type Address struct {
name, city string
Pincode int
}
func main() {
add1 := Address{"Ram"}
fmt.Println("Address is: ", add1)
}
|
Output:
Compilation Error: too few values in Address literal
If you specify least one key for an element, then you must specify all the other keys as well.
Example:
C
package main
import "fmt"
type Address struct {
name, city string
Pincode int
}
func main() {
add1 := Address{name: "Ram", "Mumbai", 221007}
fmt.Println("Address is: ", add1)
}
|
Output:
Compilation Error: mixture of field:value and value initializers
The above program throws an error as we have specified key for only one element and that creates a mixture of the field:value and value initializers. We should either go with the field:value or value initializers.
Share your thoughts in the comments
Please Login to comment...