Go Academy · Aula

Funções do pacote strings

Divida, una e remova espaços

Funções do pacote strings é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 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 pacote strings

O pacote strings da biblioteca padrão oferece auxiliares prontos para trabalhar com texto: pesquisar, dividir, unir, remover espaços e alterar maiúsculas e minúsculas.

Importe-o com import "strings".

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.ToUpper("hello"))
}

Contains e HasPrefix

Verifique a presença de substrings sem escrever laços:

strings.Contains(s, sub) informa se sub aparece.
strings.HasPrefix e strings.HasSuffix verificam o início e o fim.

package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "golang"
    fmt.Println(strings.Contains(s, "lan"))
    fmt.Println(strings.HasPrefix(s, "go"))
}

Encontrando uma posição

strings.Index(s, sub) retorna o índice do byte da primeira ocorrência ou -1 se ela não for encontrada.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Index("chocolate", "col"))
    fmt.Println(strings.Index("chocolate", "xyz"))
}

Dividindo uma string

strings.Split(s, sep) divide uma string em uma fatia usando um separador.

É ideal para analisar dados no formato CSV.

package main

import (
    "fmt"
    "strings"
)

func main() {
    parts := strings.Split("a,b,c", ",")
    fmt.Println(parts)
    fmt.Println(len(parts))
}

Dividindo por espaços em branco

strings.Fields(s) divide em torno de qualquer sequência de espaços em branco e descarta as partes vazias. É ideal para contar palavras.

package main

import (
    "fmt"
    "strings"
)

func main() {
    words := strings.Fields("  the   quick brown  fox ")
    fmt.Println(words)
    fmt.Println(len(words))
}

Unindo fatias

strings.Join(slice, sep) é o inverso de Split: une os elementos de uma fatia usando um separador.

package main

import (
    "fmt"
    "strings"
)

func main() {
    parts := []string{"2026", "05", "30"}
    fmt.Println(strings.Join(parts, "-"))
}

Removendo espaços

strings.TrimSpace(s) remove os espaços em branco iniciais e finais, sendo excelente para limpar a entrada do usuário.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.TrimSpace("   hi there   ") + "!")
}

Removendo caracteres específicos

strings.Trim(s, cutset) remove das duas extremidades qualquer um dos caracteres fornecidos. TrimPrefix e TrimSuffix removem strings exatas.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Trim("***name***", "*"))
    fmt.Println(strings.TrimSuffix("file.txt", ".txt"))
}

Substituindo texto

strings.ReplaceAll(s, old, new) troca todas as ocorrências. Use strings.Replace(s, old, new, n) para limitar a substituição às primeiras n ocorrências.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.ReplaceAll("a-b-c", "-", "+"))
    fmt.Println(strings.Replace("a-b-c", "-", "+", 1))
}

Repetindo e contando

Mais dois auxiliares úteis:

strings.Repeat(s, n) cria uma string repetida.
strings.Count(s, sub) conta as ocorrências que não se sobrepõem.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Repeat("ab", 3))
    fmt.Println(strings.Count("banana", "a"))
}

Combinando funções

Esses auxiliares combinam bem. Aqui, removemos espaços, dividimos e juntamos novamente uma string desorganizada em uma lista limpa separada por vírgulas.

package main

import (
    "fmt"
    "strings"
)

func main() {
    raw := "  go  rust  zig  "
    words := strings.Fields(raw)
    fmt.Println(strings.Join(words, ", "))
}

Verificação rápida

Escolha a função que une uma fatia em uma única string.

Recapitulação: funções de strings

Agora você tem um conjunto de ferramentas para trabalhar com texto:

Pesquisar: Contains, Index, HasPrefix.
Separar: Split, Fields.
Combinar: Join, Repeat.
Limpar: TrimSpace, Trim, ReplaceAll.

package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "  Hello, Go World  "
    fmt.Println(strings.ToLower(strings.TrimSpace(s)))
}

Perguntas Frequentes

A aula “Funções do pacote strings” é grátis?

Sim — o texto completo de “Funções do pacote strings” é 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 “Funções do pacote strings”?

Divida, una e remova espaços 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 2 de 4.

Quanto tempo leva a aula “Funções do pacote strings”?

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