ஸ்ட்ரிங்கர் இடைமுகம்

fmt.Stringer எல்லாவற்றிலும் அதிகம் பயன்படுத்தப்படும் நிலையான இடைமுகம் கோவின் நிலையான நூலகம். இது சக்தியின் சரியான நிரூபணம் சிறிய இடைமுகங்கள்.

வரையறை

type Stringer interface {
    String() string
}

ஒரே கையெழுத்து. String() string ஐ வரையறுக்கும் எந்த வகையும் திருப்தி அளிக்கிறது அது. மேலும் fmt இந்த இடைமுகத்தை அங்கீகரிக்கிறது: நீங்கள் ஒரு மதிப்பை அனுப்பும்போது fmt.Print*, Stringerஐச் செயல்படுத்தினால், String() இன் முடிவு இயல்புநிலை பிரதிநிதித்துவத்திற்கு பதிலாக பயன்படுத்தப்படுகிறது.

உதாரணம்

type Point struct{ X, Y int }

func (p Point) String() string {
    return fmt.Sprintf("(%d,%d)", p.X, p.Y)
}

fmt.Println(Point{1, 2})              // (1,2)
fmt.Printf("%v %s\n", Point{3, 4}, Point{5, 6})
// (3,4) (5,6)

%v, %s, Println இல் தனிப்பயன் வடிவமைப்புடன் அதே மதிப்பு அச்சிடப்படுகிறது. Sprint, log, முதலியன அனைத்தும் ஒரு முறையை வரையறுப்பதன் மூலம்.

அது அர்த்தமுள்ளதாக இருக்கும் போது

• ஒரு டொமைனை மாதிரியாகக் கொண்ட வகைகள் (ஐடிகள், குறியீடுகள், ஆயத்தொலைவுகள், கணக்கீடுகள்).
• மனிதர்கள் படிக்கக்கூடிய பிரதிநிதித்துவத்தில் பிழைகள் (error இல் அடுத்த பாடத்தைப் பார்க்கவும்).
• நீங்கள் அடிக்கடி உள்நுழையும் வகைகள் மற்றும் நீங்கள் ஒரு நிலையான வடிவமைப்பை விரும்புகிறீர்கள்.

எல்லாவற்றிற்கும் அல்ல: வகை எளிமையானது மற்றும் இயல்புநிலை பிரதிநிதித்துவம் என்றால் நன்றாக இருக்கிறது, சத்தம் சேர்க்க வேண்டாம்.

எனம் வகைகள்: iota உடன் பொதுவான முறை

type Status int

const (
    OK Status = iota
    WARN
    ERR
)

func (s Status) String() string {
    switch s {
    case OK:   return "OK"
    case WARN: return "WARN"
    case ERR:  return "ERR"
    default:   return "UNKNOWN"
    }
}

fmt.Println(OK, WARN, ERR)   // OK WARN ERR

String() இல்லாமல், fmt.Println(OK) 0 ஐ அச்சிடும். String() உடன், இது குறியீட்டு பெயரை அச்சிடுகிறது. stringer கருவி தானாகவே இந்த வடிவத்தை உருவாக்குகிறது.

எல்லையற்ற மறுநிகழ்வைக் கவனியுங்கள்

type T int
func (t T) String() string {
    return fmt.Sprintf("%d", int(t))  // OK: cast to int breaks the recursion
}

ஒரு பாயிண்டர் ரிசீவரில் ஸ்ட்ரிங்கர்

String()க்கு பாயிண்டர் ரிசீவர் இருந்தால், *T மட்டுமே Stringer ஐ திருப்திப்படுத்துகிறது. fmt.Println(t) (ஒரு மதிப்பு) உடன், T இன் முறை தொகுப்பைப் பார்க்கிறது, அதைக் கண்டுபிடிக்கவில்லை, மேலும் இயல்புநிலை வடிவமைப்பைப் பயன்படுத்துகிறது. இதைத் தவிர்க்க, மதிப்பு ரிசீவர் பொதுவாக String()க்கு பயன்படுத்தப்படுகிறது (இது ஒரு "பார்வை"; அது இல்லை எதையும் மாற்றவும்).

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

func (x T) ??? {}

மறுபரிசீலனை

• fmt.Stringer = interface { String() string }.
• அதைச் செயல்படுத்துவது fmt.Print* வகையை எவ்வாறு குறிக்கிறது என்பதை மாற்றுகிறது.
• enums (iota), டொமைன் வகைகள், குறியீடுகள்/அடையாளங்காட்டிகளுக்கான இடியோமேடிக்.
• t இல் String() இல் fmt.Sprintf("%s", t) ஐ அழைக்க வேண்டாம் (மறுநிகழ்வு).
• கன்வென்ஷன்: String() க்கான மதிப்பு பெறுதல் (பிறழ்வு இல்லை, "முறை-செட் ஆச்சர்யங்களை" தவிர்க்கிறது).