స్ట్రింగర్ ఇంటర్‌ఫేస్

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) (ఒక విలువ)తో, Go T పద్ధతిని చూస్తుంది, దానిని కనుగొనలేదు మరియు డిఫాల్ట్ ఆకృతిని ఉపయోగిస్తుంది. దీన్ని నివారించడానికి, ** విలువ రిసీవర్** సాధారణంగా String() కోసం ఉపయోగించబడుతుంది (ఇది "వీక్షణ"; అది కాదు ఏదైనా సవరించండి).

దీనిని ప్రయత్నించండి

func (x T) ??? {}

రీక్యాప్

• fmt.Stringer = interface { String() string }.
• దీన్ని అమలు చేయడం వలన fmt.Print* రకాన్ని ఎలా సూచిస్తుందో మారుతుంది.
• enums కోసం ఇడియోమాటిక్ (iota), డొమైన్ రకాలు, కోడ్‌లు/ఐడెంటిఫైయర్‌లు.
• tలో fmt.Sprintf("%s", t)కి String() లోపల ఎప్పుడూ కాల్ చేయవద్దు (పునరావృతం).
• కన్వెన్షన్: String() కోసం విలువ రిసీవర్ (మ్యుటేషన్ లేదు, "పద్ధతి-సెట్ సర్ప్రైజ్‌లను" నివారిస్తుంది).