Manipolazione delle stringhe in Go: come aggiornare il testo

La manipolazione delle stringhe è fondamentale nello sviluppo del software; la maggior parte dei linguaggi di programmazione fornisce un tipo di stringa, dopotutto. Una stringa è una sequenza di caratteri: lettere, numeri e simboli.

La manipolazione delle stringhe è utile per varie applicazioni, dall’elaborazione del testo e dall’analisi dei dati allo sviluppo web. Le operazioni più comuni di manipolazione delle stringhe sono la concatenazione, la convalida dei dati, l’estrazione e la formattazione. Go fornisce un pacchetto di manipolazione delle stringhe denominato “strings” nella libreria standard.

Il pacchetto di stringhe

Il pacchetto strings fornisce varie funzioni utili per la manipolazione delle stringhe e altre operazioni. Il pacchetto include funzionalità per operazioni di sottostringa, taglio, confronto di stringhe, conversione di stringhe, creazione di stringhe, suddivisione e altro.

Puoi importare il pacchetto di stringhe specificando il nome del pacchetto nell’elenco delle importazioni.

import "strings"


Ricerca di sottostringhe

Il pacchetto strings fornisce tre funzioni per la ricerca di sottostringhe: la funzione Contains , la funzione ContainsAny e la funzione ContainsRune .

La funzione Contains controlla se la stringa specificata contiene la sottostringa. La funzione ContainsAny controlla se la stringa contiene caratteri nella sottostringa e la funzione ContainsRune controlla se la stringa contiene una runa (un carattere Unicode).

import (
    "fmt"
    "strings"
)


func main() {
    aString: = "Hello, World!"
    substring: = "World"
    characters: = "aeiou"
    aRune: = 'o'

    fmt.Println(strings.Contains(aString, substring)) // Output: true
    fmt.Println(strings.ContainsAny(aString, characters)) // Output: true
    fmt.Println(strings.ContainsRune(aString, aRune)) // Output: true
}


È possibile recuperare l’indice di una sottostringa con le funzioni Index , IndexAny , IndexByte e IndexFunc . La funzione Index restituisce l’indice di una sottostringa, se si verifica in un’altra stringa data. La funzione IndexAny restituisce l’indice della prima istanza di un punto di codice Unicode o -1 se non è presente alcun carattere.

import (
    "fmt"
    "strings"
)


func main() {
    aString: = "Hello, world!"
    substring: = "world"
    chars: = "wrld"
    byteCharacter: = byte('o')
    aRune: = rune('o')

    fmt.Println(strings.IndexFunc(aString, f)) // Output: 4
    fmt.Println(strings.IndexRune(aString, aRune)) // Output: 4
}


IndexByte restituisce l’indice della prima istanza del carattere byte nella stringa o -1 . La funzione IndexFunc restituisce l’indice nella stringa del primo punto Unicode che soddisfa una determinata funzione. Infine, la funzione IndexRune restituisce l’indice della prima istanza del punto di codice Unicode della runa.

Sostituzione delle sottostringhe in Go

Le funzioni Sostituisci e SostituisciTutto aiutano a sostituire le sottostringhe. La funzione Sostituisci accetta la stringa, la sottostringa originale, la sostituzione e diverse sostituzioni. La funzione ReplaceAll accetta solo la stringa, la sottostringa iniziale e la sostituzione.

import (
    "fmt"
    "strings"
)


func main() {
    theString: = "This is a test string to be modified."
    fmt.Println(strings.Replace(theString, "is", "was", 1))
    fmt.Println(strings.Replace(theString, "is", "was", -1))
    fmt.Println(strings.ReplaceAll(theString, "is", "was"))
}


Si noti che è possibile utilizzare sia Replace che ReplaceAll per sostituire ogni occorrenza all’interno della stringa.

Dividere e unire stringhe

Il pacchetto strings contiene le funzioni Split , SplitAfter , SplitAfterN e SplitN per dividere le stringhe che restituiscono una sezione delle stringhe.

Il metodo Split divide in base a un delimitatore specificato. Analogamente al metodo Split , il metodo SplitAfter suddivide la stringa, ma include il separatore nei risultati.

import (
    "fmt"
    "strings"
)


func main() {
    s: = "This is a test string to be split."

    fmt.Println(strings.Split(s, ""))
    fmt.Println(strings.SplitAfter(s, ""))
    fmt.Println(strings.SplitAfterN(s, "", 3))
    fmt.Println(strings.SplitN(s, "", 3))
}


Il metodo SplitAfterN è simile alla funzione SplitAfter , ad eccezione del fatto che la funzione suddivide la stringa in un numero massimo specificato di sottostringhe. Il metodo SplitN divide la stringa in un numero massimo specificato senza includere il separatore nelle sottostringhe.

Puoi unire stringhe con la funzione Join dal pacchetto strings . La funzione Join accetta una sezione e un delimitatore.

import (
    "fmt"
    "strings"
)


func main() {
    fmt.Println(strings.Join([]string{"Hello", "World"}, ":"))
   // Output: "Hello:World"
}


Manipolare il caso delle stringhe

La manipolazione delle maiuscole e minuscole è utile per molte attività, incluso il lavoro con la documentazione. È possibile utilizzare la funzione ToLower per le lettere minuscole, la funzione ToUpper per le lettere maiuscole e la funzione ToTitle per le maiuscole e minuscole del titolo.

import (
    "fmt"
    "strings"
)


func main() {
    s: = "This is a test string."

    fmt.Println(strings.ToLower(s)) // this is a test string.
    fmt.Println(strings.ToUpper(s)) // THIS IS A TEST STRING.
    fmt.Println(strings.ToTitle(s)) // THIS IS A TEST STRING.
}


Costruzione di stringhe in Go

I generatori di stringhe sono un tipo che consente una concatenazione efficiente in Go. Il tipo bytes.Buffer è uno dei costruttori di stringhe comunemente usati. Il metodo bytes.Buffer implementa un buffer ampliabile di byte con metodi di lettura e scrittura per le operazioni, consentendo l’aggiunta efficiente di stringhe senza la necessità di creare nuove copie, a differenza dell’operazione + e della funzione Join .

import (
    "fmt"
    "strings"
)


func main() {
    var b strings.Builder

    // Convert the builder to a string again
    str = b.String()
    fmt.Println(str)
}


La funzione main dimostra come utilizzare il tipo strings.Builder per una creazione di stringhe efficiente. Il metodo WriteString del tipo Strings.Builder estende reciprocamente la sequenza di stringhe e il metodo Len restituisce la lunghezza della stringa creata.

Il metodo String converte il contenuto del generatore in una stringa e il metodo Reset reimposta il generatore per la creazione di stringhe aggiuntive.

Il metodo Cap restituisce la capacità del builder. Questo è lo spazio corrente che Go ha allocato per la stringa.

Taglio di corde in Go

Il pacchetto strings fornisce anche funzionalità per tagliare le stringhe nelle funzioni Trim , TrimLeft , TrimPrefix , TrimRight , TrimSpace e TrimSuffix .

import (
    "strings"
    "fmt"
)


func main() {
    // the full string
    s: = "Hello, World!"

    // trims out a specific suffix
    fmt.Println(strings.TrimSuffix(s, suffix))
}


La funzione principale mostra come utilizzare le funzioni per il taglio. Le diverse funzioni tagliano la stringa s in vari modi:

Puoi formattare le stringhe in Go

La libreria standard Go fornisce anche il pacchetto fmt per la formattazione delle stringhe. Il pacchetto fmt utilizza verbi di formattazione in stile C per una formattazione efficiente delle stringhe in Go.