तपाईले चर कसरी घोषणा गर्नुहुन्छ र 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 को **स्पष्ट प्रकार रूपान्तरणहरू** (कुनै निहित जबरदस्ती छैन) मा जोर एक ध्वस्त सुरक्षा छनौट हो जसले चुप सांख्यिक बगहरूलाई रोकिन्छ जु अन्य भाषाहरूले अनुमति दिन्छन्।

आधारभूत प्रकारहरू (विशेष गरी `rune` यूनिकोडको लागि, `byte`, र यो `int`/`float64` पूर्वनिर्धारितहरू हुन्) को ज्ञान आवश्यक दैनिक ज्ञान हो।