Go-வில் struct-கள் என்ன?

Question

Accepted Answer

**Struct** என்பது தொடர்புடைய புலங்களை ஒன்றாகக் கூட்டும் ஒரு கலவையான வகை — Go-வின் பொதுவான தரவு வகைகளை வரையறுக்க மற்றும் நிறுவனங்களை மாதிரி செய்வதற்கான வழி. Go-க்கு வகுப்புகள் இல்லாத காரணத்தால், struct-ங்கள் (மேலும் முறைகள்) பொருள் சார்ந்த நடை நிரலாக்கத்தை எவ்வாறு செய்வது.

## ஒரு 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 முக்கிய சொற்கள் அல்ல, பெரிய எழுத்துகளைப் பயன்படுத்துகிறது — ஒரு வேறுபட்ட மரபு.

## Struct-களில் முறைகள் (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)
```

முறைகள் *பெறுப்பாளர்* மூலம் struct-களுக்கு நடத்தையை இணைக்கின்றன. சுட்டி பெறுப்பாளர்கள் (`*Person`) முறைகளை struct-ஐ மாற்றுவதற்கு அனுமதிக்கின்றன; மূல்य பெறுப்பாளர்கள் ஒரு நகல் பெறுகின்றனர்.

## Struct-குள் மூல்य வகைகள்

```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, சரிபார்ப்பு நூலகங்களால் பயன்படுத்தப்படுகிறது) பிரதிபலிப்பு மூலம் வாசிக்கப்படுவதை இணைக்கின்றன.

## இது ஏன் முக்கியம்

Struct-குள் Go-வில் தரவை மாதிரி செய்வதற்கும் பொதுவான வகைகளை உருவாக்குவதற்கும் அடிப்படை வழி — மற்றும் முறைகளுடன் சேர்ந்து, Go பொருள் சார்ந்த நடை நிரலாக்கத்தை எவ்வாறு செய்கிறது (வகுப்புகள் இல்லை).

Struct வரையறுதல், **பெரிய எழுத்து அடிப்படையிலான தெரிவுநிலை மரபு** (Go-க்கு தனிப்பட்டவை), **மூல்য சொற்பொருள்** (ஒதுக்கு நகல் — எனவே பகிர்ந்து கொள்ள/மாற்ற சுட்டிகளைப் பயன்படுத்தவும், பொதுவான குறைவு), மூல்য மற்றும் சுட்டி பெறுப்பாளர்களுடன் முறைகள், மற்றும் struct குறிச்சொற்கள் (JSON/DB மேப்பிங்கிற்கு) கிட்டத்தட்ட அனைத்து Go குறியீட்டிற்கும் அடிப்படை ஆகும்.

Struct-குள் எல்லா இடங்களிலும் தோன்றுகிறது — களம் மாதிரிகள், கட்டமைப்பு, API சொல்லுதல், தரவு கட்டமைப்புகள் — அவற்றை Go-வில் திறனுடன் பணிபுரிவதற்கான அத்யாவசிய, அன்றாட அறிவாக மாற்றுகிறது.