Go Academy · Lezione

strings.Builder

Costruire stringhe in modo efficiente

strings.Builder è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Il costo della concatenazione con +

Poiché le stringhe sono immutabili, ogni s = s + part crea una stringa completamente nuova e copia nuovamente tutti i byte.

In un ciclo, questo diventa lento e spreca memoria.

package main

import "fmt"

func main() {
    s := ""
    for i := 0; i < 3; i++ {
        s = s + "go "
    }
    fmt.Println(s)
}

Ecco strings.Builder

strings.Builder amplia un buffer interno ed evita copie ripetute. Vi scrive i dati e poi legge il risultato una sola volta alla fine.

Lo dichiari con var b strings.Builder.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("Hello")
    fmt.Println(b.String())
}

WriteString in un ciclo

Il vero vantaggio emerge nei cicli. Chiami ripetutamente WriteString, quindi legga il risultato una sola volta con String().

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    for i := 0; i < 3; i++ {
        b.WriteString("go ")
    }
    fmt.Println(b.String())
}

Scrivere byte e rune

Un Builder accetta più di semplici stringhe complete:

WriteByte aggiunge un singolo byte.
WriteRune aggiunge un punto di codice Unicode.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("Go")
    b.WriteByte('!')
    b.WriteRune('語')
    fmt.Println(b.String())
}

Builder implementa io.Writer

Poiché Builder soddisfa l'interfaccia io.Writer, può utilizzarlo con fmt.Fprintf per formattare direttamente nel buffer.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    fmt.Fprintf(&b, "x=%d y=%d", 3, 4)
    fmt.Println(b.String())
}

Tenere traccia della lunghezza

b.Len() indica quanti byte sono stati scritti finora, senza creare la stringa finale.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("hello")
    fmt.Println(b.Len())
}

Preallocare con Grow

Se sa approssimativamente quanto sarà grande il risultato, chiami prima b.Grow(n). In questo modo riserva la capacità necessaria ed evita ridimensionamenti ripetuti del buffer.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.Grow(64)
    for i := 0; i < 5; i++ {
        b.WriteString("item ")
    }
    fmt.Println(b.String())
}

Reimpostare un Builder

b.Reset() svuota il buffer, consentendo di riutilizzare lo stesso Builder per la stringa successiva.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.WriteString("first")
    b.Reset()
    b.WriteString("second")
    fmt.Println(b.String())
}

Non copi un Builder

Un strings.Builder non deve essere copiato dopo il primo utilizzo. Lo passi invece utilizzando un puntatore (*strings.Builder).

package main

import (
    "fmt"
    "strings"
)

func add(b *strings.Builder, word string) {
    b.WriteString(word)
}

func main() {
    var b strings.Builder
    add(&b, "shared ")
    add(&b, "builder")
    fmt.Println(b.String())
}

Costruire una riga CSV

Un esempio pratico: assembli in modo efficiente una riga separata da virgole con un Builder.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fields := []string{"id", "name", "age"}
    var b strings.Builder
    for i, f := range fields {
        if i > 0 {
            b.WriteByte(',')
        }
        b.WriteString(f)
    }
    fmt.Println(b.String())
}

Quando utilizzare un Builder

Utilizzi strings.Builder quando concatena molti elementi, soprattutto all'interno dei cicli.

Per un'unica operazione di unione su una slice nota, strings.Join è più semplice e altrettanto veloce.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    for i := 1; i <= 3; i++ {
        fmt.Fprintf(&b, "[%d]", i)
    }
    fmt.Println(b.String())
}

Verifica rapida

Perché è preferibile utilizzare un Builder invece di ripetere + in un ciclo?

Riepilogo: strings.Builder

Ha imparato a costruire stringhe in modo efficiente:

Dichiari il Builder con var b strings.Builder.
Aggiunga contenuti tramite WriteString, WriteByte, WriteRune o fmt.Fprintf.
Facoltativamente chiami Grow in anticipo, legga il risultato una sola volta con String() e non copi mai il Builder.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var b strings.Builder
    b.Grow(16)
    b.WriteString("Go ")
    b.WriteString("builder!")
    fmt.Println(b.String())
}

Domande Frequenti

La lezione «strings.Builder» è gratuita?

Sì — il testo completo di «strings.Builder» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «strings.Builder»?

Costruire stringhe in modo efficiente Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «strings.Builder»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy