Go માં structs શું છે?

Question

Accepted Answer

**struct** એ એક કમ્પોઝિટ પ્રકાર છે જે સંબંધિત ફીલ્ડને એક સાથે જૂથબદ્ધ કરે છે — કસ્ટમ ડેટા પ્રકારો વ્યાખ્યાયિત કરવાનો અને એન્ટિટીઝને મોડેલ કરવાનો Go નો રસ્તો. Go ના પાસે ક્લાસીસ નથી તેથી, structs (અને મેથડ્સ) એ object-oriented-શૈલીનો પ્રોગ્રામિંગ કરવાનો રસ્તો છે.

## 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)
```

મેથડ્સ *receiver* દ્વારા 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, માન્યતા લાઇબ્રેરીઓ દ્વારા ઉપયોગ કરવામાં આવે છે) reflection દ્વારા વાંચવામાં આવે છે તે સંલગ્ન કરે છે.

## તે શા માટે મહત્વપૂર્ણ છે

Structs એ Go માં ડેટાને મોડેલ કરવાનો અને કસ્ટમ પ્રકાર બનાવવાનો મુખ્ય રસ્તો છે — અને મેથડ્સ સાથે, તેઓ Go ના object-oriented-શૈલીનો પ્રોગ્રામિંગ કરવાનો રસ્તો છે (તેની પાસે ક્લાસીસ નથી).

Struct વ્યાખ્યા, **મૂડીકરણ-આધારિત દૃશ્યતા** સંમેલન (Go માટે અનન્ય), **મૂલ્ય સેમેન્ટિક્સ** (આચમણ નકલ કરે છે — તેથી શેર/સંશોધિત કરવા માટે પોઈન્ટર વાપરો, એક સામાન્ય ભૂલ), મૂલ્ય વર્સસ પોઈન્ટર રીસીવર્સ સાથે મેથડ્સ, અને struct ટેગ્સ (JSON/DB મેપિંગ માટે) તે લગભગ તમામ Go કોડ માટે મૌલિક છે.

Structs સર્વત્ર દેખાય છે — ડોમેન મોડેલ્સ, કોન્ફિગરેશન, API પેલોડ્સ, ડેટા સ્ટ્રક્ચર્સ — તેમને અત્યાવશ્યક, દૈનિક જ્ઞાન બનાવે છે Go માં અસરકારક રીતે કામ કરવા માટે.