Lernen Zeichenkettenformatierung

Nachdem wir nun alle grundlegenden Datentypen kennengelernt haben, können wir uns mit der Zeichenkettenformatierung beschäftigen. In der Programmierung bedeutet Zeichenkettenformatierung, dass Variablenwerte in Zeichenketten eingebettet werden.

Hinweis

Die Anweisung import wird verwendet, um Pakete in eine Go-Anwendung zu importieren. Ein Paket ist eine Sammlung zusammengehöriger Go-Quelldateien, die gemeinsam eine Reihe von Funktionalitäten oder Diensten bereitstellen. Das Paket fmt stellt Funktionen zur Verfügung, mit denen wir Zeichenketten formatieren können.

Eine der Funktionen aus dem Paket fmt, die wir bereits verwendet haben, ist die Funktion Println. Die Funktion Println gibt Ausgabetext jeweils in einer neuen Zeile aus. Es gibt jedoch auch eine Funktion namens Print, die Ausgaben ohne Zeilenumbruch darstellt:

index.go


              12345678
            
package main
import "fmt"

func main() {
    fmt.Print("1")
    fmt.Print(" 2")
    fmt.Print(" 3")
}

Im Allgemeinen können diese Funktionen verwendet werden, um Variablenwerte innerhalb von Zeichenfolgendaten mit der folgenden Methode einzufügen:

index.go


              123456789
            
package main
import "fmt"

func main() {
    var n int = 5
    var in int = n / 2
    var out int = n - in
    fmt.Println("There are", n, "cats,", in, "of them are inside the house while", out, "are outside.")
}

Diese Methode ist jedoch nicht sehr effizient, da die Zeichenfolge in viele Segmente unterteilt werden muss, um Variablen an den entsprechenden Stellen einzufügen. Dies kann in komplexeren Fällen umständlich werden. Die Funktion Printf löst dieses Problem und vereinfacht die Darstellung von formatierten Ausgaben.

Die Funktion Printf erhält als erstes Argument eine Formatzeichenfolge, gefolgt von Werten (oder Variablen), die in die Formatzeichenfolge eingefügt werden. Eine Formatzeichenfolge enthält Platzhalter (Formatspezifizierer), die das gewünschte Ausgabeformat definieren.

Im Folgenden ein Beispiel:

index.go


              12345678910
            
package main
import "fmt"

func main() {
    var n int = 5
    var in int = n / 2
    var out int = n - in
   
    fmt.Printf("There are %d cats, %d of them are inside the house with %d of them are outside. ", n, in, out)
}

Wie das Beispiel zeigt, sind Formatbezeichner Symbole, die als Platzhalter für bestimmte Datentypen innerhalb eines Strings dienen. Für jeden Datentyp gibt es einen eigenen Formatbezeichner. Die folgende Tabelle enthält eine Liste grundlegender Formatbezeichner:

Formatbezeichner	Datentyp
`%d`	Integer
`%s`	String
`%f`	Float
`%t`	Boolean
`%c`	Zeichen (oder Rune)

Die Variablen ersetzen die jeweiligen Platzhalter in der Formatzeichenkette. Im Ausgabebeispiel oben wird das erste %d durch den Wert von n ersetzt. Ebenso wird das zweite durch die entsprechende Variable, nämlich in, ersetzt, und das letzte %d wird durch den Wert von out ersetzt.

Wir können auch eine Zeichenkette formatieren und sie in einer String-Variable speichern, indem wir die Funktion Sprintf verwenden. Diese formatiert eine Zeichenkette und gibt die resultierende Zeichenkette zur Speicherung oder weiteren Verwendung zurück, anstatt sie sofort auf dem Bildschirm anzuzeigen:

index.go


              123456789101112
            
package main
import "fmt"

func main() {
    var n int = 5
    var in int = n / 2
    var out int = n - in
   
    var text string = fmt.Sprintf("There are %d cats, %d of them are inside the house with %d of them are outside. ", n, in, out)
   
    fmt.Println("Text:", text)
}

Hier ist ein komplexeres Beispiel, das mehrere zuvor behandelte Konzepte in einem einzigen Programm vereint. Es ist eine wertvolle Übung, das folgende Programm und dessen Ausgabe zu überprüfen, um die Fähigkeiten im Lesen von Code zu verbessern:

index.go


              12345678910
            
package main
import "fmt"

func main() {
    var numA float32 = 17.7
    var numB int = 10
   
    var str string = fmt.Sprintf("It is %t that 'a' is bigger than 'b'.", numA > float32(numB))
    fmt.Printf("The numbers 'a' and 'b' are %f and %d. %s", numA, numB, str)
}

In einigen Fällen führt der Compiler eine implizite Typumwandlung durch, um Werte an Formatbezeichner anzupassen, wie im folgenden Beispiel gezeigt:

index.go


              1234567
            
package main
import "fmt"

func main() {
    var char rune = 'A'
    fmt.Printf("The Unicode decimal value of %c is %d", char, char)
}

Das Rune 'char' wird sowohl als Zeichen als auch als numerischer Wert ausgegeben. In einigen Fällen kann der Compiler jedoch einen Fehler erzeugen. Zum Beispiel führt der folgende Code zu einer ungültigen Ausgabe, da ein 'float' nicht implizit in einen 'int' umgewandelt werden kann:

index.go


              12
            
var value float32 = 5.7
fmt.Printf("%d", value)

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 7

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Suggested prompts:

Can you explain more about how to use different format specifiers?

What happens if I use the wrong format specifier for a variable?

Can you show more examples of string formatting in Go?

Awesome!

Completion rate improved to 1.96

Swipe um das Menü anzuzeigen

Hinweis

Die Anweisung import wird verwendet, um Pakete in eine Go-Anwendung zu importieren. Ein Paket ist eine Sammlung zusammengehöriger Go-Quelldateien, die gemeinsam eine Reihe von Funktionalitäten oder Diensten bereitstellen. Das Paket fmt stellt Funktionen zur Verfügung, mit denen wir Zeichenketten formatieren können.

index.go


              12345678
            
package main
import "fmt"

func main() {
    fmt.Print("1")
    fmt.Print(" 2")
    fmt.Print(" 3")
}

Im Allgemeinen können diese Funktionen verwendet werden, um Variablenwerte innerhalb von Zeichenfolgendaten mit der folgenden Methode einzufügen:

index.go


              123456789
            
package main
import "fmt"

func main() {
    var n int = 5
    var in int = n / 2
    var out int = n - in
    fmt.Println("There are", n, "cats,", in, "of them are inside the house while", out, "are outside.")
}

Im Folgenden ein Beispiel:

index.go


              12345678910
            
package main
import "fmt"

func main() {
    var n int = 5
    var in int = n / 2
    var out int = n - in
   
    fmt.Printf("There are %d cats, %d of them are inside the house with %d of them are outside. ", n, in, out)
}

Formatbezeichner	Datentyp
`%d`	Integer
`%s`	String
`%f`	Float
`%t`	Boolean
`%c`	Zeichen (oder Rune)

index.go


              123456789101112
            
package main
import "fmt"

func main() {
    var n int = 5
    var in int = n / 2
    var out int = n - in
   
    var text string = fmt.Sprintf("There are %d cats, %d of them are inside the house with %d of them are outside. ", n, in, out)
   
    fmt.Println("Text:", text)
}

index.go


              12345678910
            
package main
import "fmt"

func main() {
    var numA float32 = 17.7
    var numB int = 10
   
    var str string = fmt.Sprintf("It is %t that 'a' is bigger than 'b'.", numA > float32(numB))
    fmt.Printf("The numbers 'a' and 'b' are %f and %d. %s", numA, numB, str)
}

In einigen Fällen führt der Compiler eine implizite Typumwandlung durch, um Werte an Formatbezeichner anzupassen, wie im folgenden Beispiel gezeigt:

index.go


              1234567
            
package main
import "fmt"

func main() {
    var char rune = 'A'
    fmt.Printf("The Unicode decimal value of %c is %d", char, char)
}

index.go


              12
            
var value float32 = 5.7
fmt.Printf("%d", value)

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 7