Structs in Golang

What are Structs in Go?

Structs Go में composite data types होते हैं, जो कि एक group of fields (variables) को एक साथ hold कर सकते हैं। हर field का अपना data type हो सकता है, और यह एक ही struct में अलग-अलग types को combine करने की सुविधा देता है। Structs का उपयोग complex data structures को represent करने के लिए किया जाता है, जैसे कि records या objects।

Basic Syntax for Declaring a Struct

Go में struct को declare करने के लिए आप type keyword का उपयोग करते हैं, उसके बाद struct का नाम और फिर उसके fields को define करते हैं।

Example: Declaring a Simple Struct

package main

import "fmt"

// Declaring a struct named 'Person'
type Person struct {
    Name   string
    Age    int
    Gender string
}

func main() {
    // Creating an instance of the struct
    var p Person
    
    // Assigning values to the fields
    p.Name = "Alice"
    p.Age = 30
    p.Gender = "Female"
    
    // Accessing the fields
    fmt.Println("Name:", p.Name)
    fmt.Println("Age:", p.Age)
    fmt.Println("Gender:", p.Gender)
}

Explanation:

• type Person struct { ... }: यह Person नाम का struct declare करता है, जिसमें तीन fields हैं: Name, Age, और Gender।
• var p Person: यह statement Person struct का एक instance (p) create करता है।
• p.Name = "Alice": यह p के Name field को "Alice" value assign करता है।
• Output: "Name: Alice", "Age: 30", और "Gender: Female"।

1. Initializing Structs

Structs को initialize करने के कई तरीके होते हैं:

• Field Names के साथ (named initialization)
• Field Names के बिना (positional initialization)

Example: Named Initialization

package main

import "fmt"

// Declaring a struct named 'Person'
type Person struct {
    Name   string
    Age    int
    Gender string
}

func main() {
    // Named initialization
    p := Person{
        Name:   "Bob",
        Age:    25,
        Gender: "Male",
    }
    
    fmt.Println("Person:", p)
}

Explanation:

• Person{Name: "Bob", Age: 25, Gender: "Male"}: यह named initialization है, जहां हर field के लिए value explicitly specify की गई है।
• Output: "Person: {Bob 25 Male}"।

Example: Positional Initialization

package main

import "fmt"

// Declaring a struct named 'Person'
type Person struct {
    Name   string
    Age    int
    Gender string
}

func main() {
    // Positional initialization
    p := Person{"Charlie", 28, "Male"}
    
    fmt.Println("Person:", p)
}

Explanation:

• Person{"Charlie", 28, "Male"}: यह positional initialization है, जहां values fields के order में provide की गई हैं। ध्यान दें कि positional initialization में सभी fields की values specify करनी होती हैं।
• Output: "Person: {Charlie 28 Male}"।

2. Anonymous Structs

Go में आप anonymous structs भी create कर सकते हैं, जिनके लिए कोई specific type name define नहीं किया जाता। यह structs को तुरंत define और use करने के लिए उपयोगी होते हैं।

Example: Anonymous Struct

package main

import "fmt"

func main() {
    // Declaring and initializing an anonymous struct
    p := struct {
        Name   string
        Age    int
        Gender string
    }{
        Name:   "Diana",
        Age:    22,
        Gender: "Female",
    }
    
    fmt.Println("Anonymous Struct:", p)
}

Explanation:

• struct { ... }{ ... }: यह anonymous struct declaration और initialization है।
• Output: "Anonymous Struct: {Diana 22 Female}"।

3. Structs with Methods

Go में आप structs के साथ methods भी define कर सकते हैं, जो structs के instances के साथ associated होती हैं। Methods Go में object-oriented programming की तरह ही काम करती हैं।

Example: Structs with Methods

package main

import "fmt"

// Declaring a struct named 'Person'
type Person struct {
    Name   string
    Age    int
    Gender string
}

// Method associated with the Person struct
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s. I am %d years old.\n", p.Name, p.Age)
}

func main() {
    p := Person{"Eve", 29, "Female"}
    p.Greet() // Calling the method
}

Explanation:

• func (p Person) Greet() { ... }: यह method Person struct के साथ associated है। Method receiver (p Person) specify करता है कि यह method किस type के साथ associated है।
• p.Greet(): यह method call करता है, जो "Hello, my name is Eve. I am 29 years old." output देगा।

4. Pointer Receivers in Methods

आप methods में pointer receivers का उपयोग करके struct के fields को modify भी कर सकते हैं। Pointer receivers यह ensure करते हैं कि method struct के original instance को modify कर सके।

Example: Pointer Receivers

package main

import "fmt"

// Declaring a struct named 'Person'
type Person struct {
    Name   string
    Age    int
    Gender string
}

// Method with a pointer receiver
func (p *Person) HaveBirthday() {
    p.Age++
}

func main() {
    p := Person{"Frank", 40, "Male"}
    fmt.Println("Before Birthday:", p.Age)
    
    p.HaveBirthday() // Method call that modifies the struct
    
    fmt.Println("After Birthday:", p.Age)
}

Explanation:

• func (p *Person) HaveBirthday() { ... }: यह method pointer receiver का उपयोग करता है, जिससे यह method Person struct के fields को modify कर सकता है।
• p.HaveBirthday(): यह method p.Age को increment करता है। Output में Age field पहले 40 और बाद में 41 दिखेगा।

5. Embedding Structs (Composition)

Go में आप एक struct के अंदर दूसरे struct को embed कर सकते हैं। इसे composition कहते हैं, और यह inheritance के समान काम करता है, लेकिन बिना inheritance के complexities के।

Example: Embedding Structs

package main

import "fmt"

// Declaring a struct named 'Person'
type Person struct {
    Name string
    Age  int
}

// Declaring another struct named 'Employee' that embeds 'Person'
type Employee struct {
    Person   // Embedding Person struct
    Position string
}

func main() {
    e := Employee{
        Person: Person{Name: "Grace", Age: 35},
        Position: "Manager",
    }

    // Accessing fields from both embedded and outer struct
    fmt.Println("Employee Name:", e.Name)
    fmt.Println("Employee Age:", e.Age)
    fmt.Println("Employee Position:", e.Position)
}

Explanation:

• type Employee struct { Person }: यह Employee struct के अंदर Person struct को embed करता है। अब Employee के पास Person struct के fields भी हैं।
• e.Name, e.Age: ये fields directly access किए जा सकते हैं क्योंकि Person struct Employee struct में embedded है।
• Output: "Employee Name: Grace", "Employee Age: 35", और "Employee Position: Manager"।

6. Tags in Structs

Go में आप struct fields के साथ tags भी specify कर सकते हैं। Tags metadata के रूप में कार्य करते हैं और इन्हें अक्सर data serialization (जैसे JSON, XML) में उपयोग किया जाता है।

Example: Struct Tags

package main

import (
    "encoding/json"
    "fmt"
)

// Declaring a struct named 'Person' with JSON tags
type Person struct {
    Name   string `json:"name"`
    Age    int    `json:"age"`
    Gender string `json:"gender"`
}

func main() {
    p := Person{"Helen", 32, "Female"}
    
    // Converting struct to JSON
    jsonData, _ := json.Marshal(p)
    fmt.Println("JSON:", string(jsonData))
}

Explanation:

• json:"name": यह tag specify करता है कि जब Person struct को JSON में convert किया जाएगा, तो Name field का key "name" होगा।
• json.Marshal(p): यह function Person struct को JSON string में convert करता है।
• Output: "JSON: {"name":"Helen","age":32,"gender":"Female"}"।

Summary

• Structs: Go में composite data types होते हैं, जो multiple fields को group कर सकते हैं। ये complex data structures को represent करने के लिए उपयोगी होते हैं।
• Initialization: Structs को named या positional initialization से initialize किया जा सकता है। Anonymous structs भी possible हैं।
• Methods: Structs के साथ methods को define किया जा सकता है। Methods struct के instances के साथ associated होती हैं।
• Pointer Receivers: Pointer receivers का उपयोग करके आप struct के fields को methods के जरिए modify कर सकते हैं।
• Embedding: Structs के अंदर दूसरे structs को embed करके composition achieve किया जा सकता है।
• Tags: Struct fields के साथ tags specify करके metadata provide किया जा सकता है, जो serialization जैसे tasks में उपयोगी होता है।

Structs Go में complex data models को represent करने के लिए fundamental building blocks हैं। अगर आपको structs के बारे में और जानकारी चाहिए या कोई specific सवाल है, तो बताइए!

Previous