Go-String

String ist eine unveränderliche Sequenz von Bytes. In Go sind Strings UTF-8-kodiert.

Deklaration

Strings werden mit doppelten Anführungszeichen deklariert.

s := "Hallo, Welt!"

Oder mit Backticks für Raw-Strings.

s := `Hallo, Welt!
Dies ist eine mehrzeilige
Zeichenkette.`

String-Operationen

Verkettung

s1 := "Hallo"
s2 := "Welt"
s3 := s1 + ", " + s2 + "!"
fmt.Println(s3) // Hallo, Welt!

Länge

s := "Hallo"
fmt.Println(len(s)) // 5

TIP

len() gibt die Anzahl der Bytes zurück, nicht die Anzahl der Unicode-Zeichen.

Indexierung

s := "Hallo"
fmt.Println(s[0]) // 72 (ASCII-Wert von 'H')
fmt.Println(string(s[0])) // H

Slicing

s := "Hallo"
fmt.Println(s[1:4]) // all

String und Bytes

Strings können in Byte-Slices konvertiert werden.

s := "Hallo"
b := []byte(s)
fmt.Println(b) // [72 97 108 108 111]

Byte-Slices können in Strings konvertiert werden.

b := []byte{72, 97, 108, 108, 111}
s := string(b)
fmt.Println(s) // Hallo

String und Rune

Eine Rune ist ein Unicode-Codepoint (int32).

s := "你好"
for _, r := range s {
   fmt.Printf("%c %U\n", r, r)
}

Ausgabe:

你 U+4F60
好 U+597D

String-Vergleich

Strings können mit == und != verglichen werden.

s1 := "Hallo"
s2 := "Hallo"
s3 := "Welt"
fmt.Println(s1 == s2) // true
fmt.Println(s1 == s3) // false

Für lexikalischen Vergleich verwenden Sie strings.Compare.

import "strings"

s1 := "a"
s2 := "b"
fmt.Println(strings.Compare(s1, s2)) // -1

Strings-Paket

Das strings-Paket bietet viele nützliche Funktionen für String-Operationen.

Contains

import "strings"

s := "Hallo, Welt!"
fmt.Println(strings.Contains(s, "Welt")) // true

HasPrefix und HasSuffix

import "strings"

s := "Hallo, Welt!"
fmt.Println(strings.HasPrefix(s, "Hallo")) // true
fmt.Println(strings.HasSuffix(s, "Welt!")) // true

Index

import "strings"

s := "Hallo, Welt!"
fmt.Println(strings.Index(s, "Welt")) // 7

Replace

import "strings"

s := "Hallo, Welt!"
fmt.Println(strings.Replace(s, "Welt", "Go", -1)) // Hallo, Go!

Split

import "strings"

s := "a,b,c"
parts := strings.Split(s, ",")
fmt.Println(parts) // [a b c]

Join

import "strings"

parts := []string{"a", "b", "c"}
s := strings.Join(parts, ",")
fmt.Println(s) // a,b,c

ToUpper und ToLower

import "strings"

s := "Hallo"
fmt.Println(strings.ToUpper(s)) // HALLO
fmt.Println(strings.ToLower(s)) // hallo

Trim

import "strings"

s := "  Hallo  "
fmt.Println(strings.TrimSpace(s)) // Hallo

Repeat

import "strings"

s := "ab"
fmt.Println(strings.Repeat(s, 3)) // ababab

strconv-Paket

Das strconv-Paket bietet Funktionen für die Konvertierung zwischen Strings und anderen Datentypen.

String zu int

import "strconv"

s := "42"
n, err := strconv.Atoi(s)
if err != nil {
   fmt.Println(err)
   return
}
fmt.Println(n) // 42

int zu String

import "strconv"

n := 42
s := strconv.Itoa(n)
fmt.Println(s) // 42

String zu bool

import "strconv"

s := "true"
b, err := strconv.ParseBool(s)
if err != nil {
   fmt.Println(err)
   return
}
fmt.Println(b) // true

String zu float

import "strconv"

s := "3.14"
f, err := strconv.ParseFloat(s, 64)
if err != nil {
   fmt.Println(err)
   return
}
fmt.Println(f) // 3.14

fmt.Sprintf

fmt.Sprintf formatiert Werte in einen String.

import "fmt"

name := "Alice"
age := 25
s := fmt.Sprintf("Name: %s, Alter: %d", name, age)
fmt.Println(s) // Name: Alice, Alter: 25

strings.Builder

strings.Builder ist effizient für das Erstellen von Strings durch Verkettung.

import "strings"

var b strings.Builder
b.WriteString("Hallo")
b.WriteString(", ")
b.WriteString("Welt")
b.WriteString("!")
fmt.Println(b.String()) // Hallo, Welt!