Golang Concat Strings

Strengkonturering refererer til prosessen med å kombinere to eller flere strenger for å danne en enkelt streng. Det er en av de essensielle strengoperasjonene i programmering.

I denne guiden vil vi implodere forskjellige metoder for å utføre strengkonturering i Go -programmeringsspråket.

Det grunnleggende

La oss starte med de mest grunnleggende delene av alle. Hvordan lage en streng i Go?

Vi kan lage en streng ved å omslutte karakterene i dobbeltkjørt.

For eksempel oppretter koden nedenfor en streng og lagrer den til variabelen STR.

STR: = "Hello World"

Bruke doble sitater skaper en tolket streng bokstavelig som inkluderer spesialtegn som Whitespaces.

For å lage en bokstavelig streng, kan du bruke back-picks, som vist i eksemplet nedenfor:

STR: = 'Hello World'

En bokstavelig streng i Go støtter ikke bruk av spesialtegn, inkludert rømningssekvenser.

String concatenation - tilleggsoperatøren

Hvis du leter etter den smertefrie og enkleste måten å sammenfatte strenger, vil du sannsynligvis velge Plus (|+) -operatøren.

Ved hjelp av pluss (+) -operatøren kan du kombinere flere strenger til en enkelt strengverdi som vist:

pakkehoved
func main ()
str_1: = "Velkommen til"
str_2: = "Linuxhint"
full_string: = str_1 + str_2

Eksemplet over bruker tilleggsoperatøren til å kombinere to strenger. Vi kan deretter lagre resultatet i variabelen.

Du kan også utføre strengkonturering ved hjelp av noen av utskriftsmetodene fra FMT -pakken. Tenk på eksemplet nedenfor:

fmt.Println ("Velkommen til" + "Linuxhint")

Funksjonen tar de to strenglitteralene og kombinerer dem til en enkelt streng.

Du kan også passere to eller flere strenger til hvilken som helst utskriftsmetode fra FMT -pakken uten å bruke tilleggsoperatøren. Funksjonene vil kombinere strengene og legge til et mellomrom mellom dem.

Ta en titt på eksemplet nedenfor:

fmt.Println ("Velkommen til", "Linuxhint.")

Dette eksemplet fører strengen til sammenkobling som parametere atskilt med komma. Den resulterende strengen er som vist:

Velkommen til Linuxhint.

Strenger.Bli med () Metode

Vi kan også bruke Join () -metoden fra Strings -pakken for å utføre strengkonturasjon. Funksjonssyntaksen er som vist:

func join (a [] string, seperator string) string

Funksjonen tar to argumenter. Den første er en skive strengtyper, og den andre er en streng som beskriver separatoren.

Funksjonen returnerer deretter en enkelt streng som er sammenkoblet fra verdiene til skiven.

Tenk eksemplet vist nedenfor:

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
str: = [] streng "velkomst", "til", "linuxhint"
concat_str: = strenger.Bli med (str, "")
fmt.Println (concat_str)

Funksjonen tar strengskiveelementene og kombinerer dem til en enkelt streng ved hjelp av et rom som separator.

Den resulterende verdien er som:

Velkommen til Linuxhint

Strengformatering - Sprintf

Vi kan også bruke strengformateringsmønstre levert av Sprintf-, Sprint- og Sprintln -metodene fra FMT -pakken.

Følgende eksempel illustrerer hvordan du utfører strengkonfigurasjon ved bruk av Sprintf () -metoden.

str_1: = "Hei"
str_2: = "verden"
Concated_string: = fmt.Sprintf ("%S%S", STR_1, STR_2)
fmt.Println (concated_string)

Her bruker vi %s formatter til å sammenkoble to strenger ved bruk av Sprintf () -metoden.

Byes.Buffer () -metode

Golang inneholder en bytepakke som gir en buffertype, en buffer med variabel størrelse med byte med lese/skrive metoder.

Vi kan skrive strenger ved hjelp av Writestring -metoden, slik at vi kan forvandle dem til en streng.

Et eksempel er som vist:

pakkehoved
import (
"byte"
"FMT"
)
func main ()
str_1: = "Hei"
str_2: = "verden"
var concat byte.Buffer
konkat.Writestring (STR_1)
konkat.Writestring (STR_2)
fmt.Println (Concat.Streng ())

WritString () -metoden legger strengen til byte.buffertype.

Strenger.Builder () -metode

Strings -pakken gir oss også en byggherrtype som lar oss bygge strenger. Den har en Writestring -metode som ligner på de som er gitt av Bytes -pakken.

Tenk på eksemplet:

pakkehoved
import (
"FMT"
"Strenger"
)
func main ()
str_1: = "Hei"
str_2: = "verden"
var Concat Strings.Bygger
konkat.Writestring (STR_1)
konkat.Writestring (STR_2)
fmt.Println (Concat.Streng ())

Sammendrag

Denne guiden dekket forskjellige teknikker for å utføre strengkonturering i GO. Ved hjelp av plussoperatøren kan du legge til to eller flere strenger sammen. Du kan også velge andre metoder, inkludert sammenføyningsmetoden, Sprintf, buffer og mer.