När du skriver Go-kod kommer du att hitta strängformatering mycket användbar i många situationer. Du kanske analyserar indata eller skapar mer komplexa utdata än enkel sammanfogning. Du kanske arbetar med andra typer än vanliga strängar.
Strängformatering i Go använder den välbekanta processen och syntaxen för printf-funktionen, som även språk från Java till Haskell använder.
Go tillhandahåller olika metoder för att formatera strängar i fmt paket. Du kan använda funktioner och verb för strängformatering beroende på operationen eller inmatningarna du vill formatera.
Strängformatering i Go
Funktionerna i fmt-paketet liknar motsvarigheter, som printf-funktionen i bash eller C. Go härleder sina formateringsverb från C.
Du använder strängformateringsverb som platshållare för dina variabelvärden i en innehållande sträng. Du kan sedan skicka den formateringssträngen till en funktion som Printf, tillsammans med värden som motsvarar dessa platshållare.
Du kan inte använda strängformateringsverb med Skriva ut och Println metoder. Du kan använda dem med metoder som Printf och Sprintf.
fmt. Println("Detta är ett test %v", 90)
fmt. Printf("Detta är ett test %v", 90)
De %v verb skriver ut vilket värde som helst i dess standardformat. De Println Metoden känner inte igen verb och skriver ut vilka argument den tar emot. De Printf och Sprintf funktioner båda formaterar det första strängargumentet du skickar till dem.
Strängformateringsfunktioner i fmt-paketet
Formatera strängar in programmeringsspråket Go kräver att du använder en strängformateringsfunktion och ett verb. Funktionen returnerar den formaterade strängen och verben är platshållare för indata till strängen.
De Printf metoden formaterar indata enligt formatspecifikationen och returnerar antalet skrivna byte eller fel.
fmt. Printf("Detta är ett test %v", 90)
Konventionellt behöver du inte oroa dig för fel när du använder Printf metod.
De Sprintf metod formaterar enligt det angivna formatet och returnerar resultatet som en sträng.
var resultat = fmt. Sprintf("Detta är ett test %v", 90)
De Fprintf metoden formaterar strängen och skriver den till en författare (metoder som implementerar io. Författare gränssnitt)
// skriv data till standardutdata
resultat, err = fmt. Fprintf (skribent, "Detta är ett test %v", 90)De Fscanf metod skannar från en läsare och formaterar enligt det angivna formatet.
var ta sträng// läs data från den givna strängen
readString := strängar. NewReader("Detta är ett test")
läs, fel := fmt. Fscanf (läsare, "%v", &take)
I det här fallet Fscanf avkodar strängen från läsaren till ta variabel och läsa variabeln innehåller resultatet av formatet.
Strängformateringsverb
Go tillhandahåller många formateringsverb som du kan använda tillsammans med strängformateringsfunktionerna.
Det finns allmänna strängformateringsverb som %v verb i exempel på strängformateringsfunktioner. Du kan använda de allmänna strängformateringsverben för att formatera vilken datatyp som helst.
Du kan använda % #v verb att mata ut vilket värde som helst, den %+v för strukturer, den %T verb för typen av något värde, och %% verb för inga värden.
typ några struktur {
namn sträng
ålder int
är inloggad bool
}var instans = någon {
namn: "John Doe",
ålder: 34,
är inloggad: Sann,
}
var resultat = fmt. Sprintf("Detta är en struktur formateringsexempel %+v", instans)
fmt. Println (resultat)
De resultat variabeln innehåller den formaterade strängen för den instansierade strukturen. Om du skriver ut den ska den se ut ungefär så här:
Detta är ett exempel på strukturformatering {namn: John Doe ålder: 34 isLoggedIn:Sann}Det finns verb för att formatera specifika Go-native datatyper, inklusive kanaler och pekare.
| Verb | Funktionalitet |
|---|---|
| %t | booleaner. |
| %d | int, int8 osv. |
| %d, % #x om de skrivs ut med % #v | uint, uint8 osv. |
| %g | float32, complex64, etc. |
| %s | sträng. |
| %p | chan. |
| %P | pekare. |
Du vill se till att du inte gör misstag med verben eftersom de är skiftlägeskänsliga, som chan och pekare verb.
Formatera heltal och flytande tal
Det finns strängformateringsverb för att formatera heltal i olika baser. Du kan använda vilket som helst av dessa verb för att formatera heltal
| Verb | Funktionalitet |
|---|---|
| %b | bas 2 |
| %c | tecknet som representeras av motsvarande Unicode-kodpunkt. |
| %d | bas 10. |
| %o | bas 8. |
| %O | bas 8 med 0o prefix. |
| %q | ett bokstavligt tecken med ett citat rymde säkert med Go-syntax. |
| %x | bas 16, med små bokstäver för a-f. |
| %X | bas 16, med versaler för A-F. |
| %U | Unicode-format: U+1234; samma som "U+%04X". |
Du kan till exempel formatera ett heltal med hjälp av %d verb:
var resultat = fmt. Sprintf("Detta är ett heltalsformateringsexempel %d", 90)
fmt. Println (resultat)Dessa är verben för att formatera flyttal.
| Verb | Funktionalitet |
|---|---|
| %b | decimallös vetenskaplig notation med exponent en potens av två, på samma sätt som strconv. FormatFloat med "b"-formatet, t.ex. -123456p-78 |
| %e | vetenskaplig notation, t.ex. -1,234456e+78 |
| %E | decimalkomma men ingen exponent, t.ex. 123,456 |
| %f | decimalkomma men ingen exponent, t.ex. 123,456 |
| %F | synonym för %f. |
| %g | %e för stora exponenter, %f annars. Precision nedan. |
| %G | %E för stora exponenter, %F annars |
| %x | hexadecimal notation (med decimalpotens av två exponenter), t.ex. -0x1,23abcp+20. |
| %X | hexadecimal notation med stora bokstäver, t.ex. -0X1.23ABCP+20. |
Här är ett exempel på att formatera en decimalpunkt utan exponent med %f verb.
var resultat = fmt. Sprintf("Detta är ett flyttalsformateringsexempel %f", 432.9503)
fmt. Println (resultat)
Du kan alltid använda de allmänna verben om du är osäker på typen.
Formatera strängar och bytes
Strängar och delar av bytetyper är ganska lika i Go. Dessa är flaggorna för formatering av strängar och byte.
| Verb | Funktionalitet |
|---|---|
| %s | de otolkade byten av strängen eller segmentet |
| %q | en sträng med dubbla citattecken som säkert undkom med Go-syntax |
| %x | bas 16, gemener, två tecken per byte |
| %X | bas 16, versaler, två tecken per byte |
Här är ett exempel på att formatera en sträng med %s verb.
var poäng = "exempel"
var resultat = fmt. Sprintf("Detta är en sträng formateringsexempel %s", poäng)
fmt. Println (resultat)Fmt-paketet är viktigt för Python-programmering
De fmt paketet innehåller de flesta funktioner du behöver för strängformatering. Go ger också en strängar paket för strängmanipulation och en logga paket som kan formatera strängar för loggning.
De fmt paketet har funktioner som implementerar io. Författare och io. Läsare gränssnitt. Du kommer att finna det användbart för många användningsfall som att bygga webb- och kommandoradsapplikationer.
