సున్నా విలువ మరియు రకం మార్పిడులు

గోలో స్పష్టమైన విలువ లేకుండా ప్రకటించబడిన ప్రతి వేరియబుల్ a పొందుతుంది సున్నా విలువ: దాని రకం యొక్క "తటస్థ విలువ". ఇది చాలా పెద్ద తేడా జావాస్క్రిప్ట్ నుండి, ఇక్కడ let x; ఉత్పత్తి చేస్తుంది undefined, లేదా C, మీరు ముగించే చోట చెత్త జ్ఞాపకశక్తితో. కాదు undefined, UB లేదు: కేవలం సున్నా.

సున్నా విలువ పట్టిక

var i int        // 0
var f float64    // 0
var s string     // ""
var b bool       // false
var p *int       // nil
var nums []int   // nil  (NB: una slice nil ha len 0 e si può iterare!)

మార్పిడులు ఎల్లప్పుడూ స్పష్టంగా ఉంటాయి

C, Python లేదా JS కాకుండా, Go ** ఒకదానిని స్వయంచాలకంగా ప్రచారం చేయదు సంఖ్యా రకం మరొకదానికి: మీరు తప్పక type(value) అని వ్రాయాలి.

i := 42
var f float64 = float64(i)
var u uint = uint(i)

int మరియు int64 వంటి "అనుకూల" రకాలకు కూడా ఇది వర్తిస్తుంది: ఒక స్పష్టమైన మార్పిడి ఎల్లప్పుడూ అవసరం.

var a int = 10
var b int64 = int64(a)  // obbligatorio

సంఖ్యల మధ్య మార్పిడి: కత్తిరించడం కోసం చూడండి

float64 నుండి int సున్నా వైపు కుదించబడుతుంది, అది జరగదు రౌండ్:

f := 3.9
i := int(f)   // 3, non 4
n := int(-3.9) // -3, non -4

స్ట్రింగ్ ↔ సంఖ్య మార్పిడి

string(65) ఇవ్వదు "65": ఇది "A"ని ఇస్తుంది (కోడ్‌తో కూడిన రూన్ పాయింట్ 65). స్ట్రింగ్ → నంబర్ మరియు వైస్ వెర్సా కోసం మీకు strconv అవసరం ప్యాకేజీ:

import "strconv"

s := strconv.Itoa(42)        // "42"
n, err := strconv.Atoi("42") // 42, nil

మేము దానిని Stdlib మాడ్యూల్‌లో లోతుగా కవర్ చేస్తాము.

మీ వంతు

f := 3.7
fmt.Println(int(f))

రీక్యాప్

• ప్రతి రకానికి స్థిరమైన సున్నా విలువ ఉంటుంది: undefined లేదు, UB లేదు.
• స్లైస్/మ్యాప్/చాన్/ఫంక్/ఇంటర్‌ఫేస్/పాయింటర్ సున్నా విలువను కలిగి ఉంటాయి nil.
• సంఖ్యా మార్పిడులు ఎల్లప్పుడూ type(value)తో స్పష్టంగా ఉంటాయి.
• int(float) సున్నా వైపు కుదించబడుతుంది; పూర్తి వినియోగానికి math.Round.
• స్ట్రింగ్ ↔ నంబర్ కోసం strconv ప్యాకేజీని ఉపయోగించండి (ప్రత్యక్ష తారాగణం కాదు).