முக்கிய உள்ளடக்கத்திற்குச் செல்லவும்
தொகுதி 6 · பாடம் 2 இன் 5பாடத்திட்டத்தில் 27/50~10 min
தொகுதி பாடங்கள் (2/5)

வலியுறுத்தல் வகை

ஒரு வகை வலியுறுத்தல் ஒரு இடைமுக மதிப்பிலிருந்து கான்கிரீட் வகையைப் பிரித்தெடுக்கிறது. உங்களிடம் interface{} (அல்லது "உயர்" இடைமுகம்) இருக்கும்போது உங்களுக்கு இது தேவைப்படும் கை மற்றும் புலங்களை அணுகுவதற்கு அதன் குறிப்பிட்ட வகையாக கருத வேண்டும் அல்லது இடைமுகத்தில் இல்லாத முறைகள்.

தொடரியல்

Go
var i interface{} = "ciao"

s := i.(string)           // "panic" form: panics if it's not a string
s, ok := i.(string)       // "comma ok" form: ok = false if it's not a string

இரண்டு வடிவங்கள், இரண்டு சொற்பொருள்:

படிவம்வெற்றிதோல்வி
v := i.(T)v = T வகையின் மதிப்புஇயக்க நேரத்தில் பீதி
v, ok := i.(T)v=..., ok=truev = T இன் பூஜ்ஜிய மதிப்பு, ok=false

"கமா சரி" படிவம்: பாதுகாப்பானது

Go
var i interface{} = 42

if s, ok := i.(string); ok {
    fmt.Println("è stringa:", s)
} else {
    fmt.Println("non è stringa, ignoro")
}

ok பீதியின்றி "தவறான வகை" வழக்கைக் கையாள உங்களை அனுமதிக்கிறது. அது பெரும்பாலான சந்தர்ப்பங்களில் idiomatic pattern.

ஒரு இடைமுகத்திற்கான வலியுறுத்தல்

உறுதியான வகைகளில் மட்டும் வேலை செய்யாது, ஆனால் மற்றவற்றிலும் இடைமுகங்கள்:

Go
type Closer interface { Close() error }

func tryClose(x interface{}) {
    if c, ok := x.(Closer); ok {
        c.Close()
    }
}

நிலையான நூலகத்தில் மிகவும் பொதுவான வடிவம்: "என் உள்ளீடும் இருந்தால் ஒரு io.Closer, முடிவில் மூடு என்று அழைக்கவும்".

சுட்டிகள் vs மதிப்புகள் மீதான கூற்று

வலியுறுத்தல் டைனமிக் வகையுடன் சரியாகப் பொருந்த வேண்டும்:

Go
type Cat struct{}
func (c *Cat) Meow() {}

var a interface{} = &Cat{}

c1, ok := a.(*Cat)   // ok = true
c2, ok := a.(Cat)    // ok = false: it holds *Cat, not Cat

*Cat மற்றும் Cat ஆகியவை வகை அமைப்புக்கான தனித்துவமான வகைகள்.

வலியுறுத்தல் மற்றும் வகை சுவிட்சை எப்போது பயன்படுத்த வேண்டும்

  • ஒரே 1 சாத்தியமான வகை, "feature-detect" சரிபார்ப்பு (எ.கா. விருப்ப இடைமுகத்திற்கு அனுப்பப்பட்டது): வகை வலியுறுத்தல் comma ok உடன்.
  • 2+ சாத்தியமான வகைகள், பல கிளைகளுக்கு அனுப்புதல்: வகை சுவிட்ச் (அடுத்த பாடம்).

முயற்சி செய்து பாருங்கள்

உடற்பயிற்சி#go.m6.l2.e1
முயற்சிகள்: 0ஏற்றுகிறது…

i இலிருந்து ஒரு சரத்தைப் பிரித்தெடுக்க கமா சரி வடிவத்தைப் பயன்படுத்தவும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

தொடரியல்: `v, ok := i.(T)`.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

உடற்பயிற்சி#go.m6.l2.e2
முயற்சிகள்: 0ஏற்றுகிறது…

கமா சரி இல்லாமல் int என உறுதிமொழியைத் தட்டச்சு செய்க (நான் ஒரு முழு எண்ணைக் கொண்டுள்ளது என்று வைத்துக்கொள்வோம்).

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

`சரி` இல்லாமல், வகை உறுதியாக இருக்கும் என்று கருதுகிறீர்கள்; இல்லையெனில் பீதி.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

Quiz#go.m6.l2.e3
தயார்

நான் ஒரு எண்ணைக் கொண்டிருந்தால் `s := i.(string)` உடன் என்ன நடக்கும்?

Go
var i interface{} = 42
s := i.(string)
பதில் விருப்பங்கள்

மறுபரிசீலனை

  • v := i.(T): டைனமிக் வகை ≠ T என்றால் பீதி.
  • v, ok := i.(T): பாதுகாப்பான முறை, ok.
  • மற்றொரு இடைமுகத்திற்கு எதிராகவும் செயல்படுகிறது ("அம்சம் கண்டறிதல்").
  • T மற்றும் *T ஆகியவை வலியுறுத்தலுக்கான தனித்துவமான வகைகள்.
  • 1 வகை → வலியுறுத்தல்; 2+ வகைகள் → வகை சுவிட்ச்.