तुम्ही व्हेरिएबल्स कसे घोषित करता आणि Go चे मूलभूत प्रकार कोणते आहेत?

Question

Accepted Answer

Go हा स्टॅटिक्‍ली टाइप केलेला असून व्हेरिएबल्स घोषित करण्याचे अनेक मार्ग आहेत. सर्वात सामान्य म्हणजे **शॉर्ट डिक्‍लेरेशन** `:=`, जो प्रकार अनुमान लावतो. 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 चे एक वेगळे, महत्त्वाचे वैशिष्ट्य आहे जे अनिर्मित-व्हेरिएबल बग्‍स दूर करते आणि मूर्खमत्तापूर्ण पॅटर्न्‍सचे रूप घटवते (उदा. शून्य-मूल्य struct बहुतेकदा वापरण्यायोग्य असतो).

आणि Go चा **स्पष्ट प्रकार परिवर्तन** (कोणतेही निमज्जित जबरदस्ती नाही) वर जोर हा एक जाणीव सुरक्षा निवड आहे जो इतर भाषांना परवानगी असलेल्या शांत संख्यात्मक बग्‍स प्रतिबंधित करतो.

मूलभूत प्रकार (विशेषतः Unicode साठी `rune`, `byte`, आणि `int`/`float64` हे डिफॉल्ट आहेत) हे आवश्यक दैनंदिन ज्ञान आहे.