Go-இல் மாறிகளை எவ்வாறு அறிவிப்பீர்கள் மற்றும் Go-ன் அடிப்படை வகைகள் யாவை?

Question

Accepted Answer

Go ஆனது நிலையான வகை மொழி (statically typed) மற்றும் மாறிகளை அறிவிக்க பல வழிகளைக் கொண்டுள்ளது. மிகவும் பொதுவான வழி **குறுகிய அறிவிப்பு** `:=` ஆகும், இது வகையைக் கொண்டு தீர்மானிக்கிறது. Go-ன் அடிப்படை வகைகள் எண்கள், சரங்கள், பூலியன்கள் மற்றும் பலவற்றை உள்ளடக்கியுள்ளது.

## மாறிகளை அறிவிப்பது

```go
var x int = 42        // full form: explicit type and value
var y = 42            // type inferred → int
var z int             // declared, ZERO-valued (z = 0)

name := "Ann"         // short declaration (:=) — infers type, INSIDE functions only
count := 10

var a, b = 1, "two"   // multiple at once
const Pi = 3.14159     // constant (compile-time)
```

`:=` என்பது செயல்பாட்டிற்குள் இருக்கும் சுவரொளி நির்ணய வழி — வகை அனுமানத்துடன் சிறிய அளவிலான. `var` என்பது தொகுப்பு நிலையில் மற்றும் நீங்கள் வெளிப்படையான வகை அல்லது பூஜ்ய மதிப்பை விரும்பும்போது பயன்படுத்தப்படுகிறது.

## அடிப்படை வகைகள்

```go
// integers
int, int8, int16, int32, int64     // signed (int is platform-sized, usually 64-bit)
uint, uint8, ..., uint64           // unsigned
byte                                // alias for uint8
rune                                // alias for int32 — a Unicode code point

// floating point
float32, float64                    // float64 is the default for decimals

// others
string                              // immutable UTF-8 text
bool                               // true / false
complex64, complex128              // complex numbers
```

## பூஜ்ய மதிப்புகள் — "ஆரம்ப நிலையில் இல்லாத" மாறிகள் இல்லை

```go
var i int       // 0
var f float64   // 0.0
var s string    // "" (empty)
var b bool      // false
var p *int      // nil
```

முக்கியமான Go அம்சம்: ஒவ்வொரு அறிவிக்கப்பட்ட மாறியும் தானாகவே ஒரு நியாயமான **பூஜ்ய மதிப்பு** பெறுகிறது — வரையறுக்கப்படாத/குப்பை மதிப்புகள் இல்லை. இது குறியீட்டை பாதுகாப்பாக செய்கிறது மற்றும் நீங்கள் பெரும்பாலும் வெளிப்படையான ஆரம்ப நிலையை தவிர்க்கலாம் என்று அர்థம்.

## வகை மாற்றங்கள் வெளிப்படையாக இருக்கும்

```go
var i int = 42
var f float64 = float64(i)   // MUST convert explicitly — no implicit coercion
var u uint = uint(f)
// i + f  → ❌ compile error: mismatched types
```

Go **வெளிப்படையான** வகை மாற்றங்களைக் கோரும் — இது ஒருபோதும் வகைகளை மறைமுகமாக கலக்காது, நுட்பமான பிழைகளின் ஒரு வகுப்பைத் தடுக்கிறது.

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

Go-ன் மாறி அறிவிப்புகள் மற்றும் வகைகளைப் புரிந்துகொள்வது எந்த Go உதாரணத்தையும் எழுதுவதற்கு அடிப்படையாகும்.

யுক்তியுடையான `:=` குறுகிய அறிவிப்பு அனுமானத்துடன் குறியீட்டை சிறிய அளவில் வைத்திருக்கிறது, `var` மற்றும் மாறிலிகள் அவற்றின் பங்குகளை பூர்த்தி செய்கின்றன.

**பூஜ்ய-மதிப்பு உத்தரவாদம்** (ஒவ்வொரு மாறியும் பாதுகாப்பாக ஆரம்ப நிலையில் உள்ளது) என்பது ஒரு தனித்துவமான, முக்கியமான Go அம்சம் ஆகும், இது ஆரம்ப நிலையில் இல்லாத-மாறி பிழைகளை நீக்குகிறது மற்றும் சுவரொளி வடிவங்களை வடிவமைக்கிறது (எ.கா. பூஜ்ய-மதிப்பு கட்டமைப்பு பெரும்பாலும் பயன்படுத்தக்கூடியது).

மற்றும் Go-ன் **வெளிப்படையான வகை மாற்றங்களில்** (மறைமுக கோér்லெசன் இல்லை) வல்லுறுவு என்பது ஒரு விவேக நிரலாக்க தேர்வு ஆகும், இது மறைமுகமான எண் பிழைகளைத் தடுக்கிறது, மற்ற மொழிகள் அனுமதிக்கின்றன.

அடிப்படை வகைகளைத் தெரிந்துகொள்வது (குறிப்பாக `rune` யூனிகோட்டிற்காக, `byte`, மற்றும் `int`/`float64` இயல்புநிலைகள் என்பவை) தினசரி உதாரணமான அறிவு ஆகும்.