Wie man zwischen `int64` und `string` in Golang konvertiert

Key Takeaways

1. Verwenden Sie strconv.FormatInt oder fmt.Sprintf, um int64 in string zu konvertieren.
2. Verwenden Sie strconv.ParseInt, um string in int64 zu konvertieren und Fehler ordnungsgemäß zu behandeln.
3. strconv-Funktionen sind effizienter, während fmt.Sprintf Formatierungsflexibilität bietet.

Konvertieren zwischen int64 und string in Golang

In Golang ist das Konvertieren zwischen int64 und string eine häufige Aufgabe beim Umgang mit Benutzereingaben, Datenspeicherung oder Serialisierung. Dieser Artikel behandelt verschiedene Methoden zum Konvertieren von int64 in string und umgekehrt.

---

Konvertieren von int64 in string

Es gibt mehrere Möglichkeiten, einen int64 in Go in einen string zu konvertieren, abhängig vom Anwendungsfall.

Verwenden von strconv.FormatInt

Das Paket strconv bietet die Funktion FormatInt zum Konvertieren eines int64 in einen String mit einer bestimmten Basis.

package main

import (
        "fmt"
        "strconv"
)

func main() {
        num := int64(1234567890)
        str := strconv.FormatInt(num, 10) // Konvertiert int64 in dezimale Zeichenkette
        fmt.Println(str) // Ausgabe: "1234567890"
}

Verwenden von fmt.Sprintf

Ein anderer Ansatz ist die Verwendung von fmt.Sprintf, das flexibler ist und häufig zum Formatieren von Ausgaben verwendet wird.

package main

import (
        "fmt"
)

func main() {
        num := int64(1234567890)
        str := fmt.Sprintf("%d", num) // Formatiert int64 als dezimale Zeichenkette
        fmt.Println(str) // Ausgabe: "1234567890"
}

Die Funktion fmt.Sprintf ist nützlich, wenn Zahlen mit zusätzlichem Text formatiert werden sollen.

str := fmt.Sprintf("Die Zahl ist %d", num)
fmt.Println(str) // Ausgabe: "Die Zahl ist 1234567890"

---

Konvertieren von string in int64

Um einen string zurück in int64 zu konvertieren, verwenden wir hauptsächlich die Funktion strconv.ParseInt.

Verwenden von strconv.ParseInt

package main

import (
        "fmt"
        "strconv"
)

func main() {
        str := "1234567890"
        num, err := strconv.ParseInt(str, 10, 64) // Parsen als Basis 10 und Speichern als int64
        if err != nil {
                fmt.Println("Fehler:", err)
                return
        }
        fmt.Println(num) // Ausgabe: 1234567890
}

Behandeln von Konvertierungsfehlern

Wenn die Eingabezeichenkette keine gültige Zahl ist, gibt strconv.ParseInt einen Fehler zurück.

str := "invalid123"
num, err := strconv.ParseInt(str, 10, 64)
if err != nil {
        fmt.Println("Konvertierung fehlgeschlagen:", err)
} else {
        fmt.Println(num)
}

---

Welche Methode sollten Sie verwenden?

---

Fazit

In Golang können Sie einfach mit dem Paket strconv oder fmt.Sprintf zwischen int64 und string konvertieren. Für leistungskritische Anwendungen werden strconv.FormatInt und strconv.ParseInt bevorzugt. Wenn Sie mehr Flexibilität benötigen, funktioniert fmt.Sprintf gut.

Durch das Verständnis dieser Konvertierungsmethoden können Sie numerische Daten in Ihren Go-Anwendungen effizient verarbeiten.

FAQs

Was ist der effizienteste Weg, um int64 in string zu konvertieren?

strconv.FormatInt(num, 10) ist die effizienteste Methode.

Wie kann ich Fehler behandeln, wenn ich einen string in int64 konvertiere?

Verwenden Sie strconv.ParseInt und überprüfen Sie den Rückgabewert für Fehler.

Wann sollte ich fmt.Sprintf anstelle von strconv.FormatInt verwenden?

Verwenden Sie fmt.Sprintf, wenn Sie Zahlen innerhalb einer größeren Textzeichenkette formatieren möchten.

---

We are Leapcell, your top choice for hosting Go projects.

Leapcell is the Next-Gen Serverless Platform for Web Hosting, Async Tasks, and Redis:

Multi-Language Support

• Develop with Node.js, Python, Go, or Rust.

Deploy unlimited projects for free

• pay only for usage — no requests, no charges.

Unbeatable Cost Efficiency

• Pay-as-you-go with no idle charges.
• Example: $25 supports 6.94M requests at a 60ms average response time.

Streamlined Developer Experience

• Intuitive UI for effortless setup.
• Fully automated CI/CD pipelines and GitOps integration.
• Real-time metrics and logging for actionable insights.

Effortless Scalability and High Performance

• Auto-scaling to handle high concurrency with ease.
• Zero operational overhead — just focus on building.

Explore more in the Documentation!

Follow us on X: @LeapcellHQ