Golang -strenger

En streng refererer til en sekvens med ett eller flere tegn, inkludert bokstaver, tall og spesialtegn. Strenger er et kritisk konsept i de fleste programmeringsspråk til tross for den forenklede definisjonen.

Dette er fordi strenger hjelper oss å jobbe med tekstinformasjon i programmene våre. Det er vanligvis vanskelig å bygge en ikke-triviell applikasjon uten å bruke strenger.

I denne guiden vil vi dekke det grunnleggende om å jobbe med strenger i Go -programmeringsspråket.

Hva er en streng?

I Go, omtaler vi en streng som en skrivebeskyttet bytes. Vi kan lage en streng i Go ved å omslutte sekvensen av tegn i doble sitater eller bak sitater.

Husk at metoden du bruker for å lage en streng i Go Matters.

Bruke ryggen (“) for å lage en streng i go skaper en rå streng bokstavelig. En rå streng bokstavelig betyr at strengen kan inneholde et hvilket som helst tegn bortsett fra en ryggen.

Følgende eksempel viser en rå streng bokstavelig.

Raw_string: = 'Dette er en streng'

I motsetning til tolkede strenglitteraler laget med doble sitater, har tilbakeslagskarakterer ingen spesiell betegnelse i en rå streng bokstavelig. For eksempel, \ n, som kan sette inn et nytt linjekarakter i tolkede strenger, skriver vi det ut som i rå strenglitteraler.

For å lage en tolket streng bokstavelig i GO, lukker du settet med tegn i dobbeltkjørt, som vist i eksemplet nedenfor:

tolket_string: = "Dette er en streng"

Her tolkes tilbakeslagskarakterer for å ha en spesiell betydning. For å sette inn en ny linje i strengen, kan vi for eksempel bruke \ n som:

tolket_string: = "Dette er \ n en streng"

Det er vanlig å bruke tolket streng bokstavelig da de lar deg legge til spesialtegn og rømningssekvenser.

Gå, skriv inn streng

Du kan skrive ut en streng i Go ved å bruke Println () -metoden fra FMT -pakken. Forsikre deg om å importere pakken før du ringer til metoden. Et eksempelkode er som vist:

pakkehoved
Importer "FMT"
func main ()
fmt.Println ("Dette er en streng")

Ovennevnte kode bruker FMT.Println () metode for å skrive ut en tolket streng bokstavelig. Du kan også lagre en streng som en variabel og referere den til i metoden som vist:

pakkehoved
Importer "FMT"
func main ()
my_string: "dette er en streng"
fmt.Println (my_string)

Strengoperasjoner i Go

Det er en samling av operasjoner du kan utføre på strengtyper. GO gir et sett med metoder for å utføre strengoperasjoner i Strings -pakken.

https: // pkg.gå.dev/strenger

La oss se på noen få operasjoner du kan utføre på strenger.

Strengkonturasjon

Strengkonturering refererer til teknikken for å kombinere to eller flere strenglitteraler sammen for å lage en ny streng.

I GO kan vi sammenkoble strenger ved hjelp av tilleggsoperatøren (+).

La oss for eksempel kombinere strengene “Linux” og “hint” som vist.

pakkehoved
Importer "FMT"
func main ()
fmt.Println ("Linux" + "hint")

Hvis vi kjører koden over, bør vi få en utdata som:

$ go run golang_strings.gå
Linuxhint

Husk at du ikke kan bruke tilleggsoperatøren (+) med verdier av forskjellige typer. Hvis du for eksempel prøver å sammenkoble en streng og en int, vil du få en feil som:

fmt.Println ("Linux" + 12)

Koden over returnerer en feil som:

Ugyldig operasjon: "Linux" + 12 (uoverensstemmede typer Untyped String og Untyped Int)

En måte å overvinne dette på er å omslutte begge verdiene til dobbeltkvoter. Dette konverterer den numeriske verdien til en streng, slik at du kan utføre strengkonturasjon.

Strengkonturering resulterer alltid i en ny streng som du kan lagre i en variabel og gjenbruk i andre deler av programmet ditt.

Konverter streng til små bokstaver eller store bokstaver

Som nevnt gir Go oss Strings -pakken, som lar deg utføre operasjoner på strengtyper.

To nyttige metoder fra pakken er Tolower og Toupper, som konverterer en streng til henholdsvis små og store bokstaver.

Merk: I GO er strengtyper uforanderlige. Dette betyr at du ikke kan endre den opprinnelige verdien av strengen når den er opprettet når den er opprettet.

Eksemplet nedenfor konverterer strengen “Linuxhint” til små bokstaver.

pakkehoved
Importer "FMT"
importere "strenger"
func main ()
my_string: = "linuxhint"
fmt.Println (strenger.Tolower (My_String))

Tolower () -funksjonen tar strengen for å konvertere til små bokstaver som argument. Den returnerer deretter sekvensen av tegn på strengen konvertert til små bokstaver. Funksjonen returnerer en ny streng, ettersom strenger er uforanderlige datatyper.

Hvis vi kjører ovennevnte kode, bør vi få en utdata som:

Linuxhint

For å konvertere en streng til store bokstaver, kan vi bruke toUpper () -metoden, som vist i eksemplet nedenfor:

my_string: = "linuxhint"
fmt.Println (strenger.Toupper (my_string))

Den resulterende strengen er som vist:

Linuxhint

Få strenglengde

For å få lengden på en streng i Go, kan du bruke Len () -metoden og passere strengen som argument.

Metoden vil returnere antall tegn i strengen.

For eksempel:

my_string: = "linuxhint"
fmt.Println (Len (My_String))

Når vi har kjørt koden over, bør vi få antall tegn på strengen som:

$ go run golang_strings.gå
9

Antall tegn, i dette tilfellet, refererer til ethvert tegn vedlagt i doble sitater, inkludert symboler og andre spesialtegn.

Sjekk om strengen inneholder

Du kan også søke etter en substring i go ved hjelp av contacts -metoden. Metoden aksepterer hovedstrengen for å søke etter substring og substring for å søke og som argumentene.

Funksjonen returnerer deretter en boolsk verdi hvis substringen er funnet og falsk ellers.

Tenk på eksemplet som er vist nedenfor:

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
full_string: = "Velkommen til go -programmeringen Langugae!""
fmt.Println (strenger.Inneholder (full_string, "go"))

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

$ go run golang_strings.gå
ekte

Substring “Go” finnes i full_stringvariabelen; Funksjonen returnerer sann.

Konklusjon

Denne opplæringen dekker det grunnleggende om å jobbe med strenger i Go. Hvis du kommer i gang, kan du sjekke opplæringsprogrammer om emnet for å lære mer. Du kan også sjekke dokumentasjonen for lagt til informasjon.