Golang-Casting-Beispiele

Beispiel 1: Golang Basic Type Casting

Beginnen wir mit dem Beispiel der direkten und einfachen Umwandlung in Go, da wir eine Typumwandlung benötigen, um den Typ der Variablen an einer beliebigen Stelle zu ändern.

Hier beginnen wir mit der Hauptfunktion, indem wir eine Variable namens „x“ vom Typ „int“ deklarieren und ihr den Wert 31 zuweisen. Anschließend wird die Variable „y“ mit dem Kurzzuweisungsoperator „:=“ deklariert. Der Typ von „y“ wird automatisch aus dem Ausdruck auf der rechten Seite bestimmt, der das Ergebnis der Konvertierung von „x“ in „float64“ ist. In diesem Programm wird also der Wert von „x“ in „float64“ umgewandelt und „y“ zugewiesen.

Die Ergebnisse, die aus dem Basiscasting in Go abgerufen werden, werden wie folgt angezeigt:

Beispiel 2: Implizite Golang-Typumwandlung

Eine implizite Typumwandlung zwischen verschiedenen Typen ist nicht zulässig. Go erzwingt eine starke Typisierung, was bedeutet, dass wir einen Wert eines Typs ohne explizite Konvertierung nicht direkt einem anderen Typ zuweisen oder verwenden können. Im Folgenden versuchen wir, das implizite Casting durchzuführen, das die Ausnahme von Go generiert:

Hier ist der Code, der mit der Funktion main() beginnt, bei der eine „Integer“-Variable mit dem Typ „int“ deklariert wird. Der Wert, der der Variablen „integer“ zugewiesen wird, ist 9,08, was eine Gleitkommazahl ist. Da wir versuchen, einen Gleitkommawert direkt einer Ganzzahlvariablen zuzuweisen, führt dies zu einem Typkonfliktfehler. Anschließend verwenden wir die Funktion „printf“ aus dem Paket „fmt“, um den Wert der Variablen „integer“ mithilfe des Formatbezeichners „%g“ zu drucken.

Wie erwartet ist die implizite Typumwandlung in Golang nicht akzeptabel. Die vorherige implizite Typumwandlung erzeugt den folgenden Fehler:

Beispiel 3: Explizite Typumwandlung von Golang

Die explizite Typkonvertierung ermöglicht es uns, die Werte sicher zwischen kompatiblen Typen zu konvertieren und dabei explizit eine Absicht anzugeben. Dadurch wird sichergestellt, dass wir über die Typkonvertierung informiert sind, und es hilft, versehentliche Typfehler zu vermeiden. Betrachten Sie das folgende explizite Casting:

Dabei wird eine „floatVal“-Variable vom Typ „float32“ erstellt und ihr der Wert „6,75“ zugewiesen. Anschließend wird eine „intVal“-Variable mit dem Typ „int“ deklariert. Um den Wert von floatVal zu intVal zuzuweisen, wird die Typkonvertierung verwendet. Um den floatVal in einen ganzzahligen Wert umzuwandeln, wird die Funktion „int“ mit floatVal als Eingabe verwendet. Danach druckt „fmt.Printf(„Float Value is %g\n“, floatVal)“ den Wert von floatVal unter Verwendung des %g-Formatbezeichners, der zum Drucken der Gleitkommawerte geeignet ist. Während die Codezeile „fmt.Printf(„Integer Value is %d“, intVal)“ den Wert von intVal unter Verwendung des Formatbezeichners %d druckt, der zum Drucken der ganzzahligen Werte geeignet ist.

Die folgende Ausgabe generiert nach der Umwandlung die Werte für floatVal und intVal:

Beispiel 4: Golang-Typ-Casting, um den Durchschnitt zu ermitteln

Als nächstes führen wir das Casting durch, um die durchschnittliche Zahl aus den angegebenen Werten zu ermitteln. Lassen Sie uns den im Folgenden bereitgestellten Quellcode durchgehen:

Hier deklarieren wir zunächst drei Variablen. „total“ ist eine ganzzahlige Variable, die mit dem Wert 900 initialisiert wird. „MyNumber“ ist eine ganzzahlige Variable, die mit dem Wert 20 initialisiert wird. Der berechnete Durchschnitt wird dann in der float32-Variable „average“ gespeichert. Anschließend wird die Durchschnittsformel zur Durchführung der Berechnung angegeben. Um sicherzustellen, dass die Division als Gleitkommadivision erfolgt, werden die Werte von „total“ und „MyNumber“ mithilfe der Typkonvertierung in float32 umgewandelt. Der berechnete Durchschnitt wird der Variablen „Durchschnitt“ zugeordnet. Schließlich gibt die Formatzeichenfolge „%f\n“, die in der Funktion „printf“ verwendet wird, an, dass ein Gleitkommawert gefolgt von einem Zeilenumbruchzeichen gedruckt werden soll.

Der resultierende Wert als Durchschnitt wird abgerufen, nachdem die Typumwandlung im vorherigen Code impliziert wurde:

Beispiel 5: Golang Int und String Type Casting

Darüber hinaus bietet Go auch das Casting zwischen Int- und String-Typen an. Dies können wir mit der Funktion des Pakets strconv erreichen.

Hier ist der Code, der mit der Deklaration zweier Variablen beginnt. „str“ ist eine String-Variable, die mit dem Wert „1999“ initialisiert wird, und „integer“ ist eine Ganzzahlvariable, die mit dem Wert „1999“ initialisiert wird. Anschließend wird mit der Funktion „strconv.Atoi()“ der String „str“ in einen ganzzahligen Wert umgewandelt. Der zurückgegebene Wert von „v“ stellt die konvertierte Ganzzahl dar, und der leere Bezeichner „_“ wird verwendet, um mögliche Fehler zu ignorieren, die von Atoi() zurückgegeben werden.

Als nächstes wird die Funktion strconv.Itoa() verwendet, um die Ganzzahl in einen String-Wert umzuwandeln. Der zurückgegebene Wert „toStr“ stellt die konvertierte Zeichenfolge dar.

Die Ausgabe zeigt die Konvertierung der Zeichenfolge „1999“ in eine Ganzzahl und zurück in eine Zeichenfolge, die den ursprünglichen Wert „1999“ erzeugt:

Beispiel 6: Golang-Typumwandlung zwischen String und Bytes

Darüber hinaus kann das Casting in Go auch in String- und Byte-Typen durchgeführt werden. Die folgenden Codes veranschaulichen die Konvertierung zwischen Strings und Byte-Slices:

Hier werden die Variablen zunächst als „myStr“ und „b1“ deklariert und mit bestimmten Werten initialisiert. Anschließend wandelt der Ausdruck []byte(myStr) mithilfe der Typkonvertierung die Zeichenfolge „myStr“ in ein Byte-Slice um. Das resultierende Byte-Slice wird der Variablen „b1“ zugewiesen. Danach wandelt der Ausdruck „string(b1)“ mithilfe der Typkonvertierung das Byte-Slice b1 wieder in einen String um. Die resultierende Zeichenfolge wird der Variablen „toString“ zugewiesen.

Die Ausgabe zeigt die Konvertierung zwischen der Zeichenfolge „Hey There“ und der entsprechenden Byte-Slice-Darstellung im Folgenden:

Beispiel 7: Golang-Typumwandlung zum Erhalten der Quadratwurzel

Jetzt führen wir die Umwandlung in Go durch, um die Quadratwurzelergebnisse zu ermitteln. Der Code wird wie folgt platziert:

Hier wird die Variable „n“ als int deklariert und weist den Wert „144“ zu. Die Variable „SqrtN“ wird als float64 deklariert und speichert die berechnete Quadratwurzel von „n“. Anschließend wird die Funktion math.Sqrt() eingesetzt, um die Quadratwurzel von „n“ zu berechnen. Da math.Sqrt() ein float64-Argument erwartet, wird der Wert von „n“ mit float64(n) in float64 konvertiert. Danach ruft die Formatzeichenfolge „Quadratwurzel von %d ist %.2f\n“ die Funktion „printf“ auf, die einen ganzzahligen Wert (%d) und einen Gleitkommawert (%.2f) angibt. Der Präzisionsspezifizierer „.2“ in „%.2f“ stellt sicher, dass die Quadratwurzel mit zwei Dezimalstellen gedruckt wird.

Die folgende Ausgabe wird abgerufen, die die Quadratwurzel des angegebenen Werts angibt:

Abschluss

Das Casting in Go wird anhand konkreter Beispiele besprochen, die alle ausführbar sind. Beachten Sie, dass in Go die Typumwandlung explizit ist, was eine starke Typisierung erzwingt und die Klarheit und Zuverlässigkeit des Codes fördert.