Go Academy · Lekcja

Zastępowanie tekstu

Zastępuj wzorce za pomocą ReplaceAll

Zastępowanie tekstu to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Zastępowanie na podstawie wzorca

Wyrażenia regularne mogą nie tylko wyszukiwać tekst, ale również go przekształcać. ReplaceAllString zastępuje każde dopasowanie podanym ciągiem zastępczym.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.ReplaceAllString("a1b2c3", "#"))
}

Zastępowanie słów

Wzorzec taki jak cat|dog pozwala zastąpić kilka alternatyw w jednym przejściu.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("cat|dog")
    fmt.Println(re.ReplaceAllString("my cat and dog", "pet"))
}

Redukowanie białych znaków

Częstym zadaniem porządkowania tekstu jest zastąpienie ciągów białych znaków pojedynczą spacją za pomocą \s+.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\s+")
    fmt.Println(re.ReplaceAllString("too   many    spaces", " "))
}

Odwoływanie się do grup

W ciągu zastępczym $1 wstawia pierwszą grupę przechwytującą, a $2 — drugą. Pozwala to zmieniać kolejność dopasowanych elementów.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)-(\\d+)")
    fmt.Println(re.ReplaceAllString("12-34", "$2-$1"))
}

Odwołania do grup nazwanych

W przypadku grup nazwanych można użyć w zamian zapisu ${name}, aby zwiększyć czytelność.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(?P<y>\\d{4})-(?P<m>\\d{2})")
    fmt.Println(re.ReplaceAllString("2026-05", "${m}/${y}"))
}

Bezpieczne nawiasy klamrowe

Użyj zapisu z nawiasami klamrowymi ${1}, gdy po odwołaniu do grupy występuje tekst, aby $1 nie zostało pomylone z dłuższą nazwą.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)")
    fmt.Println(re.ReplaceAllString("7", "${1}px"))
}

Dosłowne zastępowanie

ReplaceAllLiteralString ignoruje odwołania $ i wstawia tekst zastępczy dokładnie w podanej postaci.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.ReplaceAllLiteralString("a1", "$money"))
}

Zastępowanie za pomocą funkcji

ReplaceAllStringFunc wywołuje Państwa funkcję dla każdego dopasowania i wstawia dowolny zwrócony przez nią tekst. Umożliwia to obliczanie zamienników.

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    out := re.ReplaceAllStringFunc("go is fun", strings.ToUpper)
    fmt.Println(out)
}

Obliczany zamiennik

Wewnątrz funkcji można dowolnie przekształcać każde dopasowanie — tutaj każdy dopasowany ciąg cyfr jest podwajany przez jego otoczenie.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    out := re.ReplaceAllStringFunc("id5 and id9", func(m string) string {
        return "<" + m + ">"
    })
    fmt.Println(out)
}

Maskowanie poufnych danych

Praktyczne zastosowanie: maskowanie liczb, na przykład ciągów cyfr przypominających numery kart, przed zapisaniem ich w logach.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\d{4}")
    fmt.Println(re.ReplaceAllString("card 1234 5678", "****"))
}

Praca na bajtach

Dostępne są również warianty działające na wycinkach bajtów, takie jak ReplaceAll, które odzwierciedlają metody dla napisów i służą do pracy z danymi binarnymi lub buforem.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    out := re.ReplaceAll([]byte("a1b2"), []byte("#"))
    fmt.Println(string(out))
}

Szybkie sprawdzenie

Jak wstawić pierwszą grupę przechwytującą w łańcuchu zastępczym?

Podsumowanie: zastępowanie tekstu

Nauczyli się Państwo przepisywać tekst:

ReplaceAllString zastępuje dopasowania; odwołania $1/${name} wskazują grupy.
ReplaceAllLiteralString pomija rozwijanie odwołań.
ReplaceAllStringFunc oblicza każdy zamiennik.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\w+)\\s(\\w+)")
    fmt.Println(re.ReplaceAllString("Ada Lovelace", "$2, $1"))
}

Często zadawane pytania

Czy lekcja „Zastępowanie tekstu” jest bezpłatna?

Tak — pełny tekst „Zastępowanie tekstu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Zastępowanie tekstu”?

Zastępuj wzorce za pomocą ReplaceAll Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Zastępowanie tekstu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy