Cititorii ca tine ajută la sprijinirea MUO. Când efectuați o achiziție folosind link-uri de pe site-ul nostru, este posibil să câștigăm un comision de afiliat. Citeşte mai mult.

Manipularea șirurilor este fundamentală în dezvoltarea software-ului; La urma urmei, majoritatea limbajelor de programare oferă un tip de șir. Un șir este o succesiune de caractere: litere, cifre și simboluri.

Manipularea șirurilor este utilă pentru diverse aplicații, de la procesarea textului și analiza datelor până la dezvoltarea web. Operațiunile populare de manipulare a șirurilor sunt concatenarea, validarea datelor, extragerea și formatarea. Go oferă un pachet de manipulare a șirurilor numit „șiruri” în biblioteca standard.

Pachetul de corzi

The siruri de caractere pachetul oferă diverse funcții utile pentru manipularea șirurilor și alte operațiuni. Pachetul include funcționalități pentru operațiuni cu subșiruri, tăierea, compararea șirurilor, conversia șirurilor, construirea șirurilor, împărțirea și multe altele.

instagram viewer

Puteți importa pachetul cu șiruri de caractere specificând numele pachetului în lista dvs. de importuri.

import"siruri de caractere"

Căutarea subșirurilor

The siruri de caractere pachetul oferă trei funcții pentru căutarea subșirurilor: the Conține funcția, cea ConțineOrice funcția, iar ConțineRune funcţie.

The Conține funcția verifică dacă șirul specificat conține subșirul. The ConțineOrice funcția verifică dacă șirul conține caractere în subșir și ConțineRune funcția verifică dacă șirul conține o rună (un caracter Unicode).

import (
"fmt"
"siruri de caractere"
)
funcprincipal() {
 aString := "Salut Lume!"
 subșir := "Lume"
 caractere := "aeiou"
 aRune := 'o'
 fmt. Println (șiruri. Conține (aString, subșir)) // Ieșire: adevărat
 fmt. Println (șiruri. ContainsAny (aString, caractere)) // Ieșire: adevărat
 fmt. Println (șiruri. ContainsRune (aString, aRune)) // Ieșire: adevărat
}

Puteți prelua indexul unui subșir cu ajutorul Index, IndexAny, IndexByte, și IndexFunc funcții. The Index funcția returnează indexul unui subșir, dacă apare într-un alt șir dat. The IndexAny funcția returnează indexul primei instanțe a un punct de cod Unicode sau -1 dacă niciunul dintre personaje nu este prezent.

import (
"fmt"
"siruri de caractere"
)
funcprincipal() {
 aString := "Salut Lume!"
 subșir := "lume"
 caractere := "lumea"
 byteCharacter := octet('o')
 aRune := rune('o')


 fmt. Println (șiruri. Index (aString, subșir)) // Ieșire: 7
 fmt. Println (șiruri. IndexAny (aString, caractere)) // Ieșire: 7
 fmt. Println (șiruri. IndexByte (aString, byteCharacter)) // Ieșire: 4
 f:= func(r rune)bool {
întoarcere r == 'o'
 }

 fmt. Println (șiruri. IndexFunc (aString, f)) // Ieșire: 4
 fmt. Println (șiruri. IndexRune (aString, aRune)) // Ieșire: 4
}

IndexByte returnează indexul primei instanțe a caracterului octet din șir sau -1. The IndexFunc funcția returnează indexul în șirul primului punct Unicode care satisface o funcție dată. În cele din urmă, cel IndexRune funcția returnează indexul primei instanțe a punctului de cod Unicode al runei.

Înlocuirea subșirurilor în Go

The A inlocui și Înlocuiește-le pe toate funcția ajută la înlocuirea subșirurilor. The A inlocui funcția preia șirul, subșirul original și înlocuirea și câteva înlocuiri. The Înlocuiește-le pe toate funcția preia numai șirul, subșirul inițial și înlocuirea.

import (
"fmt"
"siruri de caractere"
)
funcprincipal() {
 theString := „Acesta este un șir de test care trebuie modificat”.
 fmt. Println (șiruri. Înlocuiește (șirul, "este", "a fost", 1))
 fmt. Println (șiruri. Înlocuiește (șirul, "este", "a fost", -1))
 fmt. Println (șiruri. Înlocuiește tot (șirul, "este", "a fost"))
}

Observați că puteți utiliza atât Replace, cât și ReplaceAll pentru a înlocui fiecare apariție din șir.

Împărțirea și unirea șirurilor

The siruri de caractere pachetul conține Despică, SplitAfter, SplitAfterN, și SplitN funcții pentru împărțirea șirurilor care returnează o felie de șiruri.

The Despică metoda se împarte printr-un delimitator specificat. Similar cu Despică metoda, cea SplitAfter metoda împarte șirul, dar include separatorul în rezultatele sale.

import (
"fmt"
"siruri de caractere"
)
funcprincipal() {
 s := „Acesta este un șir de test care trebuie împărțit”.
 fmt. Println (șiruri. Split (s, " "))
 fmt. Println (șiruri. SplitAfter (s, " "))
 fmt. Println (șiruri. SplitAfterN(s, " ", 3))
 fmt. Println (șiruri. ÎmpărțițiN(i, " ", 3))
}

The SplitAfterN metoda este similară cu cea SplitAfter cu excepția faptului că funcția împarte șirul într-un maxim specificat de subșiruri. The SplitN metoda împarte șirul la un număr maxim specificat fără a include separatorul în subșiruri.

Puteți uni șiruri cu A te alatura funcția de la siruri de caractere pachet. The A te alatura funcția preia o felie și un delimitator.

import (
"fmt"
"siruri de caractere"
)
funcprincipal() {
 fmt. Println (șiruri. A te alatura([]şir{"Buna ziua", "Lume"}, ":"))
// Ieșire: „Bună ziua: Lumea”
}

Manipularea șirului de majuscule

Manipularea majusculei șirurilor este utilă pentru multe sarcini, inclusiv lucrul cu documentația. Puteți folosi Pentru a reduce funcția pentru minuscule, the În sus funcția pentru majuscule și ToTitle funcția pentru majusculele titlului.

import (
"fmt"
"siruri de caractere"
)
funcprincipal() {
 s := „Acesta este un șir de test”.
 fmt. Println (șiruri. Turnul(e) // acesta este un șir de test.
 fmt. Println (șiruri. Sus(e) // ACESTA ESTE UN ȘIR DE TEST.
 fmt. Println (șiruri. LaTitlu(e)) // ACESTA ESTE UN ȘIR DE TEST.
}

String Building în Go

Constructorii de șiruri sunt un tip care permite o concatenare eficientă în Go. The octeți. Tampon type este unul dintre constructorii de șiruri folosiți în mod obișnuit. The octeți. Tampon metoda implementează un buffer de octeți care poate crește cu metode de citire și scriere pentru operații, permițând anexări eficiente de șiruri fără a fi nevoie să facă copii noi, spre deosebire de + funcţionarea şi A te alatura funcţie.

import (
"fmt"
"siruri de caractere"
)
funcprincipal() {
var corzile b. Constructor


// Scrieți niște șiruri constructorului
 b. WriteString("Acest ")
 b. WriteString("este ")
 b. WriteString("A ")
 b. WriteString("Test ")
 b. WriteString("şir.")


// Obține lungimea constructorului
 fmt. Println (b. Len())


// Convertiți generatorul într-un șir
 str := b. Şir()
 fmt. Println (str)


// Resetează constructorul
 b. Resetare()


// Mai scrie niște șiruri pentru constructor
 b. WriteString("Acest ")
 b. WriteString("este ")
 b. WriteString("o alta ")
 b. WriteString("Test ")
 b. WriteString("şir.")


// Obține capacitatea constructorului
 fmt. Println (b. Capac())
// Convertiți generatorul într-un șir din nou
 str = b. Şir()
 fmt. Println (str)
}

The principal funcția demonstrează cum puteți utiliza siruri de caractere. Constructor tip pentru construirea eficientă a corzii. The WriteString metoda de Siruri de caractere. Constructor type extinde secvența de șiruri unul la altul și Len metoda returnează lungimea șirului construit.

The Şir metoda convertește conținutul constructorului într-un șir, iar Resetați metoda resetează generatorul pentru construirea de șiruri suplimentare.

The Capac metoda returnează capacitatea constructorului. Acesta este spațiul curent pe care Go l-a alocat pentru șir.

Tăierea șirurilor în Go

The siruri de caractere pachetul oferă, de asemenea, funcționalitate pentru tăierea șirurilor în Tunde, TrimLeft, TrimPrefix, TrimDreapta, TrimSpace, și TrimSuffix funcții.

import (
"siruri de caractere"
"fmt"
)
funcprincipal() {
// șirul complet
 s := "Salut Lume!"


// elementul pentru trim
 prefix := "Buna ziua"
 sufix:= "Lume!"


// decupează un șir după setul de tăiere specificat
 fmt. Println (șiruri. Trim (s, "!"))


// decupează cu spații la începutul și la sfârșitul șirului
 fmt. Println (șiruri. TrimSpace (e)


// decupează din șirul din stânga după setul de tăiere specificat
 fmt. Println (șiruri. TrimLeft (s, "Buna ziua"))


// decupează din șirul drept după setul de tăiere specificat
 fmt. Println (șiruri. TrimRight (s, "Lume!"))


// decupează un prefix
 fmt. Println (șiruri. TrimPrefix (s, prefix))
// decupează un sufix specific
 fmt. Println (șiruri. TrimSuffix (s, sufix))
}

The principal funcția demonstrează cum puteți utiliza funcțiile pentru tăiere. Diferitele funcții decupează s string în diferite moduri:

Puteți formata șirurile în Go

Biblioteca standard Go oferă, de asemenea, pachetul fmt pentru formatarea șirurilor. Pachetul fmt folosește verbe de formatare în stil C pentru formatarea eficientă a șirurilor în Go.