అధునాతన `fmt`

fmt ప్యాకేజీ అనేది Goలోని అన్ని వచన I/Oలకు గేట్‌వే. దీన్ని బాగా తెలుసుకోవడం అంటే చదవగలిగే లాగ్‌లు, ఇన్ఫర్మేటివ్ ఎర్రర్‌లు మరియు బాహ్య లైబ్రరీలను ఆశ్రయించకుండా ఇడియోమాటిక్‌గా విలువలను ఫార్మాటింగ్ చేయడం.

నాలుగు కుటుంబాలు

fmt నాలుగు కుటుంబాలలోని విధులను బహిర్గతం చేస్తుంది, ఉపసర్గ ద్వారా వేరు చేయబడుతుంది:

• Print* → **os.Stdout**కి వ్రాస్తుంది (Print, Println, Printf).
• Fprint* → ఏదైనా io.Writer (Fprintln(os.Stderr, ...), Fprintf(file, ...))కి వ్రాస్తుంది.
• Sprint* → ముద్రించకుండానే స్ట్రింగ్ని అందిస్తుంది (Sprintf, Sprintln).
• Errorf → ఆకృతీకరించిన **error**ని రూపొందిస్తుంది.

fmt.Println("hello")                       // stdout
fmt.Fprintln(os.Stderr, "boom")            // stderr
s := fmt.Sprintf("[%d]", 42)               // "[42]"
err := fmt.Errorf("parse %q: %w", in, base) // wrapped error

Print మరియు Println మధ్య వ్యత్యాసం కేవలం ** ఆర్గ్యుమెంట్‌లు మరియు వెనుకంజలో ఉన్న కొత్తలైన్ మధ్య ఖాళీ మాత్రమే**: Println ఎల్లప్పుడూ \nని జోడిస్తుంది, _AGYTOK_INLINE_TO_20_INLINE కాదు ఆకృతిని అనుసరిస్తుంది.

ప్రధాన క్రియలు

type Point struct{ X, Y int }
p := Point{1, 2}
fmt.Printf("%v\n", p)   // {1 2}
fmt.Printf("%+v\n", p)  // {X:1 Y:2}
fmt.Printf("%#v\n", p)  // main.Point{X:1, Y:2}
fmt.Printf("%T\n", p)   // main.Point

వెడల్పు, ఖచ్చితత్వం, జెండాలు

సంఖ్యా మరియు స్ట్రింగ్ క్రియలు వెడల్పు మరియు ** ఖచ్చితత్వం**:

• %6d → కనిష్ట వెడల్పు 6, ఖాళీలతో ఎడమ పాడింగ్.
• %-6d → వెడల్పు 6, కుడి పాడింగ్ (ఫ్లాగ్ -).
• %06d → వెడల్పు 6, 0తో ప్యాడింగ్ (ఫ్లాగ్ 0).
• %.2f → ఖచ్చితత్వం 2 దశాంశ అంకెలు.
• %8.2f → వెడల్పు 8, ఖచ్చితత్వం 2.

fmt.Printf("|%6d|\n", 42)    // |    42|
fmt.Printf("|%-6d|\n", 42)   // |42    |
fmt.Printf("|%06d|\n", 42)   // |000042|
fmt.Printf("|%8.2f|\n", 3.14)// |    3.14|

సమలేఖనం చేయబడిన పట్టికల కోసం, వచన నిలువు వరుసల కోసం స్థిర వెడల్పు + %-...s text/tabwriterకి తరలించడానికి ముందు సరళమైన నమూనా.

%w మరియు లోపం చుట్టడం

%w ప్రత్యేకమైనది: ఇది ** fmt.Errorf** లోపల మాత్రమే పని చేస్తుంది మరియు గొలుసులో అసలైన లోపాన్ని భద్రపరుస్తుంది, తద్వారా errors.Is మరియు errors.As దానిని నడపగలరు.

if _, err := os.Open(path); err != nil {
    return fmt.Errorf("read config %q: %w", path, err)
}

%wకి బదులుగా %vని ఉపయోగించడం వలన దోష సందేశాన్ని ముద్రిస్తుంది కానీ గొలుసును విచ్ఛిన్నం చేస్తుంది: అన్‌ర్యాప్ లేదు, errors.Is. నియమం: కాలర్ ఎర్రర్ యొక్క రకాన్ని లేదా గుర్తింపును గుర్తించగలగాలి అని మీరు కోరుకుంటే, %w (Errorfకి ఒకటి మాత్రమే) ఉపయోగించండి.

వ్యాయామాలు

err := fmt.Errorf("read %q: ???", path, base)