How to create a Struct Instance Using a Struct Literal in Golang?

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: 
 

1. A key must be a field name declared in the struct type.
2. 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.
3. 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.
4. A literal may omit the element list; such a literal evaluates to the zero value for its type.
5. It is an error to specify an element for a non-exported field of a struct belonging to a different package.

Example 1:
 

// Golang program to show how to
// declare and define the struct
// using struct literal
package main

// importing required modules
import "fmt"

// Defining a struct type
type Student struct {
    name       string
    roll_no    int
    city       string
    department string
}

func main() {

    // Declaring a variable of a `struct` type
    // All the struct fields are initialized
    // with their zero value
    var x Student
    fmt.Println("Student0:", x)

    // Declaring and initializing a
    // struct using a struct literal
    // Fields should be initialised in
    // the same order as they are declared
    // in struct's definition
    x1 := Student{"Akshay", 1, "Lucknow", "Computer Science"}
    
    fmt.Println("Student1: ", x1)

    // You can specify keys for 
    // their respective values
    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:
 

// Golang program illustrating
// the use of string literals
package main

// importing required modules
import "fmt"

// Defining a struct type
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:
 

// Golang program illustrating
// the use of string literals
package main

// importing required modules
import "fmt"

// Defining a struct type
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:
 

package main

// importing required modules
import "fmt"

// Defining a struct type
type Address struct {
    name, city string
    Pincode    int
}

func main() {
    // Only 1 key is specified here
    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.