String Manipulation in Go: Hvordan oppdatere tekst

Strengemanipulasjon er grunnleggende i programvareutvikling; de fleste programmeringsspråk gir tross alt en strengtype. En streng er en sekvens av tegn: bokstaver, tall og symboler.

Strengemanipulering kommer godt med for ulike applikasjoner, fra tekstbehandling og dataanalyse til webutvikling. Populære strengmanipulasjonsoperasjoner er sammenkobling, datavalidering, utvinning og formatering. Go gir en strengmanipulasjonspakke kalt "strenger" i standardbiblioteket.

Strengepakken

De strenger pakken gir forskjellige nyttige funksjoner for strengmanipulering og andre operasjoner. Pakken inkluderer funksjonalitet for delstrengoperasjoner, trimming, sammenligning av strenger, strengkonvertering, strengbygging, splitting og mer.

Du kan importere strengpakken ved å spesifisere pakkenavnet i listen over importer.

import"strenger"

Søker etter understrenger

De strenger pakken inneholder tre funksjoner for å søke etter understrenger: Inneholder funksjon, den Inneholder alle funksjon, og Inneholder Rune funksjon.

De Inneholder funksjonen sjekker om den angitte strengen inneholder delstrengen. De Inneholder alle funksjonen sjekker om strengen inneholder noen tegn i understrengen, og Inneholder Rune funksjonen sjekker om strengen inneholder en rune (et Unicode-tegn).

import (
"fmt"
"strenger"
)
funchoved-() {
 aString := "Hei Verden!"
 understreng := "Verden"
 tegn := "aeiou"
 aRune := 'o'
 fmt. Println (strenger. Inneholder (aString, substring)) // Utdata: sant
 fmt. Println (strenger. Inneholder alle (en streng, tegn)) // Utdata: sant
 fmt. Println (strenger. InneholderRune (aString, aRune)) // Utdata: sant
}

Du kan hente indeksen til en delstreng med Indeks, Indekser enhver, IndexByte, og IndexFunc funksjoner. De Indeks funksjon returnerer indeksen til en delstreng, hvis den forekommer i en annen gitt streng. De Indekser enhver funksjonen returnerer indeksen for den første forekomsten av et Unicode-kodepunkt eller -1 hvis ingen av karakterene er til stede.

import (
"fmt"
"strenger"
)
funchoved-() {
 aString := "Hei Verden!"
 understreng := "verden"
 tegn := "wrld"
 byteCharacter := byte('o')
 aRune := rune('o')
 fmt. Println (strenger. Indeks (aString, substring)) // Utgang: 7
 fmt. Println (strenger. IndexAny (aString, tegn)) // Utgang: 7
 fmt. Println (strenger. IndexByte (aString, byteCharacter)) // Utgang: 4
 f := func(r rune)bool {
komme tilbake r == 'o'
 }

 fmt. Println (strenger. IndexFunc (aString, f)) // Utgang: 4
 fmt. Println (strenger. IndexRune (aString, aRune)) // Utgang: 4
}

IndexByte returnerer indeksen for den første forekomsten av byte-tegnet i strengen eller -1. De IndexFunc funksjon returnerer indeksen inn i strengen til det første Unicode-punktet som tilfredsstiller en gitt funksjon. Til slutt, den IndexRune funksjonen returnerer indeksen til den første forekomsten av Unicode-kodepunktet til runen.

Bytte ut understrenger i Go

De Erstatte og Erstatt Alle funksjonshjelp med å erstatte delstrenger. De Erstatte funksjonen tar inn strengen, den opprinnelige understrengen, og erstatningen og flere erstatninger. De Erstatt Alle funksjonen tar bare inn strengen, den første delstrengen og erstatningen.

import (
"fmt"
"strenger"
)
funchoved-() {
 strengen := "Dette er en teststreng som skal endres."
 fmt. Println (strenger. Erstatt (theString, "er", "var", 1))
 fmt. Println (strenger. Erstatt (theString, "er", "var", -1))
 fmt. Println (strenger. ReplaceAll (theString, "er", "var"))
}

Legg merke til at du kan bruke både Replace og ReplaceAll for å erstatte hver forekomst i strengen.

Splitting og sammenføyning av strenger

De strenger pakken inneholder Dele, SplitEtter, SplitAfterN, og SplitN funksjoner for å dele opp strenger som returnerer en del av strengene.

De Dele metoden deles med en spesifisert skilletegn. Ligner på Dele metoden, den SplitEtter metoden deler strengen, men den inkluderer separatoren i resultatene.

import (
"fmt"
"strenger"
)
funchoved-() {
 s := "Dette er en teststreng som skal deles."
 fmt. Println (strenger. Del (s, " "))
 fmt. Println (strenger. SplitEtter (s, " "))
 fmt. Println (strenger. SplitEtterN(er, " ", 3))
 fmt. Println (strenger. SplitN(er, " ", 3))
}

De SplitEtterN metoden ligner på SplitEtter funksjon bortsett fra at funksjonen deler strengen i et spesifisert maksimum av understrenger. De SplitN metoden deler strengen til et spesifisert maksimalt antall uten å inkludere skilletegn i understrengene.

Du kan slå sammen strenger med Bli med funksjon fra strenger pakke. De Bli med funksjonen tar inn et stykke og et skilletegn.

import (
"fmt"
"strenger"
)
funchoved-() {
 fmt. Println (strenger. Bli med([]streng{"Hallo", "Verden"}, ":"))
// Utgang: "Hei: Verden"
}

Manipulerende strengveske

Å manipulere strengveske er nyttig for mange oppgaver, inkludert jobber med dokumentasjon. Du kan bruke Å senke funksjon for små bokstaver, den Til Øvre funksjon for store bokstaver, og Til Tittel funksjon for tittelhus.

import (
"fmt"
"strenger"
)
funchoved-() {
 s := "Dette er en teststreng."
 fmt. Println (strenger. Nedre (r) // dette er en teststreng.
 fmt. Println (strenger. Øvre (e) // DETTE ER EN TESTTRENG.
 fmt. Println (strenger. Tiltittel (e) // DETTE ER EN TESTTRENG.
}

String Building in Go

Strengebyggere er en type som muliggjør effektiv sammenkobling i Go. De bytes. Buffer type er en av de mest brukte strengbyggerne. De bytes. Buffer metoden implementerer en vekstbar buffer av byte med lese- og skrivemetoder for operasjoner, noe som muliggjør effektive strengtilføyelser uten å måtte lage nye kopier, i motsetning til + drift og Bli med funksjon.

import (
"fmt"
"strenger"
)
funchoved-() {
var b strenger. Bygger
// Skriv noen strenger til byggherren
 b. WriteString("Dette")
 b. WriteString("er ")
 b. WriteString("a")
 b. WriteString("test")
 b. WriteString("streng.")
// Få lengden på byggherren
 fmt. Println (f. Len())
// Konverter byggeren til en streng
 str := b. String()
 fmt. Println (str)
// Tilbakestill byggeren
 b. Nullstille()
// Skriv noen flere strenger til byggherren
 b. WriteString("Dette")
 b. WriteString("er ")
 b. WriteString("en annen ")
 b. WriteString("test")
 b. WriteString("streng.")
// Få kapasiteten til byggherren
 fmt. Println (f. Lokk())
// Konverter byggeren til en streng igjen
 str = b. String()
 fmt. Println (str)
}

De hoved- funksjonen viser hvordan du kan bruke strenger. Bygger type for effektiv strengbygging. De WriteString metoden for Strenger. Bygger type utvider sekvensen av strenger til hverandre, og Len metoden returnerer lengden på den bygde strengen.

De String metoden konverterer byggerens innhold til en streng, og Nullstille metoden tilbakestiller byggeren for ytterligere strengbygging.

De Lokk metoden returnerer kapasiteten til byggherren. Dette er den gjeldende plassen som Go har tildelt strengen.

Stringtrimming i farten

De strenger pakken gir også funksjonalitet for trimming av strenger i Listverk, TrimLeft, TrimPrefix, TrimRight, TrimSpace, og TrimSuffix funksjoner.

import (
"strenger"
"fmt"
)
funchoved-() {
// hele strengen
 s := "Hei Verden!"
// elementet for trimmen
 prefiks := "Hallo"
 suffiks := "Verden!"
// trimmer en streng etter spesifisert trimmesett
 fmt. Println (strenger. Trim (s, "!"))
// trimmer ut med mellomrom i begynnelsen og slutten av strengen
 fmt. Println (strenger. TrimSpace(r)
// trimmer fra venstre streng med spesifisert trimsett
 fmt. Println (strenger. TrimLeft (s, "Hallo"))
// trimmer ut fra høyre streng med spesifisert trimsett
 fmt. Println (strenger. TrimRight (s, "Verden!"))
// trimmer ut et prefiks
 fmt. Println (strenger. TrimPrefix (s, prefiks))
// trimmer ut et spesifikt suffiks
 fmt. Println (strenger. TrimSuffiks (s, suffiks))
}

De hoved- funksjonen viser hvordan du kan bruke funksjonene til trimming. De forskjellige funksjonene trimmer s streng på forskjellige måter:

Du kan formatere strenger i Go

Go-standardbiblioteket gir også fmt-pakken for strengformatering. Fmt-pakken bruker formateringsverb i C-stil for effektiv strengformatering i Go.