`strings.Builder.Grow` în Go

strings.Builder și strings.Reader Go 1.10 (Cap din Go 1.12)

Grow rezervă loc dinainte, Len dă octeții scriși, Cap capacitatea bufferului, iar Reset golește Builder-ul.

Sintaxă

func (b *Builder) Grow(n int)
func (b *Builder) Len() int
func (b *Builder) Cap() int
func (b *Builder) Reset()

Ce face `strings.Builder.Grow`

sb.Grow(n) se asigură că mai încap cel puțin n octeți fără o nouă alocare de memorie. Dacă știi cam cât de mare va fi textul, un singur Grow la început evită realocările repetate.

sb.Len() returnează câți octeți au fost scriși (nu câte caractere: „Iași” are 5 octeți). sb.Cap() returnează capacitatea bufferului, adică câți octeți încap până la următoarea alocare.

sb.Reset() golește Builder-ul și renunță la buffer: următoarea scriere alocă unul nou. Textele obținute înainte cu String() rămân valabile.

Parametri

Parametru	Descriere
`n`	La Grow: câți octeți în plus trebuie să încapă. Un `n` negativ produce `panic`.

Ce returnează

Len și Cap returnează numere de octeți; Grow și Reset nu returnează nimic.

Exemple

Exemplul 1: Len, Cap și Grow

package main

import (
	"fmt"
	"strings"
)

func main() {
	var sb strings.Builder
	fmt.Println("la început:", sb.Len(), sb.Cap())
	sb.Grow(64)
	fmt.Println("după Grow(64):", sb.Len(), sb.Cap() >= 64)
	sb.WriteString("Iași")
	fmt.Println("după „Iași”:", sb.Len(), "octeți, capacitate", sb.Cap())
}

Rezultat

la început: 0 0
după Grow(64): 0 true
după „Iași”: 5 octeți, capacitate 64

Exemplul 2: Reset pentru refolosire

package main

import (
	"fmt"
	"strings"
)

func main() {
	var sb strings.Builder
	var randuri []string
	for _, elev := range []string{"Ana", "Ion"} {
		sb.Reset()
		sb.WriteString("Elev: ")
		sb.WriteString(elev)
		randuri = append(randuri, sb.String())
	}
	fmt.Printf("%q\n", randuri)
	fmt.Println("după ultimul rând:", sb.Len(), sb.Cap())
	sb.Reset()
	fmt.Println("după Reset:", sb.Len(), sb.Cap())
}