Golang Sammenlign streng

Som programmerere kommer vi over tilfeller der vi trenger å sammenligne strenger. Dette kan være at vi sjekker for innspillet fra brukeren eller en lignende oppgave. Uansett hva behovet måtte være, er det viktig å vite hvordan du utfører streng sammenligning.

Gjennom denne artikkelen vil vi inspisere forskjellige måter og metoder for å utføre streng sammenligningsoperasjoner i Go -programmeringsspråket.

Metode 1 - Sammenligningsoperatører

Den mest grunnleggende formen for å sammenligne strenger er å bruke GO -sammenligningsoperatører. Følgende er noen sammenligningsoperatører du kan bruke:

1. == - Likhetskontroll
2. ! = - ikke lik
3. > = - større enn eller lik
4. <= - less than or equal to

La oss se på noen få eksempler.

Likestillingoperatør

Likestillingsoperatøren lar deg sjekke om verdien på venstre side tilsvarer den på høyre side.

Vi kan bruke denne operatøren til å sjekke om den ene strengen er lik den andre.

Et eksempel er som vist:

pakkehoved
Importer "FMT"
func main ()
str_1: = "mysql"
str_2: = "SQL"
fmt.Println (str_1 == str_2)

I eksemplet over sjekker vi om verdien av STR_1 -variabelen er lik verdien av STR_2 -variabelen.

Siden strengene ikke er like, returnerer programmet usant:

$ go run string_compare.gå
falsk

Det er godt å huske at likestillingsoperatøren sjekker for saksfølsomhet. Følgende sammenligning returnerer for eksempel falsk:

fmt.Println ("sql" == "sql")

Hvis du vil utføre en ufølsom sammenligning, kan du først konvertere strengene til små bokstaver eller store bokstaver (som du synes passer) eller bruk en innebygd metode (dekket senere).

Følgende eksempel viser hvordan du konverterer strengene til store eller små bokstaver:

fmt.Println (strenger.TOLOWER ("SQL") == "SQL")
fmt.Println (strenger.Toupper ("SQL") == "SQL")

Ovennevnte sammenligninger returnerer sanne ettersom begge strengene er like.

Ikke lik operatør

Du kan også bruke den ikke like store operatøren (!=). Det fungerer tett lik likestillingoperatøren, bortsett fra at den returnerer den negerte versjonen av resultatet. Derfor, hvis to strenger er like, returnerer den ikke like operatøren falsk.

Et eksempel er som vist:

pakkehoved
Importer "FMT"
func main ()
str_1: = "mysql"
str_2: = "SQL"
fmt.Println (STR_1 != str_2)

Her er de to strengene ikke like. Dette betyr at den ikke like operatøren returnerer sann.

:: utgang
ekte

Leksikografiske operatører

Du kan utføre den leksikografiske sammenligningen ved å bruke større enn, mindre enn, større enn eller lik, og mindre enn eller lik. Leksikografisk sammenligning sammenligner hvis strengene er av like lengde og hvis karakterene er i en lignende posisjon (alfabetisk).

Tenk på eksempelkoden vist nedenfor:

pakkehoved
Importer "FMT"
func main ()
fmt.Println ("ABCD"> "ABCD")
fmt.Println ("abcd" = "abcd")
fmt.Println ("defc" <= "abcd")

Eksempelprogrammet ovenfor utfører en leksikografisk sammenligning med de spesifiserte strengene. Den resulterende utgangen er som vist:

falsk
ekte
ekte
falsk

Metode 2 - Sammenlign () Metode

Strings-pakken gir oss en innebygd metode for å utføre strengsammenligning. Sammenlign () -metoden tar to strenger er dens argumenter.

Funksjonen kommer tilbake:

1. 0 Hvis de to strengene er like.
2. 1 Hvis den første strengen er større enn den andre.
3. -1 Hvis den første strengen er mindre enn den andre.

Merk: Strengens storhet og mindrehet bestemmes av en leksikografisk sammenligning.

Eksemplet nedenfor illustrerer hvordan du bruker sammenligning () -metoden.

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
str_1: = "Hei"
str_2: = "hei"
fmt.Println (strenger.Sammenlign (str_1, str_2))

Eksemplet ovenfor returnerer -1.

Vi kan også overføre bokstavelige strenger til metoden som:

fmt.Println (strenger.Sammenlign ("Hei", "Hei"))
fmt.Println (strenger.Sammenlign ("SQL", "SQL"))

Ovennevnte utdrag skal returnere en utdata som:

::produksjon
0
-1

Metode 3 - EqualFold () Metode

Som du vil legge merke til fra eksemplet ovenfor, er COMPARE () -metoden case-sensitiv. Derfor hvis to strenger ikke samsvarer med tilfeller, anser det dem som ikke er like.

Imidlertid kan det være lurt å utføre strengsammenligning uten å utføre en konvertering til store bokstaver eller små bokstaver.

I et slikt tilfelle kan vi bruke EqualFold () -metoden. Det fungerer på samme måte som sammenligningsmetoden () uten sakens følsomhet.

Tenk på eksemplet nedenfor:

fmt.Println (strenger.EqualFold ("SQL", "SQL"))
ekte

Funksjonen returnerer en boolsk sann.

Konklusjon

Denne guiden tar deg med på en omvisning i å bruke flere metoder for å utføre strengsammenligning på Go -programmeringsspråket.

Takk for at du leste!