Manipulacja łańcuchami w Go: Jak zaktualizować tekst

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.

wynik operacji wymiany Go

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.

wynik operacji budowy strun

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:

wynikiem operacji przycinania

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

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *