Go માં structs શું છે?

Question

IT Interview Practice · 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 માં અસરકારક રીતે કામ કરવા માટે.

Struct ને વ્યાખ્યાયિત અને ઉપયોગ કરવો

મૂડીકરણ દ્વારા ફીલ્ડ દૃશ્યતા

Structs પર મેથડ્સ (Go નો OOP)

Structs મૂલ્ય પ્રકાર છે

Struct ટેગ્સ (મેટાડેટા)

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

સંબંધિત પ્રશ્નો