Golang delt streng

Strengmanipulering er en av de mest grunnleggende oppgavene på ethvert programmeringsspråk. Du kan trekke ut strenger, søkestrenger, bestille strenger og mange flere operasjoner ved hjelp av forskjellige strengmanipulasjonsteknikker.

En slik oppgave med strengmanipulering er strengdeling. Når du har en lang streng, enten fra brukerinngang, en fil, database eller miljøvariabler, kan det hende du må dele opp i mindre biter og utføre operasjoner på hver. Et eksempel vil være å dele en streng fra en komma-separert fil med kommaene som avgrenseren.

Ved hjelp av denne guiden lærer du forskjellige splitting av en streng i Go -programmeringsspråket.

Strenger.Split () funksjon

Go er et enormt programmeringsspråk som følger med mange verktøy og funksjonaliteter ut av boksen. Ved hjelp av strengpakken fra standardbiblioteket kan vi bruke Split () -funksjonen til å dele en streng basert på en spesifikk avgrensning.

Syntaksen til funksjonen er som vist:

func split (str, sep string) [] streng

Funksjonen tar strengen og avgrenseren som argumenter. Den returnerer deretter en skive av strengene, hvor hvert element i skiven er en substring atskilt av avgrenseren.

La oss ta eksemplet nedenfor:

pakkehoved
import (
"FMT"
"Strenger"
func main ()
Path_str: = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:"
Sti: = Strenger.Split (Path_str, ":")
fmt.Println (sti)

I eksemplet over har vi en variabel path_str som holder utgangen fra banemiljøvariabelen i Linux.

Vi bruker deretter split () -metoden for å skille hver verdi av banen med avgrenseren som tykktarmen (:)

Når vi har kjørt koden over, bør vi få en utdata som vist:

[/usr/local/sbin/usr/local/bin/usr/sbin/usr/bin/sbin/bin/usr/games/usr/local/games]

Når vi har skiven av strenger, kan vi bruke indeksnotasjon for å få tilgang til hvert element som vist:

fmt.Println (sti [0])

Ovennevnte skal returnere elementet ved indeks 0 som vist i utgangen nedenfor:

/usr/local/sbin

På grunn av dens enkelhet og mangfold, er dette sannsynligvis den du trenger når du trenger å dele en streng i Go.

Strenger.Splitn ()

Splitn () -metoden fra Strings -pakken lar deg skille en streng basert på den spesifiserte avgrenseren. I motsetning til Split () -metoden, tar Splitn -metoden imidlertid tre argumenter, som vist ved syntaks nedenfor:

func splitaftern (str, sep string, m int) [] streng

Splitn () -funksjonen lar deg spesifisere strengen for å skille, avgrenser og antall strenger som skal inkluderes i skiven.

Hvis antallet underlag som skal inkluderes i skiven tilsvarer 0, returnerer funksjonen null.

Tenk på eksemplet nedenfor:

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
Path_str: = "Samsung, Apple, Microsoft, Amazon, Google"
Sti: = Strenger.Splitn (Path_str, ",", 3)
fmt.Println (sti)

I dette eksemplet bruker vi en komma-separert streng. Vi bruker deretter splitn () -metoden for å trekke ut substringen basert på komma. Vi spesifiserer også antall elementer i skiven.

Den resulterende utgangen er som vist:

[Samsung Apple Microsoft, Amazon, Google]

Merk at funksjonen inkluderer strengen etter antall elementer som en enkelt streng.

Strenger.Splitafter

Strings -pakken er veldig mangfoldig. Det tilbyr også splitafter () -funksjonen. Det fungerer på samme måte som Split () -metoden, men beholder avgrenserne etter hver substring i skiven.

Vend oppmerksomheten mot koden nedenfor:

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
Path_str: = "Samsung, Apple, Microsoft, Amazon, Google"
Sti: = Strenger.Splitafter (Path_str, ",")
fmt.Println (sti)

Eksemplet ovenfor bruker splitafter () -metoden for å dele strengen basert på komma som avgrensning. Vi bevarer også avgrenser etter hvert element som vist i utgangen nedenfor:

[Samsung, Apple, Microsoft, Amazon, Google]

Strenger.Splitaftern ()

Du gjettet det. Denne funksjonen fungerer på samme måte som strengene.Splitn () -metode. Dette lar deg spesifisere nummeret på substringen som skal inkluderes i skiven.

Et eksempel er vist nedenfor:

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
Path_str: = "Samsung, Apple, Microsoft, Amazon, Google"
Sti: = Strenger.Splitafter (Path_str, ",")
fmt.Println (sti)

Den resulterende utgangen:

[Samsung, Apple, Microsoft, Amazon, Google]

Strenger.Enger()

Strengene.Felt () -metoden lar deg dele strenger etter de tilgjengelige hvite rommene. I motsetning til splitafter () og splitaftern (), inkluderer denne metoden ikke hvitespasene i skiven.

Hvis du ikke bryr deg om hvilken hvitrom, er dette sannsynligvis den beste metoden for deg.

Tenk på et eksempel som vist:

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
Path_str: = "\ nsamsung \ t Apple \ V Microsoft \ r Amazon Google"
Sti: = Strenger.Felt (Path_str)
fmt.Println (sti)

Funksjonen tar strengen og deler den i alle tilgjengelige hvitfarer.

Et eksempelutgang er som vist:

[Samsung Apple Microsoft Amazon Google]

Konklusjon

Strenger er utrolige i Go -programmeringsspråket. Derfor er det å forstå hvordan du utfører forskjellige handlinger på dem, som vist i denne guiden.

Fortsett å øve og lykkelig koding!