பூஜ்ஜிய மதிப்பு மற்றும் வகை மாற்றங்கள்

Go இல் வெளிப்படையான மதிப்பு இல்லாமல் அறிவிக்கப்பட்ட ஒவ்வொரு மாறியும் a பெறுகிறது பூஜ்ஜிய மதிப்பு: அதன் வகையின் "நடுநிலை மதிப்பு". இது ஒரு பெரிய வித்தியாசம் JavaScript இலிருந்து, 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 இல்லை.
• Slice/map/chan/func/interface/pointer இல் பூஜ்ஜிய மதிப்பு உள்ளது nil.
• எண் மாற்றங்கள் எப்போதும் type(value) உடன் வெளிப்படையாக இருக்கும்.
• int(float) பூஜ்ஜியத்தை நோக்கி துண்டிக்கப்படுகிறது; சுற்று உபயோகத்திற்கு math.Round.
• சரம் ↔ எண்ணுக்கு strconv தொகுப்பைப் பயன்படுத்தவும் (நேரடியான நடிகர் அல்ல).