Structures
A structure, or struct, in Go is a user-defined data type that groups together related items of different types into a single type. Any real-world entity with a set of properties or attributes can be effectively represented as a struct. This concept is often compared to classes in object-oriented programming but serves as a lightweight alternative. Unlike classes, structs in Go do not support inheritance but do support composition. For instance, consider a Person having a name, age, and address. It makes sense to group these attributes into a single structure like this:
Declaring a Structure:
type Person struct {
name string
age int
address string
}Here, the type keyword is used to introduce a new type named Person, followed by the keyword struct, indicating that we are defining a structure. Inside the curly braces {}, the struct fields are listed with their names and corresponding data types.
Compact Notation:
Fields of the same type can be declared together, as shown in this example:
type Person struct {
name, address string
age int
}Declaring and Initializing a Structure:
To define a variable of a struct type, use the following syntax:
var p PersonThis creates a variable p of type Person, initializing all fields to their zero values ("" for strings, 0 for integers, etc.). A struct can also be initialized with values using a struct literal:
var p = Person{"Alice", 25, "New York"}Named Field Initialization:
The name:value syntax allows initializing fields by name, skipping the order requirement:
var p = Person{name: "Bob", age: 30}Uninitialized fields will automatically be set to their zero values.
Example Program:
package main
import "fmt"
// Define a struct
type Person struct {
name string
age int
address string
}
func main() {
// Zero-value initialization
var p Person
fmt.Println(p)
// Initializing with struct literal
p1 := Person{"Alice", 25, "New York"}
fmt.Println("Person1:", p1)
// Named initialization
p2 := Person{name: "Bob", age: 30}
fmt.Println("Person2:", p2)
// Uninitialized fields have zero value
p3 := Person{name: "Charlie"}
fmt.Println("Person3:", p3)
}Output:
{ 0 }
Person1: {Alice 25 New York}
Person2: {Bob 30 }
Person3: {Charlie 0 }Accessing Fields of a Struct:
Fields of a struct are accessed using the dot (.) operator.
Example Program:
package main
import "fmt"
// Define the struct
type Vehicle struct {
brand, model string
weight float64
}
func main() {
v := Vehicle{brand: "Tesla", model: "Model S", weight: 2100}
// Access and display fields
fmt.Println("Vehicle Brand:", v.brand)
fmt.Println("Vehicle Model:", v.model)
// Update a field value
v.model = "Model X"
fmt.Println("Updated Vehicle:", v)
}Output:
Vehicle Brand: Tesla
Vehicle Model: Model S
Updated Vehicle: {Tesla Model X 2100}Pointers to a Struct:
Pointers in Go store the memory address of variables. Similarly, you can create pointers to structs.
Example Program:
package main
import "fmt"
// Define a struct
type Book struct {
title, author string
price float64
}
func main() {
b := &Book{"Go Programming", "John Doe", 29.99}
// Access fields via pointer
fmt.Println("Title:", b.title)
fmt.Println("Author:", b.author)
}Output:
Title: Go Programming
Author: John DoeAdditional Details and Benefits:
- Encapsulation: Structures group related data, simplifying management.
- Code Organization: They help organize complex data logically.
- Type Safety: Define types for fields, reducing type-related errors.
- Flexibility and Performance: Structures are efficient for memory and processing.
Before: a = 10, b = 20
Sum: 35
After: a = 10, b = 20Nested Structure in Golang
A structure or struct in Go is a user-defined data type that enables grouping elements of various types into a single unit. Structs are particularly useful for representing real-world entities that have multiple attributes or fields. Go supports nested structures, where a structure is used as a field within another structure. This concept is also known as Nested Structure.
Syntax:
type struct_name_1 struct {
// Fields of the structure
}
type struct_name_2 struct {
variable_name struct_name_1
}Example Program:
// Golang program to demonstrate nested structures
package main
import "fmt"
// Define a basic structure
type Book struct {
title string
author string
year int
}
// Define a nested structure
type Library struct {
collection Book
}
func main() {
// Initialize the fields of the structure
library := Library{
collection: Book{"The Alchemist", "Paulo Coelho", 1988},
}
// Display the values
fmt.Println("\nDetails of the Book in the Library")
fmt.Println(library)
}Output:
Details of the Book in the Library
{{The Alchemist Paulo Coelho 1988}}Example 2: Nested Structure with Multiple Fields
// Golang program to demonstrate nested structures
package main
import "fmt"
// Define a structure for Employee details
type Employee struct {
name string
dept string
tenure int
}
// Define a structure for Manager with nested Employee details
type Manager struct {
name string
project string
experience int
teamLead Employee
}
func main() {
// Initialize the fields of the structure
manager := Manager{
name: "Alice",
project: "AI Research",
experience: 10,
teamLead: Employee{"Bob", "IT", 5},
}
// Display the values
fmt.Println("Details of the Manager")
fmt.Println("Manager's Name: ", manager.name)
fmt.Println("Project: ", manager.project)
fmt.Println("Experience: ", manager.experience)
fmt.Println("\nDetails of the Team Lead")
fmt.Println("Team Lead's Name: ", manager.teamLead.name)
fmt.Println("Department: ", manager.teamLead.dept)
fmt.Println("Tenure: ", manager.teamLead.tenure)
}Output:
Details of the Manager
Manager's Name: Alice
Project: AI Research
Experience: 10
Details of the Team Lead
Team Lead's Name: Bob
Department: IT
Tenure: 5Anonymous Structure and Field in Golang
In Go, structures (or structs) help group elements of various types into a single logical unit, making them excellent for representing real-world entities. Anonymous structures are unnamed and temporary, designed for one-time use. On the other hand, anonymous fields allow embedding fields without explicitly naming them.
Syntax:
variable := struct {
field1 dataType1
field2 dataType2 // Definition of Anonymous Structure
// Additional fields as needed
}{value1, value2}
type StructName struct {
dataType1
dataType2 // Anonymous Fields
// Additional anonymous fields
}Example Code:
package main
import "fmt"
// Student struct containing an anonymous structure and anonymous fields
type Student struct {
struct { // Embedded anonymous structure for personal data
fullName string
rollNumber int
}
CGPA float64 // Regular field
}
func main() {
// Initializing the struct with values for the anonymous structure and other fields
learner := Student{
struct {
fullName string
rollNumber int
}{
fullName: "John Doe",
rollNumber: 67890,
},
CGPA: 4.0,
}
// Printing the values
fmt.Println("Full Name:", learner.fullName)
fmt.Println("Roll Number:", learner.rollNumber)
fmt.Println("CGPA:", learner.CGPA)
}Output:
Full Name: Jane Smith
Roll Number: 98765
CGPA: 3.9Anonymous Fields
Anonymous fields in Go are fields defined without explicit names, where their types act as their names. This approach is handy when the type itself conveys enough meaning.
Syntax:
type StructName struct {
dataType1
dataType2
// Additional anonymous fields
}Example:
package main
import "fmt"
// Student struct using anonymous fields
type Student struct {
int // Roll number (anonymous field)
string // Name (anonymous field)
float64 // CGPA (anonymous field)
}
func main() {
// Initializing the Student struct with anonymous fields
learner := Student{54321, "Alice", 4.1}
// Printing the values
fmt.Println("Roll Number:", learner.int)
fmt.Println("Name:", learner.string)
fmt.Println("CGPA:", learner.float64)
}Output:
Roll Number: 54321
Name: Alice
CGPA: 4.1