గోలో స్ట్రింగ్‌లను ఎలా ఫార్మాట్ చేయాలి

మీరు గో కోడ్‌ను వ్రాసేటప్పుడు, స్ట్రింగ్ ఫార్మాటింగ్ చాలా సందర్భాలలో చాలా ఉపయోగకరంగా ఉంటుంది. మీరు ఇన్‌పుట్‌లను అన్వయించవచ్చు లేదా సాధారణ సంయోగం కంటే సంక్లిష్టమైన అవుట్‌పుట్‌ను రూపొందించవచ్చు. మీరు సాదా స్ట్రింగ్స్ కాకుండా ఇతర రకాలతో పని చేస్తూ ఉండవచ్చు.

Goలో స్ట్రింగ్ ఫార్మాటింగ్ అనేది ప్రింట్‌ఎఫ్ ఫంక్షన్ యొక్క సుపరిచితమైన ప్రక్రియ మరియు సింటాక్స్‌ను ఉపయోగిస్తుంది, వీటిని జావా నుండి హాస్కెల్ వరకు భాషలు కూడా ఉపయోగిస్తాయి.

లో స్ట్రింగ్స్ ఫార్మాటింగ్ చేయడానికి గో వివిధ పద్ధతులను అందిస్తుంది fmt ప్యాకేజీ. మీరు ఫార్మాట్ చేయాలనుకుంటున్న ఆపరేషన్ లేదా ఇన్‌పుట్‌లను బట్టి స్ట్రింగ్ ఫార్మాటింగ్ కోసం మీరు ఫంక్షన్‌లు మరియు క్రియలను ఉపయోగించవచ్చు.

గోలో స్ట్రింగ్ ఫార్మాటింగ్

fmt ప్యాకేజీలోని విధులు ప్రతిరూపాల మాదిరిగానే ఉంటాయి బాష్‌లో printf ఫంక్షన్ లేదా C. Go దాని ఫార్మాటింగ్ క్రియలను C నుండి పొందింది.

మీరు వాడుతారు స్ట్రింగ్ ఫార్మాటింగ్ క్రియలు కలిగి ఉన్న స్ట్రింగ్‌లో మీ వేరియబుల్ విలువలకు ప్లేస్‌హోల్డర్‌లుగా. మీరు ఆ ఫార్మాటింగ్ స్ట్రింగ్‌ని వంటి ఫంక్షన్‌కి పాస్ చేయవచ్చు ప్రింట్ఎఫ్ , ఆ ప్లేస్‌హోల్డర్‌లకు సంబంధించిన విలువలతో పాటు.

మీరు స్ట్రింగ్ ఫార్మాటింగ్ క్రియలను దీనితో ఉపయోగించలేరు ముద్రణ మరియు Println పద్ధతులు. వంటి పద్ధతులతో మీరు వాటిని ఉపయోగించవచ్చు ప్రింట్ఎఫ్ మరియు స్ప్రింట్ఎఫ్ .

fmt.Println("This is a test %v", 90) 
fmt.Printf("This is a test %v", 90)

ది % లో క్రియ ఏదైనా విలువను దాని డిఫాల్ట్ ఆకృతిలో ముద్రిస్తుంది. ది Println పద్ధతి క్రియలను గుర్తించదు మరియు అది స్వీకరించే ఏవైనా వాదనలను ప్రింట్ చేస్తుంది. ది ప్రింట్ఎఫ్ మరియు స్ప్రింట్ఎఫ్ ఫంక్షన్‌లు రెండూ మీరు వారికి పంపే మొదటి స్ట్రింగ్ ఆర్గ్యుమెంట్‌ను ఫార్మాట్ చేస్తాయి.

fmt ప్యాకేజీలో స్ట్రింగ్ ఫార్మాటింగ్ విధులు

స్ట్రింగ్‌లను ఫార్మాట్ చేస్తోంది గో ప్రోగ్రామింగ్ భాష మీరు స్ట్రింగ్ ఫార్మాటింగ్ ఫంక్షన్ మరియు క్రియను ఉపయోగించాలి. ఫంక్షన్ ఆకృతీకరించిన స్ట్రింగ్‌ను అందిస్తుంది మరియు స్ట్రింగ్‌కు ఇన్‌పుట్‌ల కోసం క్రియలు ప్లేస్‌హోల్డర్‌లు.

ది ప్రింట్ఎఫ్ మెథడ్ ఫార్మాట్ స్పెసిఫైయర్ ప్రకారం ఇన్‌పుట్‌ను ఫార్మాట్ చేస్తుంది మరియు వ్రాసిన బైట్‌లు లేదా ఎర్రర్‌ల సంఖ్యను అందిస్తుంది.

fmt.Printf("This is a test %v", 90)

సాంప్రదాయకంగా, మీరు ఉపయోగించినప్పుడు లోపాల గురించి చింతించాల్సిన అవసరం లేదు ప్రింట్ఎఫ్ పద్ధతి.

క్రోమ్ రామ్ వినియోగాన్ని ఎలా పరిమితం చేయాలి

ది స్ప్రింట్ఎఫ్ మెథడ్ పేర్కొన్న ఫార్మాట్ ప్రకారం ఫార్మాట్ చేస్తుంది మరియు ఫలితాన్ని స్ట్రింగ్‌గా అందిస్తుంది.

var result = fmt.Sprintf("This is a test %v", 90)

ది Fprintf మెథడ్ స్ట్రింగ్‌ను ఫార్మాట్ చేస్తుంది మరియు దానిని రైటర్‌కి వ్రాస్తుంది (అమలు చేసే పద్ధతులు io.రచయిత ఇంటర్ఫేస్)

// write data to standard output 
result, err = fmt.Fprintf(writer, "This is a test %v", 90)

ది Fscanf పద్ధతి రీడర్ నుండి స్కాన్ చేస్తుంది మరియు పేర్కొన్న ఫార్మాట్ ప్రకారం ఫార్మాట్ చేస్తుంది.

var take string 
  
// read data from the given string 
readString := strings.NewReader("This is a test") 
  
read, err := fmt.Fscanf(reader, "%v", &take)

ఈ సందర్భంలో, ది Fscanf రీడర్ నుండి స్ట్రింగ్‌ను డీకోడ్ చేస్తుంది తీసుకోవడం వేరియబుల్, మరియు చదవండి వేరియబుల్ ఫార్మాట్ యొక్క ఫలితాన్ని కలిగి ఉంటుంది.

స్ట్రింగ్ ఫార్మాటింగ్ క్రియలు

స్ట్రింగ్ ఫార్మాటింగ్ ఫంక్షన్‌లతో పాటు మీరు ఉపయోగించగల అనేక ఫార్మాటింగ్ క్రియలను Go అందిస్తుంది.

విండోస్ 10 లో పాత పిసి గేమ్‌లను ఎలా అమలు చేయాలి

వంటి సాధారణ స్ట్రింగ్ ఫార్మాటింగ్ క్రియలు ఉన్నాయి % లో స్ట్రింగ్ ఫార్మాటింగ్ ఫంక్షన్ల ఉదాహరణలలోని క్రియ. ఏదైనా డేటా రకాన్ని ఫార్మాట్ చేయడానికి మీరు సాధారణ స్ట్రింగ్ ఫార్మాటింగ్ క్రియలను ఉపయోగించవచ్చు.

మీరు ఉపయోగించవచ్చు %#in ఏదైనా విలువను అవుట్‌పుట్ చేయడానికి క్రియ, ది %+v స్ట్రక్ట్స్ కోసం, ది %T ఏదైనా విలువ రకం కోసం క్రియ, మరియు %% విలువలు లేని క్రియ.

type any struct {  
  name string 
  age int 
  isLoggedIn bool 
} 
  
var instance = any { 
  name: "John Doe", 
  age: 34, 
  isLoggedIn: true, 
} 
  
var result = fmt.Sprintf("This is a struct formatting example %+v", instance) 
fmt.Println(result)

ది ఫలితం వేరియబుల్ ఇన్‌స్టంటియేటెడ్ స్ట్రక్ట్ యొక్క ఫార్మాట్ చేసిన స్ట్రింగ్‌ను కలిగి ఉంటుంది. మీరు దాన్ని ప్రింట్ చేస్తే, అది ఇలా ఉండాలి:

This is a struct formatting example {name:John Doe age:34 isLoggedIn:true}

ఛానెల్‌లు మరియు పాయింటర్‌లతో సహా నిర్దిష్ట Go స్థానిక డేటా రకాలను ఫార్మాటింగ్ చేయడానికి క్రియలు ఉన్నాయి.

%t	బూలియన్లు.
%d	int, int8, మొదలైనవి.
%d, %#x %#vతో ముద్రించబడితే	uint, uint8, మొదలైనవి.
% గ్రా	float32, complex64, మొదలైనవి.
%s	స్ట్రింగ్.
% p	చాన్.
%P	పాయింటర్.

మీరు క్రియలతో పొరపాట్లు చేయకూడదని మీరు నిర్ధారించుకోవాలి, ఎందుకంటే అవి కేస్-సెన్సిటివ్‌గా ఉంటాయి. చాన్ మరియు పాయింటర్ క్రియలు.

పూర్ణాంకాలు మరియు ఫ్లోట్‌లను ఫార్మాటింగ్ చేయడం

పూర్ణాంకాలను ఫార్మాటింగ్ చేయడానికి స్ట్రింగ్ ఫార్మాటింగ్ క్రియలు ఉన్నాయి వివిధ ఆధారాలు . పూర్ణాంకాలను ఫార్మాట్ చేయడానికి మీరు ఈ క్రియలలో దేనినైనా ఉపయోగించవచ్చు

%b	బేస్ 2
%c	సంబంధిత యూనికోడ్ కోడ్ పాయింట్ ద్వారా సూచించబడే అక్షరం.
%d	బేస్ 10.
% O	బేస్ 8.
% O	0o ఉపసర్గతో బేస్ 8.
%q	ఒకే కోట్ చేయబడిన అక్షరం గో సింటాక్స్‌తో సురక్షితంగా తప్పించుకుంది.
%x	బేస్ 16, a-f కోసం చిన్న అక్షరాలతో.
% X	A-F కోసం పెద్ద-కేస్ అక్షరాలతో బేస్ 16.
%IN	యూనికోడ్ ఫార్మాట్: U+1234; అదే 'U+%04X'.

ఉదాహరణకు, మీరు ఉపయోగించి పూర్ణాంకాన్ని ఫార్మాట్ చేయవచ్చు %d క్రియ:

var result = fmt.Sprintf("This is an integer formatting example %d", 90) 
fmt.Println(result)

ఫ్లోటింగ్ పాయింట్ నంబర్‌లను ఫార్మాటింగ్ చేయడానికి ఇవి క్రియలు.

%b	strconv పద్ధతిలో ఘాతాంకం రెండు శక్తితో దశాంశ రహిత శాస్త్రీయ సంజ్ఞామానం. 'b' ఆకృతితో ఫార్మాట్ ఫ్లోట్, ఉదా. -123456p-78
% మరియు	శాస్త్రీయ సంజ్ఞామానం, ఉదా. -1.234456e+78
%AND	దశాంశ బిందువు కానీ ఘాతాంకం లేదు, ఉదా., 123.456
% f	దశాంశ బిందువు కానీ ఘాతాంకం లేదు, ఉదా., 123.456
%F	%fకి పర్యాయపదం.
% గ్రా	పెద్ద ఘాతాంకాలకు %e, లేకపోతే %f. క్రింద ఖచ్చితత్వం.
%G	పెద్ద ఘాతాంకాలకు %E, లేకపోతే %F
%x	హెక్సాడెసిమల్ సంజ్ఞామానం (రెండు ఘాతాంకాల దశాంశ శక్తితో), ఉదా., -0x1.23abcp+20.
% X	అప్పర్-కేస్ హెక్సాడెసిమల్ సంజ్ఞామానం, ఉదా. -0X1.23ABCP+20.

ఘాతాంకం లేకుండా దశాంశ బిందువును ఫార్మాటింగ్ చేయడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది % f క్రియ.

var result = fmt.Sprintf("This is a floating point formatting example %f", 432.9503) 
fmt.Println(result)

మీరు రకం గురించి అనిశ్చితంగా ఉంటే మీరు ఎల్లప్పుడూ సాధారణ క్రియలను ఉపయోగించవచ్చు.

స్ట్రింగ్‌లు మరియు బైట్‌లను ఫార్మాటింగ్ చేయడం

గోలో స్ట్రింగ్‌లు మరియు బైట్ రకాల స్లైస్ చాలా పోలి ఉంటాయి. ఇవి స్ట్రింగ్‌లు మరియు బైట్‌లను ఫార్మాటింగ్ చేయడానికి ఫ్లాగ్‌లు.

%s	స్ట్రింగ్ లేదా స్లైస్ యొక్క అన్వయించని బైట్‌లు
%q	గో సింటాక్స్‌తో డబుల్ కోట్ చేయబడిన స్ట్రింగ్ సురక్షితంగా తప్పించుకుంది
%x	బేస్ 16, లోయర్-కేస్, ఒక్కో బైట్‌కి రెండు అక్షరాలు
% X	బేస్ 16, అప్పర్-కేస్, ఒక్కో బైట్‌కి రెండు అక్షరాలు

దీనితో స్ట్రింగ్‌ని ఫార్మాటింగ్ చేయడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది %s క్రియ.

var score = "example" 
var result = fmt.Sprintf("This is a string formatting example %s", score) 
fmt.Println(result)

పైథాన్ ప్రోగ్రామింగ్ కోసం fmt ప్యాకేజీ అవసరం

ది fmt స్ట్రింగ్ ఫార్మాటింగ్ కోసం మీకు అవసరమైన చాలా కార్యాచరణలను ప్యాకేజీ కలిగి ఉంది. గో కూడా అందిస్తుంది తీగలను స్ట్రింగ్ మానిప్యులేషన్ కోసం ప్యాకేజీ మరియు a లాగ్ లాగింగ్ కోసం స్ట్రింగ్‌లను ఫార్మాట్ చేయగల ప్యాకేజీ.

ది fmt ప్యాకేజీని అమలు చేసే విధులు ఉన్నాయి io.రచయిత మరియు io.రీడర్ ఇంటర్‌ఫేస్‌లు. వెబ్ మరియు కమాండ్ లైన్ అప్లికేషన్‌లను రూపొందించడం వంటి అనేక వినియోగ సందర్భాలలో మీకు ఇది ఉపయోగకరంగా ఉంటుంది.