Manipulacja łańcuchami w Go: Jak zaktualizować tekst
Manipulowanie łańcuchami ma fundamentalne znaczenie w tworzeniu oprogramowania; w końcu większość języków programowania zapewnia typ łańcuchowy. Łańcuch to ciąg znaków: liter, cyfr i symboli.
Manipulowanie łańcuchami jest przydatne w różnych zastosowaniach, od przetwarzania tekstu i analizy danych po tworzenie stron internetowych. Popularnymi operacjami manipulowania łańcuchami są konkatenacja, sprawdzanie poprawności danych, wyodrębnianie i formatowanie. Go udostępnia pakiet do manipulacji łańcuchami o nazwie „strings” w bibliotece standardowej.
Pakiet strun
Pakiet strings dostarcza różnych przydatnych funkcji do manipulowania łańcuchami i innych operacji. Pakiet zawiera funkcje operacji na podciągach, przycinania, porównywania ciągów, konwersji ciągów, budowania ciągów, dzielenia i nie tylko.
Możesz zaimportować pakiet strings, podając nazwę pakietu na liście importów.
import "strings"
Wyszukiwanie podciągów
Pakiet strings udostępnia trzy funkcje wyszukiwania podłańcuchów: funkcję Zawiera , funkcję ZawieraAny i funkcję ZawieraRune .
Funkcja Zawiera sprawdza, czy określony ciąg zawiera podciąg. Funkcja ZawieraAny sprawdza, czy łańcuch zawiera jakiekolwiek znaki w podłańcuchu, a funkcja ZawieraRune sprawdza, czy ciąg zawiera runę (znak Unicode).
import (
"fmt"
"strings"
)
func main() {
aString: = "Hello, World!"
substring: = "World"
characters: = "aeiou"
aRune: = 'o'
fmt.Println(strings.Contains(aString, substring)) // Output: true
fmt.Println(strings.ContainsAny(aString, characters)) // Output: true
fmt.Println(strings.ContainsRune(aString, aRune)) // Output: true
}
Możesz pobrać indeks podciągu za pomocą funkcji Index , IndexAny , IndexByte i IndexFunc . Funkcja Index zwraca indeks podłańcucha, jeśli występuje on w innym podanym ciągu. Funkcja IndexAny zwraca indeks pierwszego wystąpienia punktu kodu Unicode lub -1 , jeśli żaden ze znaków nie jest obecny.
import (
"fmt"
"strings"
)
func main() {
aString: = "Hello, world!"
substring: = "world"
chars: = "wrld"
byteCharacter: = byte('o')
aRune: = rune('o')
fmt.Println(strings.Index(aString, substring)) // Output: 7
fmt.Println(strings.IndexAny(aString, chars)) // Output: 7
fmt.Println(strings.IndexByte(aString, byteCharacter)) // Output: 4
f: = func(r rune) bool {
return r == 'o'
}
fmt.Println(strings.IndexFunc(aString, f)) // Output: 4
fmt.Println(strings.IndexRune(aString, aRune)) // Output: 4
}
IndexByte zwraca indeks pierwszego wystąpienia znaku bajtu w łańcuchu lub -1 . Funkcja IndexFunc zwraca indeks do łańcucha pierwszego punktu Unicode, który spełnia daną funkcję. Na koniec funkcja IndexRune zwraca indeks pierwszego wystąpienia punktu kodowego Unicode runy.
Zastępowanie podciągów w Go
Funkcje Replace i ReplaceAll pomagają w zastępowaniu podłańcuchów. Funkcja Replace przyjmuje ciąg, oryginalny podłańcuch oraz zastąpienie i kilka zamienników. Funkcja ReplaceAll przyjmuje tylko łańcuch, początkowy podłańcuch i zamiennik.
import (
"fmt"
"strings"
)
func main() {
theString: = "This is a test string to be modified."
fmt.Println(strings.Replace(theString, "is", "was", 1))
fmt.Println(strings.Replace(theString, "is", "was", -1))
fmt.Println(strings.ReplaceAll(theString, "is", "was"))
}
Zauważ, że możesz użyć zarówno metody Replace, jak i ReplaceAll, aby zastąpić każde wystąpienie w łańcuchu.
Dzielenie i łączenie ciągów
Pakiet strings zawiera funkcje Split , SplitAfter , SplitAfterN i SplitN służące do dzielenia ciągów, które zwracają wycinek ciągów.
Metoda Split dzieli się według określonego ogranicznika. Podobnie jak w przypadku metody Split , metoda SplitAfter dzieli ciąg znaków, ale w wynikach uwzględnia separator.
import (
"fmt"
"strings"
)
func main() {
s: = "This is a test string to be split."
fmt.Println(strings.Split(s, ""))
fmt.Println(strings.SplitAfter(s, ""))
fmt.Println(strings.SplitAfterN(s, "", 3))
fmt.Println(strings.SplitN(s, "", 3))
}
Metoda SplitAfterN jest podobna do funkcji SplitAfter z tą różnicą, że funkcja dzieli ciąg na określoną maksymalną liczbę podciągów. Metoda SplitN dzieli ciąg na określoną maksymalną liczbę bez uwzględniania separatora w podciągach.
Łańcuchy można łączyć za pomocą funkcji Join z pakietu strings . Funkcja Join przyjmuje wycinek i ogranicznik.
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Join([]string{"Hello", "World"}, ":"))
// Output: "Hello:World"
}
Manipulowanie etui na struny
Manipulowanie wielkością znaków jest przydatne w przypadku wielu zadań, w tym pracy z dokumentacją. Możesz użyć funkcji ToLower do małych liter, funkcji ToUpper do wielkich liter i funkcji ToTitle do wielkich liter w tytułach.
import (
"fmt"
"strings"
)
func main() {
s: = "This is a test string."
fmt.Println(strings.ToLower(s)) // this is a test string.
fmt.Println(strings.ToUpper(s)) // THIS IS A TEST STRING.
fmt.Println(strings.ToTitle(s)) // THIS IS A TEST STRING.
}
Budowanie strun w Go
Konstruktorzy ciągów to typ, który pozwala na wydajne łączenie w Go. Typ bytes.Buffer jest jednym z powszechnie używanych konstruktorów łańcuchów. Metoda bytes.Buffer implementuje powiększalny bufor bajtów z metodami odczytu i zapisu dla operacji, umożliwiając efektywne dołączanie ciągów bez konieczności tworzenia nowych kopii, w przeciwieństwie do operacji + i funkcji Join .
import (
"fmt"
"strings"
)
func main() {
var b strings.Builder
// Write some strings to the builder
b.WriteString("This ")
b.WriteString("is ")
b.WriteString("a ")
b.WriteString("test ")
b.WriteString("string.")
// Get the length of the builder
fmt.Println(b.Len())
// Convert the builder to a string
str: = b.String()
fmt.Println(str)
// Reset the builder
b.Reset()
// Write some more strings to the builder
b.WriteString("This ")
b.WriteString("is ")
b.WriteString("another ")
b.WriteString("test ")
b.WriteString("string.")
// Get the capacity of the builder
fmt.Println(b.Cap())
// Convert the builder to a string again
str = b.String()
fmt.Println(str)
}
Funkcja main pokazuje, jak można wykorzystać typ strings.Builder do efektywnego budowania łańcuchów. Metoda WriteString typu Strings.Builder rozszerza ciąg napisów jeden na drugi, a metoda Len zwraca długość zbudowanego ciągu.
Metoda String konwertuje zawartość konstruktora na ciąg, a metoda Reset resetuje konstruktora w celu dodatkowego budowania ciągów.
Metoda Cap zwraca pojemność konstruktora. To jest bieżące miejsce, które Go przydzieliło dla łańcucha.
Przycinanie strun w Go
Pakiet strings zapewnia również funkcje przycinania ciągów w funkcjach Trim , TrimLeft , TrimPrefix , TrimRight , TrimSpace i TrimSuffix .
import (
"strings"
"fmt"
)
func main() {
// the full string
s: = "Hello, World!"
// the element for the trim
prefix: = "Hello"
suffix: = "World!"
// trims a string by specified trim set
fmt.Println(strings.Trim(s, "!"))
// trims out by spaces in the beginning and end of the string
fmt.Println(strings.TrimSpace(s))
// trims from the left string by specified trim set
fmt.Println(strings.TrimLeft(s, "Hello"))
// trims out from the right string by specified trim set
fmt.Println(strings.TrimRight(s, "World!"))
// trims out a prefix
fmt.Println(strings.TrimPrefix(s, prefix))
// trims out a specific suffix
fmt.Println(strings.TrimSuffix(s, suffix))
}
Funkcja main pokazuje, jak można używać funkcji do przycinania. Różne funkcje przycinają ciąg s na różne sposoby:
Możesz formatować ciągi w Go
Standardowa biblioteka Go zawiera również pakiet fmt do formatowania ciągów znaków. Pakiet fmt używa czasowników formatujących w stylu języka C do efektywnego formatowania ciągów znaków w Go.
Dodaj komentarz