strings

Il pacchetto strings implementa semplici funzioni per operare su stringhe codificate in UTF-8, in pratica è un pacchetto di utility per operare con le stringhe.

Documentazione ufficiale: strings package - strings - Go Packages

TIP

Go supporta nativamente i caratteri UTF8, tutte le operazioni sulle stringhe sono basate su UTF8.

Importazione

import (
   "strings"
)

Di seguito verranno spiegati con esempi le funzioni più comuni.

Clonare una Stringa

func Clone(s string) string

Alloca una nuova memoria per la copia clonata, se viene passata una stringa vuota, non alloca memoria e restituisce una stringa vuota.

func TestClone(t *testing.T) {
   ori := "hello mondo"
   copys := strings.Clone(ori)
   fmt.Println(ori, copys)
   fmt.Println(&ori, &copys)
}

=== RUN   TestClone
hello mondo hello mondo
0xc00005e5d0 0xc00005e5e0
--- PASS: TestClone (0.00s)
PASS

Confrontare Stringhe

func Compare(a, b string) int

Confronta le stringhe a e b in ordine lessicografale, se a>b restituisce 1, a<b restituisce -1, a=b restituisce 0.

func TestCompare(t *testing.T) {
  fmt.Println(strings.Compare("abc", "abe"))
  fmt.Println(strings.Compare("abcd", "abe"))
  fmt.Println(strings.Compare("abijk", "abe"))
  fmt.Println(strings.Compare("abe", "abe"))
}

=== RUN   TestCompare
-1
-1
1
0
--- PASS: TestCompare (0.00s)
PASS

Contiene una Sottosringa

func Contains(s, substr string) bool

Verifica se una stringa s contiene una sottostringa substr

func TestContains(t *testing.T) {
  fmt.Println(strings.Contains("abcdefg", "a"))
  fmt.Println(strings.Contains("abcdefg", "abc"))
  fmt.Println(strings.Contains("abcdefg", "ba"))
}

=== RUN   TestContains
true
true
false
--- PASS: TestContains (0.00s)
PASS

func ContainsAny(s, chars string) bool

Verifica se qualsiasi carattere unicode della stringa chars è presente nella stringa s, in altre parole se s contiene qualsiasi carattere di chars

func TestContainsAny(t *testing.T) {
  fmt.Println(strings.ContainsAny("abcedfg", "bac"))
  fmt.Println(strings.ContainsAny("abcedfg", "gfdecba"))
}

=== RUN   TestContainsAny
true
--- PASS: TestContainsAny (0.00s)
PASS

func ContainsRune(s string, r rune) bool

Verifica se la stringa s contiene il carattere r

func TestContainsRune(t *testing.T) {
   fmt.Println(strings.ContainsRune("abcedf", 'a'))
   fmt.Println(strings.ContainsRune("abcedf", 'b'))
   fmt.Println(strings.ContainsRune("Ciao mondo", 'C'))
}

=== RUN   TestContainsRune
true
true
true
--- PASS: TestContainsRune (0.00s)
PASS

Numero di Occorrenze di una Sottosringa

func Count(s, substr string) int

Restituisce il numero di occorrenze della sottostringa substr nella stringa s

func TestCount(t *testing.T) {
  fmt.Println(strings.Count("3.1415926", "1"))
  fmt.Println(strings.Count("there is a girl", "e"))
  fmt.Println(strings.Count("there is a girl", ""))
}

=== RUN   TestCount
2
2
16
--- PASS: TestCount (0.00s)
PASS

Rimuovere una Sottosringa Specifica

func Cut(s, sep string) (before, after string, found bool)

Rimuove la prima occorrenza della sottostringa sep in s e restituisce il risultato dopo la rimozione

before - La stringa prima della posizione della sottostringa rimossa
after - La stringa dopo la posizione della sottostringa rimossa
found - Se è stata trovata la sottostringa

func TestCut(t *testing.T) {
  show := func(s, sep string) {
    before, after, found := strings.Cut(s, sep)
    fmt.Printf("Cut(%q, %q) = %q, %q, %v\n", s, sep, before, after, found)
  }
  show("Hello world", " ")
  show("Hello world", "world")
  show("Hello world", "Hello")
  show("Hello world", "Hello world")
}

=== RUN   TestCut
Cut("Hello world", " ") = "Hello", "world", true
Cut("Hello world", "world") = "Hello ", "", true
Cut("Hello world", "Hello") = "", " world", true
Cut("Hello world", "Hello world") = "", "", true
--- PASS: TestCut (0.00s)
PASS

Uguaglianza Ignorando Maiuscole/Minuscole

func EqualFold(s, t string) bool

Restituisce se le stringhe s e t sono uguali ignorando maiuscole/minuscole

func TestEqualFold(t *testing.T) {
   fmt.Println(strings.EqualFold("Ciao", "Ciao"))
   fmt.Println(strings.EqualFold("Hello", "Hello"))
   fmt.Println(strings.EqualFold("Hello", "hELLO"))
}

=== RUN   TestEqualFold
true
true
true
--- PASS: TestEqualFold (0.00s)
PASS

Dividere una Stringa

func Fields(s string) []string

func FieldsFunc(s string, f func(rune) bool) []string

La prima divide la stringa in base agli spazi, la seconda usa il valore di ritorno della funzione f per decidere se dividere la stringa.

func TestField(t *testing.T) {
   fmt.Printf("%q\n", strings.Fields(" a b c d e f g "))
   fmt.Printf("%q\n", strings.FieldsFunc("a,b,c,d,e,f,g", func(r rune) bool {
      return r == ','
   }))
}

=== RUN   TestField
["a" "b" "c" "d" "e" "f" "g"]
["a" "b" "c" "d" "e" "f" "g"]
--- PASS: TestField (0.00s)
PASS

Cercare Prefissi e Suffissi

func HasPrefix(s, prefix string) bool

func HasSuffix(s, suffix string) bool

La prima cerca il prefisso, la seconda cerca il suffisso. Chi è interessato può guardare l'implementazione del codice sorgente qui, è piuttosto ingegnosa.

func TestPreSuffix(t *testing.T) {
   str := "abbc cbba"
   fmt.Println(strings.HasPrefix(str, "abb"))
   fmt.Println(strings.HasSuffix(str, "bba"))
}

=== RUN   TestPreSuffix
true
true
--- PASS: TestPreSuffix (0.00s)
PASS

Posizione della Sottosringa

Restituisce l'indice della prima occorrenza della sottostringa

func Index(s, substr string) int

Restituisce l'indice della prima occorrenza della sottostringa

func IndexAny(s, chars string) int

Restituisce l'indice della prima occorrenza della sottostringa

func IndexRune(s string, r rune) int

Esempio

func TestIndex(t *testing.T) {
   fmt.Println(strings.Index("abcdefg", "bc"))
   fmt.Println(strings.IndexAny("abcdefg", "cb"))
   fmt.Println(strings.IndexRune("abcdefg", 'g'))
}

=== RUN   TestIndex
1
1
6
--- PASS: TestIndex (0.00s)
PASS

Restituisce l'indice dell'ultima occorrenza della sottostringa

func LastIndex(s, substr string) int

Restituisce l'indice dell'ultima occorrenza di qualsiasi carattere della sottostringa

func LastIndexAny(s, chars string) int

Esempio

func TestLastIndex(t *testing.T) {
  fmt.Println(strings.LastIndex("abcdefga", "a"))
  fmt.Println(strings.LastIndexAny("abcdefghisa", "ba"))
}

Iterare e Sostituire una Stringa

Map restituisce una copia della stringa s e modifica tutti i caratteri della stringa s secondo la funzione di mappatura. Se la mappatura restituisce un valore negativo, il carattere viene rimosso dalla stringa senza sostituzione

func Map(mapping func(rune) rune, s string) string

Esempio

func TestMap(t *testing.T) {
   fmt.Println(strings.Map(func(r rune) rune {
      return r - 32
   }, "abcdefghijk"))
   fmt.Println(strings.Map(func(r rune) rune {
      return r + 32
   }, "ABCDEFGHIJK"))
   fmt.Println(strings.Map(func(r rune) rune {
      if r < 'F' {
         return -1
      } else {
         return r
      }
   }, "ABCDEFGHIJK"))
}

Output

text

=== RUN   TestMap
ABCDEFGHIJK
abcdefghijk
FGHIJK
--- PASS: TestMap (0.00s)
PASS

Ripetere una Stringa

Copia la stringa in base al count dato, se negativo causa un panic

func Repeat(s string, count int) string

Esempio

func TestRepeat(t *testing.T) {
   fmt.Println(strings.Repeat("a", 10))
   fmt.Println(strings.Repeat("abc", 10))
}

Output

=== RUN   TestRepeat
aaaaaaaaaa
abcabcabcabcabcabcabcabcabcabc
--- PASS: TestRepeat (0.00s)
PASS

Sostituire una Stringa

s è la stringa di origine, old è la parte da sostituire, new è la parte che sostituisce old, n è il numero di sostituzioni, n minore di 0 indica nessuna limitazione al numero di sostituzioni.

func Replace(s, old, new string, n int) string

Esempio

func TestReplace(t *testing.T) {
   fmt.Println(strings.Replace("Hello this is golang", "golang", "c++", 1))
   fmt.Println(strings.Replace("Hello this is golang", "o", "c", -1))
   fmt.Println(strings.Replace("Hello this is golang", "o", "c", 1))
}

Output

=== RUN   TestReplace
Hello this is c++
Hellc this is gclang
Hellc this is golang
--- PASS: TestReplace (0.00s)
PASS

Funzione convenience di Replace, equivalente a strings.Replace(s,old,new,-1)

func ReplaceAll(s, old, new string) string

Esempio

func TestReplaceAll(t *testing.T) {
  fmt.Println(strings.ReplaceAll("Hello this is golang", "o", "c++"))
}

Output

=== RUN   TestReplaceAll
Hellc++ this is gc++lang
--- PASS: TestReplaceAll (0.00s)
PASS

Separare una Stringa

Separa la stringa s in una slice di stringhe in base alla sottostringa sep

func Split(s, sep string) []string

Separa la stringa s in una slice di stringhe in base alla sottostringa sep, il numero di separazioni è determinato da n

func SplitN(s, sep string, n int) []string

Separa la stringa s in una slice di stringhe contenenti sep in base alla sottostringa sep

func SplitAfter(s, sep string) []string

Separa la stringa s in una slice di stringhe contenenti sep in base alla sottostringa sep, il numero di separazioni è determinato da n

func SplitAfterN(s, sep string, n int) []string

Esempio

func TestSplit(t *testing.T) {
   fmt.Printf("%q\n", strings.Split("this is go language", " "))
   fmt.Printf("%q\n", strings.SplitN("this is go language", " ", 2))
   fmt.Printf("%q\n", strings.SplitAfter("this is go language", " "))
   fmt.Printf("%q\n", strings.SplitAfterN("this is go language", " ", 2))
}

Output

=== RUN   TestSplit
["this" "is" "go" "language"]
["this" "is go language"]
["this " "is " "go " "language"]
["this " "is go language"]
--- PASS: TestSplit (0.00s)
PASS

Conversione Maiuscole/Minuscole

Converte una stringa inglese in minuscolo

func ToLower(s string) string

Converte in minuscolo secondo il unicode.SpecialCase della lingua corrispondente passata

func ToLowerSpecial(c unicode.SpecialCase, s string) string

Converte una stringa inglese in maiuscolo

func ToUpper(s string) string

Converte in maiuscolo secondo il unicode.SpecialCase della lingua corrispondente passata

func ToUpperSpecial(c unicode.SpecialCase, s string) string

Esempio

func TestLowerAndUpper(t *testing.T) {
   fmt.Println(strings.ToLower("My name is jack,Nice to meet you!"))
   fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
   fmt.Println(strings.ToUpper("My name is jack,Nice to meet you!"))
   fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "örnek iş"))
}

Output

=== RUN   TestLowerAndUpper
my name is jack,nice to meet you!
önnek iş
MY NAME IS JACK,NICE TO MEET YOU!
ÖRNEK İŞ
--- PASS: TestLowerAndUpper (0.00s)
PASS

Tagliare una Stringa

Taglia le estremità della stringa, rimuove qualsiasi sottostringa corrispondente a cutset

func Trim(s, cutset string) string

Taglia l'estremità sinistra della stringa, rimuove qualsiasi sottostringa corrispondente a cutset

func TrimLeft(s, cutset string) string

Taglia il prefisso all'estremità sinistra della stringa, rimuove la sottostringa corrispondente a cutset, se non corrisponde restituisce la stringa s

func TrimPrefix(s, suffix string) string

Taglia l'estremità destra della stringa, rimuove qualsiasi sottostringa corrispondente a cutset

func TrimRight(s, cutset string) string

Taglia il suffisso all'estremità destra della stringa, rimuove la sottostringa corrispondente a cutset, se non corrisponde restituisce la stringa s

func TrimSuffix(s, suffix string) string

Esempio

func TestTrim(t *testing.T) {
  fmt.Println(strings.Trim("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimLeft("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimRight("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimPrefix("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimSuffix("!!this is a test statement!!", "!!!"))
}

Output

=== RUN   TestTrim
this is a test statement
this is a test statement!!
!!this is a test statement
!!this is a test statement!!
!!this is a test statement!!
--- PASS: TestTrim (0.00s)
PASS

Builder di Stringhe

Il Builder di stringhe è più efficiente in termini di memoria rispetto all'operare direttamente sulle stringhe.

type Builder struct {
  // I campi interni non sono esposti
}

Esempio

func TestBuilder(t *testing.T) {
   builder := strings.Builder{}
   builder.WriteString("hello")
   builder.WriteString(" world")
   fmt.Println(builder.Len())
   fmt.Println(builder.String())
}

Output

=== RUN   TestBuilder
11
hello world
--- PASS: TestBuilder (0.00s)
PASS

TIP

Non cercare di passare Builder come valore, ad esempio quando si passa strings.Builder come parametro di una funzione, il programma andrà in panic

strings: illegal use of non-zero Builder copied by value

Internamente c'è il seguente codice

type Builder struct {
  addr *Builder // Indirizzo proprio
  buf  []byte
}

func (b *Builder) copyCheck() {
   if b.addr == nil {
      b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
   } else if b.addr != b {
      panic("strings: illegal use of non-zero Builder copied by value")
   }
}

Quando si copia un valore di Builder, si copia anche il puntatore alla slice interna, due Builder durante la scrittura di stringhe operano sulla stessa slice, questo è il motivo per cui non è consentita la copia per valore.

Replacer di Stringhe

Replacer è utilizzato per sostituire stringhe

func NewReplacer(oldnew ...string) *Replacer

Esempio

func TestReplacer(t *testing.T) {
  r := strings.NewReplacer("<", "<", ">", ">")
  fmt.Println(r.Replace("This is <b>HTML</b>!"))
}

Output

This is <b>HTML</b>!

Reader di Stringhe

Reader implementa le interfacce io.Reader, io.ReaderAt, io.ByteReader, io.ByteScanner, io.RuneReader, io.RuneScanner, io.Seeker, e io.WriterTo.

func NewReader(s string) *Reader

Esempio

func TestReader(t *testing.T) {
   reader := strings.NewReader("abcdefghijk")
   buffer := make([]byte, 20, 20)
   read, err := reader.Read(buffer)
   if err != nil {
      log.Panic(err)
   }
   fmt.Println(read)
   fmt.Println(string(buffer))
}

Output

=== RUN   TestReader
11
abcdefghijk
--- PASS: TestReader (0.00s)
PASS

strings ​

Importazione ​

Clonare una Stringa ​

Confrontare Stringhe ​

Contiene una Sottosringa ​

Numero di Occorrenze di una Sottosringa ​

Rimuovere una Sottosringa Specifica ​

Uguaglianza Ignorando Maiuscole/Minuscole ​

Dividere una Stringa ​

Cercare Prefissi e Suffissi ​

Posizione della Sottosringa ​

Iterare e Sostituire una Stringa ​

Ripetere una Stringa ​

Sostituire una Stringa ​

Separare una Stringa ​

Conversione Maiuscole/Minuscole ​

Tagliare una Stringa ​

Builder di Stringhe ​

Replacer di Stringhe ​

Reader di Stringhe ​

strings

Importazione

Clonare una Stringa

Confrontare Stringhe

Contiene una Sottosringa

Numero di Occorrenze di una Sottosringa

Rimuovere una Sottosringa Specifica

Uguaglianza Ignorando Maiuscole/Minuscole

Dividere una Stringa

Cercare Prefissi e Suffissi

Posizione della Sottosringa

Iterare e Sostituire una Stringa

Ripetere una Stringa

Sostituire una Stringa

Separare una Stringa

Conversione Maiuscole/Minuscole

Tagliare una Stringa

Builder di Stringhe

Replacer di Stringhe

Reader di Stringhe