Čtenáři jako vy pomáhají podporovat MUO. Když provedete nákup pomocí odkazů na našich stránkách, můžeme získat provizi přidružené společnosti. Přečtěte si více.

Manipulace s řetězci je při vývoji softwaru zásadní; většina programovacích jazyků koneckonců poskytuje typ řetězce. Řetězec je posloupnost znaků: písmena, čísla a symboly.

Manipulace s řetězci se hodí pro různé aplikace, od zpracování textu a analýzy dat až po vývoj webu. Populární operace manipulace s řetězci jsou zřetězení, ověřování dat, extrakce a formátování. Go poskytuje balíček pro manipulaci s řetězci s názvem „strings“ ve standardní knihovně.

Balíček řetězců

The struny balíček poskytuje různé užitečné funkce pro manipulaci s řetězci a další operace. Balíček obsahuje funkce pro operace podřetězců, ořezávání, porovnávání řetězců, konverzi řetězců, vytváření řetězců, dělení a další.

Balíček řetězců můžete importovat zadáním názvu balíčku v seznamu importů.

import"struny"

Hledání podřetězců

The struny balíček poskytuje tři funkce pro vyhledávání podřetězců: the Obsahuje funkce, Obsahuje Any funkce a ObsahujeRune funkce.

instagram viewer

The Obsahuje funkce zkontroluje, zda zadaný řetězec obsahuje podřetězec. The Obsahuje Any funkce zkontroluje, zda řetězec obsahuje nějaké znaky v podřetězci, a ObsahujeRune funkce zkontroluje, zda řetězec obsahuje runu (znak Unicode).

import (
"fmt"
"struny"
)
funchlavní() {
 aString := "Ahoj světe!"
 podřetězec := "Svět"
 znaky := "aeiou"
 aRune := 'Ó'
 fmt. Println (řetězce. Obsahuje (aString, podřetězec)) // Výstup: true
 fmt. Println (řetězce. ContainsAny (aString, znaky)) // Výstup: true
 fmt. Println (řetězce. ContainsRune (aString, aRune)) // Výstup: true
}

Index podřetězce můžete načíst pomocí Index, IndexAny, IndexByte, a IndexFunc funkcí. The Index funkce vrací index podřetězce, pokud se vyskytuje v jiném daném řetězci. The IndexAny funkce vrací index první instance bod v kódu Unicode nebo -1 pokud není přítomna žádná z postav.

import (
"fmt"
"struny"
)
funchlavní() {
 aString := "Ahoj světe!"
 podřetězec := "svět"
 znaky := "wrld"
 byteCharacter := byte('Ó')
 aRune := runa('Ó')


 fmt. Println (řetězce. Index (aString, podřetězec)) // Výstup: 7
 fmt. Println (řetězce. IndexAny (aString, znaky)) // Výstup: 7
 fmt. Println (řetězce. IndexByte (aString, byteCharacter)) // Výstup: 4
 f:= func(r runa)bool {
vrátit se r == 'Ó'
 }

 fmt. Println (řetězce. IndexFunc (aString, f)) // Výstup: 4
 fmt. Println (řetězce. IndexRune (aString, aRune)) // Výstup: 4
}

IndexByte vrátí index první instance bajtového znaku v řetězci nebo -1. The IndexFunc funkce vrátí index do řetězce prvního bodu Unicode, který splňuje danou funkci. Konečně, IndexRune funkce vrací index první instance bodu kódu Unicode runy.

Výměna podřetězců v Go

The Nahradit a Vyměnit vše funkce pomáhá s nahrazením podřetězců. The Nahradit funkce přijímá řetězec, původní podřetězec a náhradu a několik nahrazení. The Vyměnit vše funkce přijímá pouze řetězec, počáteční podřetězec a náhradu.

import (
"fmt"
"struny"
)
funchlavní() {
 theString := "Toto je testovací řetězec, který se má upravit."
 fmt. Println (řetězce. Nahradit (řetězec, "je", "byl", 1))
 fmt. Println (řetězce. Nahradit (řetězec, "je", "byl", -1))
 fmt. Println (řetězce. Nahradit vše (řetězec, "je", "byl"))
}

Všimněte si, že můžete použít jak Nahradit, tak Nahradit vše k nahrazení každého výskytu v řetězci.

Dělení a spojování strun

The struny balení obsahuje Rozdělit, SplitAfter, SplitAfterN, a SplitN funkce pro rozdělení řetězců, které vracejí část řetězců.

The Rozdělit metoda rozdělí zadaným oddělovačem. Podobné jako Rozdělit metoda, SplitAfter metoda rozdělí řetězec, ale ve svých výsledcích zahrnuje oddělovač.

import (
"fmt"
"struny"
)
funchlavní() {
 s := "Toto je testovací řetězec, který se má rozdělit."
 fmt. Println (řetězce. Rozdělit (s, " "))
 fmt. Println (řetězce. SplitAfter (s, " "))
 fmt. Println (řetězce. SplitAfterN(s, " ", 3))
 fmt. Println (řetězce. SplitN(s, " ", 3))
}

The SplitAfterN metoda je podobná SplitAfter funkce kromě toho, že funkce rozděluje řetězec na určený maximální počet podřetězců. The SplitN metoda rozdělí řetězec na zadaný maximální počet bez zahrnutí oddělovače do podřetězců.

Řetězce můžete spojit pomocí Připojit funkce z struny balík. The Připojit funkce přijímá řez a oddělovač.

import (
"fmt"
"struny"
)
funchlavní() {
 fmt. Println (řetězce. Připojit se([]tětiva{"Ahoj", "Svět"}, ":"))
// Výstup: "Hello: World"
}

Manipulační pouzdro na strunu

Manipulace s pouzdrem na strunu je užitečná pro mnoho úkolů, včetně práci s dokumentací. Můžete použít Snížit funkce pro malá písmena, ToUpper funkce pro psaní velkých písmen a ToTitle funkce pro psaní malých a velkých písmen.

import (
"fmt"
"struny"
)
funchlavní() {
 s := "Toto je testovací řetězec."
 fmt. Println (řetězce. ToLower (s)) // toto je testovací řetězec.
 fmt. Println (řetězce. Horní (s)) // TOTO JE TESTOVACÍ ŘETĚZEC.
 fmt. Println (řetězce. Název (y)) // TOTO JE TESTOVACÍ ŘETĚZEC.
}

String Building in Go

Tvůrci řetězců jsou typem, který umožňuje efektivní zřetězení v Go. The bajtů. Buffer type je jedním z běžně používaných stavitelů strun. The bajtů. Buffer metoda implementuje rozšiřitelný buffer bajtů s metodami čtení a zápisu pro operace, což umožňuje efektivní připojování řetězců bez nutnosti vytvářet nové kopie, na rozdíl od + provoz a Připojit funkce.

import (
"fmt"
"struny"
)
funchlavní() {
var b struny. Stavitel


// Napište nějaké řetězce do tvůrce
 b. WriteString("Tento ")
 b. WriteString("je ")
 b. WriteString("a")
 b. WriteString("test ")
 b. WriteString("tětiva.")


// Získání délky stavitele
 fmt. Println (b. Len())


// Převede tvůrce na řetězec
 str := b. Tětiva()
 fmt. Println (str)


// Resetujte tvůrce
 b. Reset()


// Napište nějaké další řetězce do tvůrce
 b. WriteString("Tento ")
 b. WriteString("je ")
 b. WriteString("další ")
 b. WriteString("test ")
 b. WriteString("tětiva.")


// Získání kapacity stavitele
 fmt. Println (b. Víčko())
// Znovu převede builder na řetězec
 str = b. Tětiva()
 fmt. Println (str)
}

The hlavní funkce ukazuje, jak můžete použít struny. Stavitel typ pro efektivní stavbu strun. The WriteString metoda Struny. Stavitel type rozšiřuje posloupnost řetězců jeden na druhého a Len metoda vrací délku sestaveného řetězce.

The Tětiva metoda převede obsah tvůrce na řetězec a Resetovat metoda resetuje tvůrce pro další vytváření řetězců.

The Víčko metoda vrací kapacitu stavitele. Toto je aktuální prostor, který Go přidělil pro řetězec.

Ořezávání strun v Go

The struny balíček také poskytuje funkce pro ořezávání řetězců v Oříznout, TrimLeft, TrimPrefix, TrimRight, TrimSpace, a TrimSuffix funkcí.

import (
"struny"
"fmt"
)
funchlavní() {
// celý řetězec
 s := "Ahoj světe!"


// prvek pro oříznutí
 předpona := "Ahoj"
 přípona := "Svět!"


// ořízne řetězec zadanou sadou trimování
 fmt. Println (řetězce. Oříznout (s, "!"))


// ořezává o mezery na začátku a na konci řetězce
 fmt. Println (řetězce. TrimSpace (s))


// ořízne z levého řetězce zadanou sadou trimování
 fmt. Println (řetězce. TrimLeft (s, "Ahoj"))


// ořízne z pravého řetězce pomocí zadané trimovací sady
 fmt. Println (řetězce. TrimRight (s, "Svět!"))


// ořízne předponu
 fmt. Println (řetězce. TrimPrefix (s, prefix))
// ořízne konkrétní příponu
 fmt. Println (řetězce. TrimSuffix (s, přípona))
}

The hlavní funkce ukazuje, jak můžete použít funkce pro oříznutí. Různé funkce oříznou s řetězec různými způsoby:

Můžete formátovat řetězce v Go

Standardní knihovna Go také poskytuje balíček fmt pro formátování řetězců. Balíček fmt používá formátovací slovesa ve stylu C pro efektivní formátování řetězců v Go.