તમે ચલોને કેવી રીતે જાહેર કરો છો અને 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` ડિફોલ્ટ છે) જ્ઞાન જાણવું આવશ્યક રોજિંદું જ્ઞાન છે.