Go లో structs అంటే ఏమిటి?

Question

Accepted Answer

**Struct** అనేది సంబంధిత ఫీల్డ్‌లను కలిసి సమూహం చేసే ఒక సమ్మేళిత రకం — Go యొక్క రీతిలో కస్టమ్ డేటా రకాలను నిర్వచించడం మరియు ఎంటిటీలను మోడల్ చేయడం. Go కి తరగతులు లేనందున, structs (మరియు పద్ధతులు) ఆబ్జెక్ట్-ఓరియంటెడ్-స్టైల్ ప్రోగ్రామింగ్ చేయడానికి మీ మార్గం.

## Struct ను నిర్వచించడం మరియు ఉపయోగించడం

```go
type Person struct {
    Name string     // exported (capitalized) → accessible from other packages
    Age  int
    email string    // unexported (lowercase) → package-private
}

// creating instances
p1 := Person{Name: "Ann", Age: 30}        // named fields (preferred — clear, order-independent)
p2 := Person{"Bob", 25, "bob@x.com"}       // positional (fragile — order matters)
var p3 Person                              // zero value: {"", 0, ""}

p1.Name          // access fields with dot notation
p1.Age = 31      // mutate
```

## పెద్ద అక్షరాల ద్వారా ఫీల్డ్ దృశ్యమానత

```text
Capitalized field/type/func name → EXPORTED (public, usable outside the package)
lowercase name → unexported (private to the package)
```

Go కీవర్డ్‌ల కంటే పెద్ద అక్షరాలను ఉపయోగిస్తుంది, దృశ్యమానత కోసం — ఒక విలక్షణ సమ్మతి.

## Structs పై పద్ధతులు (Go యొక్క OOP)

```go
// a method is a function with a RECEIVER (the struct it operates on)
func (p Person) Greet() string {           // value receiver
    return "Hi, I'm " + p.Name
}
func (p *Person) Birthday() {                // pointer receiver — can MODIFY the struct
    p.Age++
}

p1.Greet()       // "Hi, I'm Ann"
p1.Birthday()    // modifies p1 (Go auto-takes the address)
```

పద్ధతులు *రిసీవర్* ద్వారా structs కు ప్రవర్తనను జోడిస్తాయి. పాయింటర్ రిసీవర్‌లు (`*Person`) పద్ధతులను struct ని సవరించుటకు అనుమతిస్తాయి; విలువ రిసీవర్‌లు ఒక కాపీని పొందుతాయి.

## Structs విలువ రకాలు

```go
p1 := Person{Name: "Ann"}
p2 := p1            // COPIES the entire struct (independent)
p2.Name = "Bob"
fmt.Println(p1.Name)   // "Ann" — unchanged (it was a copy)

// pass a pointer to share/modify
func update(p *Person) { p.Name = "X" }
```

Struct ను నియమించడం లేదా పాస్ చేయడం **దానిని కాపీ చేస్తుంది** (విలువ సెమాంటిక్‌లు) — భాగస్వామ్యం లేదా సవరించడానికి, పాయింటర్ ఉపయోగించండి.

## Struct ట్యాగ్‌లు (మెటాడేటా)

```go
type User struct {
    Name  string `json:"name"`           // tags guide encoding/decoding
    Email string `json:"email,omitempty"`
}
```

ట్యాగ్‌లు మెటాడేటాను జోడిస్తాయి (JSON, DB, ధ్రువీకరణ లైబ్రరీలు ఉపయోగిస్తాయి) ప్రతిబింబం ద్వారా చదువుతాయి.

## ఇది ఎందుకు ముఖ్యమైనది

Structs అనేది Go లో డేటాను మోడల్ చేయడానికి మరియు కస్టమ్ రకాలను రూపొందించడానికి ప్రధాన మార్గం — మరియు పద్ధతులతో కలిపి, అవి Go ఎలా ఆబ్జెక్ట్-ఓరియంటెడ్-స్టైల్ ప్రోగ్రామింగ్ చేస్తాయి (దీనికి తరగతులు లేవు).

Struct నిర్వచనం, **పెద్ద అక్షరాల ఆధారిత దృశ్యమానత సమ్మతిని** (Go కు ప్రత్యేకమైనది), **విలువ సెమాంటిక్‌లను** (అసైనమెంట్ కాపీలు — కాబట్టి భాగస్వామ్యం/సవరించడానికి పాయింటర్‌లను ఉపయోగించండి, సాధారణ ఆపాదన), విలువ వర్సస్ పాయింటర్ రిసీవర్‌లతో పద్ధతులను, మరియు struct ట్యాగ్‌లను (JSON/DB మ్యాపింగ్ కోసం) అర్థం చేసుకోవడం ఫలితంగా Go కోడ్‌కు ఫండమెంటల్ ఆకృతిలో ఉంటుంది.

Structs ప్రతిచోటా కనిపిస్తాయి — డొమైన్ మోడల్‌లు, కాన్ఫిగరేషన్, API పేలోడ్‌లు, డేటా స్ట్రక్చర్‌లు — వాటిని Go లో సమర్థవంతంగా పని చేయడానికి అవసరమైన, రోజువారీ జ్ఞానం చేస్తుంది.