ਤੁਸੀਂ ਵੇਰੀਏਬਲਜ਼ ਦੀ ਘੋਸ਼ਣਾ ਕਿਵੇਂ ਕਰਦੇ ਹੋ ਅਤੇ Go ਦੀਆਂ ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਕੀ ਹਨ?

Question

Accepted Answer

Go ਇੱਕ statically typed ਭਾਸ਼ਾ ਹੈ ਜਿਸ ਵਿੱਚ ਵੇਰੀਏਬਲਜ਼ ਦੀ ਘੋਸ਼ਣਾ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ। ਸਭ ਤੋਂ ਆਮ **short declaration** `:=` ਹੈ, ਜੋ ਕਿ ਕਿਸਮ ਨੂੰ infer ਕਰਦਾ ਹੈ। Go ਦੀਆਂ ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਨੰਬਰਾਂ, strings, booleans ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਕਵਰ ਕਰਦੀਆਂ ਹਨ।

## ਵੇਰੀਏਬਲਜ਼ ਦੀ ਘੋਸ਼ਣਾ

```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 ਦੇ ਨਾਲ ਸੰਖੇਪ। `var` package level ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਸਪੱਸ਼ਟ ਕਿਸਮ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਸਿਰਫ਼ zero value ਚਾਹੁੰਦੇ ਹੋ।

## ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ

```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" ਵੇਰੀਏਬਲਜ਼ ਨਹੀਂ

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

Go ਦੀ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ੇਸ਼ਤਾ: ਹਰ ਘੋਸ਼ਿਤ ਵੇਰੀਏਬਲ ਆਪਣੇ ਆਪ ਹੀ ਇੱਕ ਸਮਝਦਾਰੀ **zero value** ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ — ਕੋਈ undefined/garbage values ਨਹੀਂ ਹੁੰਦੀਆਂ। ਇਹ ਕੋਡ ਨੂੰ ਸੁਰੱਖਿਅਤ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਅਕਸਰ ਸਪੱਸ਼ਟ ਸ਼ੁਰੂਆਤ ਨੂੰ ਛੱਡ ਸਕਦੇ ਹੋ।

## Type conversions ਸਪੱਸ਼ਟ ਹਨ

```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 ਦੀ ਲੋੜ ਹੈ — ਇਹ ਕਦੇ implicit ਤੌਰ 'ਤੇ ਕਿਸਮਾਂ ਨੂੰ ਮਿਕਸ ਨਹੀਂ ਕਰਦਾ, ਜੋ ਸੂਖਮ bugs ਦੀ ਇੱਕ ਸ਼੍ਰੇਣੀ ਨੂੰ ਰੋਕਦਾ ਹੈ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Go ਦੀਆਂ ਵੇਰੀਏਬਲ ਘੋਸ਼ਣਾਵਾਂ ਅਤੇ ਕਿਸਮਾਂ ਨੂੰ ਸਮਝਣਾ ਕਿਸੇ ਵੀ Go ਨੂੰ ਲਿਖਣ ਲਈ ਮੁਲ਼ਤਵੀ ਹੈ।

Idiomatic `:=` short declaration with inference ਕੋਡ ਨੂੰ ਸੰਖੇਪ ਰੱਖਦਾ ਹੈ, ਜਦੋਂ ਕਿ `var` ਅਤੇ constants ਆਪਣੀਆਂ ਭੂਮਿਕਾਵਾਂ ਨਿਭਾਉਂਦੇ ਹਨ।

**Zero-value guarantee** (ਹਰ ਵੇਰੀਏਬਲ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ) Go ਦੀ ਇੱਕ ਵਿਸ਼ਿਸ਼ਟ, ਮਹੱਤਵਪੂਰਨ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜੋ uninitialized-variable bugs ਨੂੰ ਖ਼ਤਮ ਕਰਦੀ ਹੈ ਅਤੇ idiomatic ਪੈਟਰਨਸ ਨੂੰ ਆਕਾਰ ਦਿੰਦੀ ਹੈ (ਉਦਾ: ਇੱਕ zero-valued struct ਅਕਸਰ ਵਰਤੋਂ ਲਈ ਤਿਆਰ ਹੁੰਦਾ ਹੈ)।

ਅਤੇ Go ਦਾ **explicit type conversions** (implicit coercion ਨਹੀਂ) ਦਾ ਜ਼ੋਰ ਇੱਕ ਜਾਣਬੁੱਝ ਕੇ ਕੀਤਾ ਸੁਰੱਖਾ ਚੋਣ ਹੈ ਜੋ silent numeric bugs ਦੀ ਉਸ ਕਿਸਮ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੋ ਦੂਸਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹਨ।

ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਨੂੰ ਜਾਣਨਾ (ਖਾਸ ਤੌਰ 'ਤੇ `rune` Unicode ਲਈ, `byte`, ਅਤੇ ਇਹ ਕਿ `int`/`float64` defaults ਹਨ) ਹਰ ਰੋਜ਼ ਜਾਣਕਾਰੀ ਹੈ।