strings
Das Paket strings implementiert einfache Funktionen zur Manipulation von UTF-8-kodierten Strings. Kurz gesagt, es ist ein Werkzeugpaket für String-Operationen.
Offizielle Dokumentation: strings package - strings - Go Packages
TIP
Go unterstützt von Haus aus UTF8-Zeichen. Alle String-Operationen basieren auf UTF8.
Import
import (
"strings"
)Im Folgenden werden anhand von Beispielen die häufig verwendeten Funktionen erklärt.
String kopieren
func Clone(s string) stringWeist neuen Speicher für die Kopie zu. Wenn ein leerer String übergeben wird, wird kein Speicher zugewiesen und ein leerer String zurückgegeben.
func TestClone(t *testing.T) {
ori := "hello Welt"
copys := strings.Clone(ori)
fmt.Println(ori, copys)
fmt.Println(&ori, ©s)
}=== RUN TestClone
hello Welt hello Welt
0xc00005e5d0 0xc00005e5e0
--- PASS: TestClone (0.00s)
PASSStrings vergleichen
func Compare(a, b string) intVergleicht Strings a und b in lexikografischer Reihenfolge. Wenn a>b, wird 1 zurückgegeben, wenn a<b wird -1 zurückgegeben, wenn a=b wird 0 zurückgegeben.
func TestCompare(t *testing.T) {
fmt.Println(strings.Compare("abc", "abe"))
fmt.Println(strings.Compare("abcd", "abe"))
fmt.Println(strings.Compare("abijk", "abe"))
fmt.Println(strings.Compare("abe", "abe"))
}=== RUN TestCompare
-1
-1
1
0
--- PASS: TestCompare (0.00s)
PASSString enthält
func Contains(s, substr string) boolPrüft, ob ein String s einen Teilstring substr enthält
func TestContains(t *testing.T) {
fmt.Println(strings.Contains("abcdefg", "a"))
fmt.Println(strings.Contains("abcdefg", "abc"))
fmt.Println(strings.Contains("abcdefg", "ba"))
}=== RUN TestContains
true
true
false
--- PASS: TestContains (0.00s)
PASSfunc ContainsAny(s, chars string) boolPrüft, ob ein beliebiges Zeichen aus chars im String s enthalten ist
func TestContainsAny(t *testing.T) {
fmt.Println(strings.ContainsAny("abcedfg", "bac"))
fmt.Println(strings.ContainsAny("abcedfg", "gfdecba"))
}=== RUN TestContainsAny
true
--- PASS: TestContainsAny (0.00s)
PASSfunc ContainsRune(s string, r rune) boolPrüft, ob das Zeichen r im String s enthalten ist
func TestContainsRune(t *testing.T) {
fmt.Println(strings.ContainsRune("abcedf", 'a'))
fmt.Println(strings.ContainsRune("abcedf", 'b'))
fmt.Println(strings.ContainsRune("Hallo Welt", 'W'))
}=== RUN TestContainsRune
true
true
true
--- PASS: TestContainsRune (0.00s)
PASSHäufigkeit eines Teilstrings
func Count(s, substr string) intGibt zurück, wie oft der Teilstring substr im String s vorkommt
func TestCount(t *testing.T) {
fmt.Println(strings.Count("3.1415926", "1"))
fmt.Println(strings.Count("there is a girl", "e"))
fmt.Println(strings.Count("there is a girl", ""))
}=== RUN TestCount
2
2
16
--- PASS: TestCount (0.00s)
PASSTeilstring entfernen
func Cut(s, sep string) (before, after string, found bool)Entfernt das erste Vorkommen des Teilstrings sep in s und gibt das Ergebnis zurück
before- der String vor dem entfernten Teilstringafter- der String nach dem entfernten Teilstringfound- ob der Teilstring gefunden wurde
func TestCut(t *testing.T) {
show := func(s, sep string) {
before, after, found := strings.Cut(s, sep)
fmt.Printf("Cut(%q, %q) = %q, %q, %v\n", s, sep, before, after, found)
}
show("Hello world", " ")
show("Hello world", "world")
show("Hello world", "Hello")
show("Hello world", "Hello world")
}=== RUN TestCut
Cut("Hello world", " ") = "Hello", "world", true
Cut("Hello world", "world") = "Hello ", "", true
Cut("Hello world", "Hello") = "", " world", true
Cut("Hello world", "Hello world") = "", "", true
--- PASS: TestCut (0.00s)
PASSGroß-/Kleinschreibung ignorieren
func EqualFold(s, t string) boolGibt zurück, ob die Strings s und t bei Ignorierung der Groß-/Kleinschreibung gleich sind
func TestEqualFold(t *testing.T) {
fmt.Println(strings.EqualFold("Hallo", "Hallo"))
fmt.Println(strings.EqualFold("Hello", "Hello"))
fmt.Println(strings.EqualFold("Hello", "hELLO"))
}=== RUN TestEqualFold
true
true
true
--- PASS: TestEqualFold (0.00s)
PASSString aufteilen
func Fields(s string) []stringfunc FieldsFunc(s string, f func(rune) bool) []stringErstere teilt den String anhand von Leerzeichen, letztere anhand des Rückgabewerts der Funktion f.
func TestField(t *testing.T) {
fmt.Printf("%q\n", strings.Fields(" a b c d e f g "))
fmt.Printf("%q\n", strings.FieldsFunc("a,b,c,d,e,f,g", func(r rune) bool {
return r == ','
}))
}=== RUN TestField
["a" "b" "c" "d" "e" "f" "g"]
["a" "b" "c" "d" "e" "f" "g"]
--- PASS: TestField (0.00s)
PASSPräfix und Suffix suchen
func HasPrefix(s, prefix string) boolfunc HasSuffix(s, suffix string) boolErstere sucht nach einem Präfix, letztere nach einem Suffix.
func TestPreSuffix(t *testing.T) {
str := "abbc cbba"
fmt.Println(strings.HasPrefix(str, "abb"))
fmt.Println(strings.HasSuffix(str, "bba"))
}=== RUN TestPreSuffix
true
true
--- PASS: TestPreSuffix (0.00s)
PASSPosition eines Teilstrings
Gibt den Index des ersten Vorkommens eines Teilstrings zurück
func Index(s, substr string) intGibt den Index des ersten Vorkommens eines beliebigen Zeichens aus chars zurück
func IndexAny(s, chars string) intGibt den Index des ersten Vorkommens eines Runes zurück
func IndexRune(s string, r rune) intBeispiel
func TestIndex(t *testing.T) {
fmt.Println(strings.Index("abcdefg", "bc"))
fmt.Println(strings.IndexAny("abcdefg", "cb"))
fmt.Println(strings.IndexRune("abcdefg", 'g'))
}=== RUN TestIndex
1
1
6
--- PASS: TestIndex (0.00s)
PASSGibt den Index des letzten Vorkommens eines Teilstrings zurück
func LastIndex(s, substr string) intGibt den Index des letzten Vorkommens eines beliebigen Zeichens aus chars zurück
func LastIndexAny(s, chars string) intBeispiel
func TestLastIndex(t *testing.T) {
fmt.Println(strings.LastIndex("abcdefga", "a"))
fmt.Println(strings.LastIndexAny("abcdefghisa", "ba"))
}String durchlaufen und ersetzen
Map gibt eine Kopie des Strings s zurück und modifiziert alle Zeichen basierend auf der Mapping-Funktion. Wenn die Mapping-Funktion einen negativen Wert zurückgibt, wird das Zeichen aus dem String entfernt, ohne ersetzt zu werden.
func Map(mapping func(rune) rune, s string) stringBeispiel
func TestMap(t *testing.T) {
fmt.Println(strings.Map(func(r rune) rune {
return r - 32
}, "abcdefghijk"))
fmt.Println(strings.Map(func(r rune) rune {
return r + 32
}, "ABCDEFGHIJK"))
fmt.Println(strings.Map(func(r rune) rune {
if r < 'F' {
return -1
} else {
return r
}
}, "ABCDEFGHIJK"))
}Ausgabe
=== RUN TestMap
ABCDEFGHIJK
abcdefghijk
FGHIJK
--- PASS: TestMap (0.00s)
PASSString wiederholen
Kopiert den String entsprechend der angegebenen Anzahl. Eine negative Zahl führt zu panic.
func Repeat(s string, count int) stringBeispiel
func TestRepeat(t *testing.T) {
fmt.Println(strings.Repeat("a", 10))
fmt.Println(strings.Repeat("abc", 10))
}Ausgabe
=== RUN TestRepeat
aaaaaaaaaa
abcabcabcabcabcabcabcabcabcabc
--- PASS: TestRepeat (0.00s)
PASSString ersetzen
s ist der Quellstring, old ist der zu ersetzende Teil, new ist der Ersatzteil, n ist die Anzahl der Ersetzungen. Wenn n kleiner als 0 ist, wird unbegrenzt ersetzt.
func Replace(s, old, new string, n int) stringBeispiel
func TestReplace(t *testing.T) {
fmt.Println(strings.Replace("Hello this is golang", "golang", "c++", 1))
fmt.Println(strings.Replace("Hello this is golang", "o", "c", -1))
fmt.Println(strings.Replace("Hello this is golang", "o", "c", 1))
}Ausgabe
=== RUN TestReplace
Hello this is c++
Hellc this is gclang
Hellc this is golang
--- PASS: TestReplace (0.00s)
PASSPraktische Funktion für Replace, äquivalent zu strings.Replace(s, old, new, -1)
func ReplaceAll(s, old, new string) stringBeispiel
func TestReplaceAll(t *testing.T) {
fmt.Println(strings.ReplaceAll("Hello this is golang", "o", "c++"))
}Ausgabe
=== RUN TestReplaceAll
Hellc++ this is gc++lang
--- PASS: TestReplaceAll (0.00s)
PASSString trennen
Trennt den String s anhand des Teilstrings sep in ein String-Slice
func Split(s, sep string) []stringTrennt den String s anhand des Teilstrings sep in ein String-Slice, die Anzahl der Trennungen wird durch n bestimmt
func SplitN(s, sep string, n int) []stringTrennt den String s anhand des Teilstrings sep in ein String-Slice, das sep enthält
func SplitAfter(s, sep string) []stringTrennt den String s anhand des Teilstrings sep in ein String-Slice, das sep enthält, die Anzahl der Trennungen wird durch n bestimmt
func SplitAfterN(s, sep string, n int) []stringBeispiel
func TestSplit(t *testing.T) {
fmt.Printf("%q\n", strings.Split("this is go language", " "))
fmt.Printf("%q\n", strings.SplitN("this is go language", " ", 2))
fmt.Printf("%q\n", strings.SplitAfter("this is go language", " "))
fmt.Printf("%q\n", strings.SplitAfterN("this is go language", " ", 2))
}Ausgabe
=== RUN TestSplit
["this" "is" "go" "language"]
["this" "is go language"]
["this " "is " "go " "language"]
["this " "is go language"]
--- PASS: TestSplit (0.00s)
PASSGroß-/Kleinschreibung umwandeln
Wandelt englische Strings in Kleinbuchstaben um
func ToLower(s string) stringWandelt basierend auf der übergebenen unicode.SpecialCase in Kleinbuchstaben der entsprechenden Sprache um
func ToLowerSpecial(c unicode.SpecialCase, s string) stringWandelt englische Strings in Großbuchstaben um
func ToUpper(s string) stringWandelt basierend auf der übergebenen unicode.SpecialCase in Großbuchstaben der entsprechenden Sprache um
func ToUpperSpecial(c unicode.SpecialCase, s string) stringBeispiel
func TestLowerAndUpper(t *testing.T) {
fmt.Println(strings.ToLower("My name is jack,Nice to meet you!"))
fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
fmt.Println(strings.ToUpper("My name is jack,Nice to meet you!"))
fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "örnek iş"))
}Ausgabe
=== RUN TestLowerAndUpper
my name is jack,nice to meet you!
önnek iş
MY NAME IS JACK,NICE TO MEET YOU!
ÖRNEK İŞ
--- PASS: TestLowerAndUpper (0.00s)
PASSString trimmen
Trimmt beide Enden des Strings und löscht alle übereinstimmenden Teilstrings aus cutset
func Trim(s, cutset string) stringTrimmt das linke Ende des Strings und löscht alle übereinstimmenden Teilstrings aus cutset
func TrimLeft(s, cutset string) stringTrimmt das Präfix am linken Ende und löscht den übereinstimmenden Teilstring aus cutset. Wenn nicht übereinstimmend, wird der String s zurückgegeben
func TrimPrefix(s, suffix string) stringTrimmt das rechte Ende des Strings und löscht alle übereinstimmenden Teilstrings aus cutset
func TrimRight(s, cutset string) stringTrimmt das Suffix am rechten Ende und löscht den übereinstimmenden Teilstring aus cutset. Wenn nicht übereinstimmend, wird der String s zurückgegeben
func TrimSuffix(s, suffix string) stringBeispiel
func TestTrim(t *testing.T) {
fmt.Println(strings.Trim("!!this is a test statement!!", "!!!"))
fmt.Println(strings.TrimLeft("!!this is a test statement!!", "!!!"))
fmt.Println(strings.TrimRight("!!this is a test statement!!", "!!!"))
fmt.Println(strings.TrimPrefix("!!this is a test statement!!", "!!!"))
fmt.Println(strings.TrimSuffix("!!this is a test statement!!", "!!!"))
}Ausgabe
=== RUN TestTrim
this is a test statement
this is a test statement!!
!!this is a test statement
!!this is a test statement!!
!!this is a test statement!!
--- PASS: TestTrim (0.00s)
PASSString Builder
String Builder ist speichereffizienter als direkte String-Manipulation.
type Builder struct {
// interne Felder nicht öffentlich
}Beispiel
func TestBuilder(t *testing.T) {
builder := strings.Builder{}
builder.WriteString("hello")
builder.WriteString(" world")
fmt.Println(builder.Len())
fmt.Println(builder.String())
}Ausgabe
=== RUN TestBuilder
11
hello world
--- PASS: TestBuilder (0.00s)
PASSTIP
Versuchen Sie nicht, Builder als Wert zu übergeben. Wenn Sie strings.Builder beispielsweise als Funktionsparameter übergeben, wird das Programm panic auslösen.
strings: illegal use of non-zero Builder copied by valueIntern enthält es folgenden Code:
type Builder struct {
addr *Builder // eigene Adresse
buf []byte
}
func (b *Builder) copyCheck() {
if b.addr == nil {
b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
} else if b.addr != b {
panic("strings: illegal use of non-zero Builder copied by value")
}
}Wenn Builder als Wert kopiert wird, wird auch der Zeiger auf den internen Slice kopiert. Beide Builder schreiben in denselben Slice. Deshalb ist die Wertkopie nicht erlaubt.
String Replacer
Replacer ist speziell für das Ersetzen von Strings
func NewReplacer(oldnew ...string) *ReplacerBeispiel
func TestReplacer(t *testing.T) {
r := strings.NewReplacer("<", "<", ">", ">")
fmt.Println(r.Replace("This is <b>HTML</b>!"))
}Ausgabe
This is <b>HTML</b>!String Reader
Reader implementiert die Schnittstellen io.Reader, io.ReaderAt, io.ByteReader, io.ByteScanner, io.RuneReader, io.RuneScanner, io.Seeker und io.WriterTo.
func NewReader(s string) *ReaderBeispiel
func TestReader(t *testing.T) {
reader := strings.NewReader("abcdefghijk")
buffer := make([]byte, 20, 20)
read, err := reader.Read(buffer)
if err != nil {
log.Panic(err)
}
fmt.Println(read)
fmt.Println(string(buffer))
}Ausgabe
=== RUN TestReader
11
abcdefghijk
--- PASS: TestReader (0.00s)
PASS