Drucktypen in Go (Drucktyp)

Drucktypen In Go Drucktyp



Es gibt keine Sprache, die zu einer funktionalen Anwendung führen könnte, die kein Konzept von Datentypen hat. Dies liegt daran, dass sie die Bausteine ​​dafür sind, wie die Anwendung funktioniert, welche Werte sie speichern kann, wie mit den Werten gearbeitet wird und vieles mehr.

Der grundlegendste und dennoch grundlegendste Aspekt des Debuggens und Protokollierens besteht darin, dem Benutzer die Informationen über das Programm anzuzeigen. Glücklicherweise bietet uns Go umfangreiche und leistungsstarke Möglichkeiten zum Drucken der Werte verschiedener Datentypen mithilfe des Pakets „fmt“ aus der Standardbibliothek.

Nehmen Sie an diesem Tutorial teil, in dem wir Ihnen beibringen, wie Sie die Werte verschiedener Datentypen in Go mithilfe des Pakets „fmt“ drucken.







Typen in Go

Bevor wir uns mit den Schritten zum Drucken der Typen in Go befassen, lassen Sie uns kurz auf die grundlegenden Datentypen eingehen, die von Go unterstützt werden:



  • Ganzzahlen – Go unterstützt verschiedene Ganzzahltypen, darunter die folgenden:
    • int
    • du8
    • int16
    • int32
    • int64

Jeder der Ganzzahltypen stellt vorzeichenbehaftete Ganzzahlen mit unterschiedlichen Größen dar.



  • Gleitkommazahlen – Als nächstes haben wir Gleitkommazahlen. In Go gibt es zwei Arten von Floating-Typen:
    • float32
    • float64
  • Strings – Strings in Go sind Zeichenfolgen.
  • Boolesche Werte – Go verfügt über einen Bool-Typ zur Darstellung der booleschen Werte, die entweder wahr oder falsch sein können.
  • Arrays und Slices – Arrays und Slices ermöglichen es uns, mehrere Werte desselben Typs zusammenzufassen. Arrays haben eine feste Größe, während Slices dynamisch sind.
  • Strukturen – Strukturen sind zusammengesetzte Datentypen, die es uns ermöglichen, mehrere Werte unterschiedlichen Typs zu einer einzigen Einheit zusammenzufassen. Sie spielen eine entscheidende Rolle bei der Definition der benutzerdefinierten Typen.
  • Zeiger – Wie alle Zeiger ermöglichen uns Zeiger in Go, die Speicheradresse eines Werts zu speichern. Wir stellen die Zeiger mit dem Symbol „*“ dar.
  • Benutzerdefinierte Typen – Schließlich können wir die benutzerdefinierten Typen mit dem Schlüsselwort „type“ erstellen.

Lassen Sie uns nun in die Schritte und den Prozess des Druckens der Typen in Go eintauchen.





Golang-Drucktypen

Ganzzahlen und Floats

Um die Ganzzahlen und Gleitkommazahlen in Go zu drucken, können wir die Funktion fmt.Print() verwenden. Ein Beispielcode lautet wie folgt:

importieren „fmt“
Funktion hauptsächlich () {
ich := 30
F := 175 . 5
fmt . Drucken ( „Int:“ , ich , ', Schweben: ' , F )
}

Im gegebenen Beispiel verwenden wir die Funktion fmt.Print(), um die Werte von „i“ und „f“ zusammen mit einem beschreibenden Text zu drucken.



String-Typen

Wie Sie sich vorstellen können, ist das Drucken von Zeichenfolgen in Go mithilfe der Zeichenfolge „fmt.Print“ sehr einfach. Ein Beispiel ist wie folgt:

Paket hauptsächlich
importieren „fmt
func main() {
str := '
Hallo , Welt ! '
fmt.Print(str)
}

In diesem Beispiel verwenden wir die Funktion „Drucken“, um den String-Wert zu drucken.

Boolesche Typen

Wir können dieselbe Funktion verwenden, um die booleschen Werte problemlos zu drucken, wie im folgenden Beispiel gezeigt:

Paket hauptsächlich
importieren „fmt“
Funktion hauptsächlich () {
Es_ := WAHR
Wenn_ := FALSCH
fmt . Drucken ( 'ist wahr: ' , Es_ , ', is false: ' , Wenn_ )
}

Der angegebene Code sollte die booleschen Werte mit beschreibendem Text ausgeben, wie in der folgenden Ausgabe gezeigt:

Ist WAHR : WAHR , Ist FALSCH : FALSCH

Arrays und Slices

Wir können die Arrays und Slices mithilfe von Schleifen oder der Funktion „fmt.Println“ drucken. Der folgende Beispielcode zeigt, wie das geht:

Paket hauptsächlich
importieren „fmt“
Funktion hauptsächlich () {
// Array
Zahlen := [ 5 ] int { 1 , 2 , 3 , 4 , 5 }
fmt . Druckenln ( „Array:“ )
für ich , Auf eins := Reichweite Zahlen {
fmt . Druckenf ( „Index %d: %d \N ' , ich , Auf eins )
}
// Scheibe
dbs := [] Zeichenfolge { „MySQL“ , „PostgreSQL“ , „SQLite“ }

fmt . Druckenln ( ' \N Scheibe:' )
für ich , db := Reichweite dbs {
fmt . Druckenf ( „Index %d: %s \N ' , ich , db )
}
}

Das angegebene Beispiel zeigt, wie eine Schleife verwendet wird, um die Elemente eines Arrays oder Slice zu durchlaufen.

Die resultierende Ausgabe lautet wie folgt:

Array :
Index 0 : 1
Index 1 : 2
Index 2 : 3
Index 3 : 4
Index 4 : 5

Scheibe :
Index 0 : MySQL
Index 1 : PostgreSQL
Index 2 : SQLite

Strukturen

Wir können die Strukturen mit der Funktion fmt.Printf() mit dem angegebenen Format „%+v“ drucken, um die Feldnamen zusammen mit den jeweiligen Werten anzuzeigen.

Ein Beispiel ist wie folgt:

Paket hauptsächlich
importieren „fmt“
Typ Auto Struktur {
Modell Zeichenfolge
Jahr int
}
Funktion hauptsächlich () {
Auto := Auto { Modell : „Audi“ , Jahr : 2023 }
fmt . Druckenf ( „%+in \N ' , Auto )
}

Im gegebenen Beispiel verwenden wir den Formatbezeichner „%+v“, um die Struktur „Car“ mit den Feldnamen und -werten zu drucken.

Ausgabe:

{ Modell : Audi-Jahr : 2023 }

Wenn Sie verschachtelte Strukturen haben, können Sie diese mit dem Formatbezeichner „%+v“ drucken.

Benutzerdefinierte Typen

In Go können wir die benutzerdefinierten Typen definieren und sie mit der Funktion „Drucken“ von „fmt“ drucken, wie im folgenden Beispiel gezeigt:

Paket hauptsächlich
importieren „fmt“
Typ Auto Struktur {
Modell Zeichenfolge
Jahr int
}
Funktion hauptsächlich () {
Auto := Auto { Modell : „Ferrari“ , Jahr : 2023 }
fmt . Drucken ( „“ , Auto )
}

Dadurch sollte der entsprechende Typ gedruckt werden.

Druckformatierung (fmt.Printf)

Während „fmt.Print“ für einfache Druckvorgänge praktisch ist, benötigen Sie möglicherweise häufig mehr Kontrolle über die Formatierung.

Hier bietet sich „fmt.Printf“ an. Mit dieser Funktion können wir die Ausgabe mithilfe von Formatspezifizierern formatieren.

Formatspezifizierer

Formatbezeichner sind Platzhalter in der Formatzeichenfolge, die durch die Werte ersetzt werden, die Sie drucken möchten.

Zu den gängigen Spezifizierern für die Funktion gehören:

  • %d – Gibt eine Ganzzahl aus
  • %f – Gibt eine Gleitkommazahl aus
  • %s – Einen String ausgeben
  • %t – Gibt einen Booleschen Wert aus
  • %v – Gibt den Wert in einem Standardformat aus
  • %+v – Wert mit Feldnamen ausgeben (für Strukturen)
  • %#v – Gibt die Go-Syntaxdarstellung des Werts aus

Ein Beispiel für die Verwendung dieser Funktion ist wie folgt:

Paket hauptsächlich
importieren „fmt“
Typ Produkt Struktur {
Name Zeichenfolge
Preis float64
}
Funktion hauptsächlich () {
ich := 30
F := 175 . 5
str := „Alice“
bool := FALSCH
Prod := Produkt { Name : 'Laptop' , Preis : 999 . 99 }
fmt . Druckenf ( 'int: %d, float: %.2f \N ' , ich , F )
fmt . Druckenf ( „Name: %s, Lebendig: %t \N ' , str , bool )
fmt . Druckenf ( „Produkt: %+v \N ' , Prod )
}

Im gegebenen Beispiel verwenden wir die verschiedenen Formatspezifizierer, um die verschiedenen Wertetypen zu formatieren und auszugeben.

Abschluss

In diesem Tutorial haben wir alles gelernt, was Sie über Drucktypen in Go wissen müssen. Der Typdruck spielt eine entscheidende Rolle beim Debuggen und Protokollieren. Glücklicherweise haben Sie gelernt, wie Sie das Paket „fmt“ und einige der unterstützten Methoden wie Print und Printf verwenden.