Go Academy · Aula

strings.Builder

Construa strings com eficiência

strings.Builder é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O custo da concatenação com +

Como as strings são imutáveis, cada s = s + part cria uma string totalmente nova e copia novamente todos os bytes.

Em um laço, isso fica lento e desperdiça memória.

package main

import "fmt"

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

Conheça strings.Builder

strings.Builder aumenta um buffer interno e evita cópias repetidas. Você escreve nele e lê o resultado apenas uma vez, no final.

Declare um com var b strings.Builder.

package main

import (
    "fmt"
    "strings"
)

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

WriteString em um laço

O verdadeiro ganho aparece nos laços. Chame WriteString repetidamente e depois leia uma única vez com 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())
}

Escrevendo bytes e runes

Um Builder aceita mais do que strings completas:

WriteByte adiciona um único byte.
WriteRune adiciona um ponto de código 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

Como Builder satisfaz a interface io.Writer, você pode usá-lo com fmt.Fprintf para formatar diretamente no 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())
}

Acompanhando o comprimento

b.Len() informa quantos bytes foram escritos até o momento, sem construir a string final.

package main

import (
    "fmt"
    "strings"
)

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

Pré-alocando com Grow

Se você souber aproximadamente qual será o tamanho do resultado, chame b.Grow(n) primeiro. Isso reserva capacidade e evita redimensionamentos repetidos do 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())
}

Redefinindo um Builder

b.Reset() esvazia o buffer para que você possa reutilizar o mesmo Builder na próxima string.

package main

import (
    "fmt"
    "strings"
)

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

Não copie um Builder

Um strings.Builder não deve ser copiado depois do primeiro uso. Passe-o usando um ponteiro (*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())
}

Construindo uma linha CSV

Um exemplo prático: monte uma linha separada por vírgulas com eficiência usando um 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 usar um Builder

Use strings.Builder quando precisar concatenar muitas partes, especialmente dentro de laços.

Para uma união única de uma fatia conhecida, strings.Join é mais simples e igualmente rápido.

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ção rápida

Por que preferir um Builder a usar + repetidamente em um laço?

Recapitulação: strings.Builder

Você aprendeu a construir strings com eficiência:

Declare com var b strings.Builder.
Acrescente usando WriteString, WriteByte, WriteRune ou fmt.Fprintf.
Opcionalmente, use Grow antecipadamente, leia uma vez com String() e nunca faça uma cópia.

package main

import (
    "fmt"
    "strings"
)

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

Perguntas Frequentes

A aula “strings.Builder” é grátis?

Sim — o texto completo de “strings.Builder” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “strings.Builder”?

Construa strings com eficiência Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “strings.Builder”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy