మీరు వేరియబుల్‌లను ఎలా డిక్లేర్ చేస్తారు మరియు Go యొక్క ప్రాథమిక రకాలు ఏవి?

Question

Accepted Answer

Go స్టాటిక్‌గా టైప్ చేయబడింది మరియు వేరియబుల్‌లను డిక్లేర్ చేయడానికి అనేక మార్గాలు ఉన్నాయి. అత్యంత సాధారణమైనది **short declaration** `:=`, ఇది టైప్‌ను inferr చేస్తుంది. 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)
```

`:=` ఫంక్షన్-లోపల ఆలోచనాత్మక మార్గం — టైప్ inference తో సంక్షిప్తమైనది. `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
```

## జీరో విలువలు — "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 విలువలు లేవు. ఇది కోడ్‌ను సురక్షితమైనదిగా చేస్తుంది మరియు మీరు తరచుగా స్పష్టమైన ఇనిషియలైజేషన్ స్కిప్ చేయవచ్చని అర్థం.

## టైప్ కన్‌వర్షన్‌లు స్పష్టమైనవి

```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** టైప్ కన్‌వర్షన్‌లను చేస్తుంది — ఇది ఎప్పుడూ అవ్యక్తంగా రకాలను మిక్స్ చేయదు, సూక్ష్మ బగ్‌ల శ్రేణిని నివారిస్తుంది.

## ఇది ఎందుకు ముఖ్యమైనది

Go యొక్క వేరియబుల్ డిక్లరేషన్‌లు మరియు రకాలను అర్థం చేసుకోవడం ఏదైనా Go రాయడానికి ప్రాథమికమైనది.

इडिയમетిक `:=` short declaration with inference కోడ్‌ను సంక్షిప్తమైనదిగా ఉంచుతుంది, అయితే `var` మరియు constants వాటి పాత్రలను కలిగి ఉంటాయి.

**zero-value guarantee** (ప్రతి వేరియబుల్ సురక్షితంగా ఇనిషియలైజ్ చేయబడిందని) Go యొక్క విలక్షణమైన, ముఖ్యమైన ఫీచర్, ఇది uninitialized-variable బగ్‌లను తొలగిస్తుంది మరియు ఆలోచనాత్మక నమూనాలను ఆకారమిస్తుంది (ఉదాహరణకు, zero-valued struct తరచుగా ఉపయోగ సాధ్యమైనది).

And Go **explicit type conversions** (no implicit coercion) పై నొక్కిලో ఉండటం ఆశయమైన సురక్షత ఎంపిక, ఇది ఇతర భాషలు అనుమతించే నిస్సందేహ సంఖ్యా బగ్‌ల రకాలను నివారిస్తుంది.

ప్రాథమిక రకాలను తెలుసుకోవడం (ముఖ్యంగా Unicode కోసం `rune`, `byte`, మరియు `int`/`float64` డిఫాల్ట్‌లు) ఆవశ్యక రోజువారీ జ్ఞానం.