आप variables को कैसे declare करते हैं और Go के मूल types क्या हैं?

Question

Accepted Answer

Go statically typed है और variables को declare करने के कई तरीके हैं। सबसे आम तरीका **short declaration** `:=` है, जो type को infer करता है। Go के मूल types में numbers, strings, booleans, और अन्य बहुत कुछ शामिल है।

## Variables declare करना

```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)
```

`:=` function के अंदर idiomatic तरीका है — type inference के साथ concise। `var` को package level पर use किया जाता है और जब आप explicit type या sirf zero value चाहते हैं।

## Basic types

```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
```

## Zero values — कोई "uninitialized" variables नहीं

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

Go की एक महत्वपूर्ण विशेषता: प्रत्येक declared variable को automatically एक sensible **zero value** मिलता है — कोई undefined/garbage values नहीं हैं। यह code को सुरक्षित बनाता है और आप अक्सर explicit initialization को skip कर सकते हैं।

## Type conversions explicit हैं

```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 **explicit** type conversions की requirement करता है — यह कभी भी implicitly types को mix नहीं करता, जो subtle bugs की एक class को prevent करता है।

## यह क्यों महत्वपूर्ण है

Go के variable declarations और types को समझना कोई भी Go लिखने के लिए fundamental है।

Idiomatic short declaration `:=` inference के साथ code को concise रखता है, जबकि `var` और constants अपनी roles निभाते हैं।

**Zero-value guarantee** (हर variable safely initialize होता है) Go की एक distinctive, महत्वपूर्ण विशेषता है जो uninitialized-variable bugs को eliminate करती है और idiomatic patterns को shape करती है (उदाहरण के लिए, zero-valued struct अक्सर usable है)।

और Go का **explicit type conversions** पर insistence (कोई implicit coercion नहीं) एक deliberate safety choice है जो silent numeric bugs को prevent करता है जो अन्य languages allow करती हैं।

Basic types को जानना (खासतौर पर Unicode के लिए `rune`, `byte`, और कि `int`/`float64` defaults हैं) essential everyday knowledge है।