వేరియబుల్స్ మరియు రకాలు

గోలో ప్రతి వేరియబుల్ కంపైలర్‌కు తెలిసిన స్టాటిక్ రకంని కలిగి ఉంటుంది: ఒకసారి ప్రకటించబడింది, వేరియబుల్ రకాన్ని మార్చదు. ఈ దృఢత్వం - చాలా భిన్నమైనది జావాస్క్రిప్ట్ లేదా పైథాన్ నుండి — కంపైల్-టైమ్ పొందడానికి మీరు చెల్లించే ధర రన్‌టైమ్ వాటికి బదులుగా లోపాలు, చిన్న బైనరీలు మరియు ఊహించదగినవి పనితీరు.

డిక్లరేషన్ యొక్క రెండు రూపాలు

var స్పష్టమైన రకంతో

var name string = "Ada"
var age int = 36
var active bool

మీరు విలువను వదిలివేసినప్పుడు (var active boolలో వలె) వేరియబుల్ స్వీకరిస్తుంది సున్నా విలువ దాని రకం — మేము తదుపరి పాఠంలో దీనికి తిరిగి వస్తాము.

సంక్షిప్త ప్రకటన :=

ఫంక్షన్‌లో మీరు :=ని ఉపయోగించవచ్చు, ఇది రకాన్ని ఊహించింది కుడి వైపున వ్యక్తీకరణ. ఇది ఇడియోమాటిక్ రూపం మరియు మీరు ఉపయోగించేది 90% సమయం:

name := "Ada"   // string
age := 36        // int
pi := 3.14       // float64
active := true   // bool

మీరు వెంటనే కలుసుకునే ప్రాథమిక రకాలు

int8/16/32/64, uint8/16/32/64, float32 మరియు complex64/128 కూడా ఉన్నాయి మీకు ఖచ్చితమైన పరిమాణాలు అవసరమైనప్పుడు (బైనరీ పార్సింగ్, ఇంటరాప్, మొదలైనవి).

బహుళ ప్రకటనలు

మీరు var-బ్లాక్ లేదా బహువచనం :=తో అనేక వేరియబుల్‌లను ప్రకటించవచ్చు:

var (
    name   string = "Ada"
    age    int    = 36
    active bool
)

x, y := 10, 20
a, b, c := "a", 2, true   // different types: no problem

వేరియబుల్స్ ప్రకటించబడ్డాయి కానీ ఉపయోగించబడలేదు

గో అనేది కఠినమైనది: వేరియబుల్ ప్రకటించబడింది మరియు ఎప్పుడూ ఉపయోగించని అనేది సంకలనం లోపం, హెచ్చరిక కాదు. ఇది ఉపయోగించని importsకి వర్తిస్తుంది.

func main() {
    x := 42
    // error: x declared and not used
}

నియమాన్ని తాత్కాలికంగా నిశ్శబ్దం చేయడానికి మీరు _ (ఖాళీ ఐడెంటిఫైయర్):

_ = x

మీ వంతు

// (a)
var name string = "Ada"

// (b)
age := 36

// (c)
const PI = 3.14

రీక్యాప్

• స్టాటిక్ రకం, స్వయంచాలకంగా := ద్వారా ఊహించబడింది లేదా varతో ప్రకటించబడింది.
• := ఫంక్షన్‌ల లోపల మాత్రమే; ప్యాకేజీ స్థాయిలో మాత్రమే var/const.
• ఉపయోగించని వేరియబుల్స్ మరియు దిగుమతులు = కంపైలేషన్ లోపం: వాటిని నిశ్శబ్దం చేయడానికి _ని ఉపయోగించండి.
• int/float64/string/bool రోజువారీ కేసుల్లో 90% కవర్ చేస్తుంది.