Uma introdução ao pacote de Strings em Go

Introdução

O pacote stringem Go possui várias funções disponíveis para trabalhar com o string data type​​​. Essas funções nos permitem modificar e manipular strings facilmente. Podemos pensar em funções como ações que realizamos nos elementos do nosso código. Funções integradas são aquelas definidas na linguagem de programação Go e ficam prontamente disponíveis para o nosso uso.

Neste tutorial, avaliaremos várias funções diferentes que podemos usar para trabalhar com as strings em Go.

Criando strings em letras maiúsculas e minúsculas

As funções strings.ToUpper e strings.ToLower vão retornar uma string com todas as letras de uma string original convertidas em letras maiúsculas ou minúsculas. Como as strings são tipos de dados imutáveis, a string retornada será uma nova string. Quaisquer caracteres na string que não sejam letras não serão alterados.

Para converter a string "Sammy Shark" para ser toda em maiúscula, use a função strings.ToUpper:

ss := "Sammy Shark"
fmt.Println(strings.ToUpper(ss))

Output
SAMMY SHARK

Para converter para minúsculas:

fmt.Println(strings.ToLower(ss))

Output
sammy shark

Como você está usando o pacote strings, primeiro você precisa importá-lo para um programa. Para converter a string em maiúsculas e minúsculas, o programa todo ficaria da seguinte forma:

package main

import (
	"fmt"
	"strings"
)

func main() {
	ss := "Sammy Shark"
	fmt.Println(strings.ToUpper(ss))
	fmt.Println(strings.ToLower(ss))
}

As funções strings.ToUpper e strings.ToLower facilitam a avaliação e comparação de strings, tornando consistente o uso de maiúsculas e minúsculas de ponta a ponta. Por exemplo, se um usuário escreve seu nome com todas as letras minúsculas, ainda assim conseguiremos saber se o nome dele está em nosso banco de dados, comparando-o com uma versão com todas as letras maiúsculas.

Funções de busca de string

O pacote strings tem uma série de funções que ajudam a determinar se uma string contém uma sequência específica de caracteres.

As funções strings.HasPrefix e strings.HasSuffix permitem que você verifique se uma string começa ou termina com um conjunto específico de caracteres.

Por exemplo, para verificar se a string "Sammy Shark" começa com Sammy e termina com o Shark:

ss := "Sammy Shark"
fmt.Println(strings.HasPrefix(ss, "Sammy"))
fmt.Println(strings.HasSuffix(ss, "Shark"))

Output
true
true

Você usaria a função strings.Contains para verificar se "Sammy Shark"contém a sequência Sh:

fmt.Println(strings.Contains(ss, "Sh"))

Output
true

Por fim, para ver quantas vezes a letra S aparece na frase Sammy Shark:

fmt.Println(strings.Count(ss, "S"))

Output
2

Usar um s minúsculo para obter uma contagem do Sammy Shark não é o mesmo que usar o S maiúsculo:

fmt.Println(strings.Count(ss, "s"))

Output
0

Como S é diferente de s, a contagem será 0.

As funções de string são úteis quando você quer comparar ou pesquisar strings no seu programa.

Determinando o tamanho da string

A função integrada len() retorna o número de caracteres em uma string. Essa função é útil para quando você tiver que impor o tamanho mínimo ou máximo de uma senha, por exemplo, ou para truncar strings maiores para que fiquem dentro de certos limites para usar como abreviações.

Para demonstrar essa função, encontraremos o tamanho de uma string longa:

import (
	"fmt"
	"strings"
)

func main() {
        openSource := "Sammy contributes to open source."
        fmt.Println(len(openSource))
}

Output
33

Definimos a variável openSource igual a string "Sammy contributes to open source." e então passamos essa variável para a função len() com len(openSource). Por fim, movemos a função para que faça parte da função fmt.Println() para que pudéssemos ver o resultado do programa na tela.

Lembre-se de que a função len() contará qualquer caractere vinculado por aspas duplas - incluindo letras, números, espaços em branco e símbolos.

Funções para a manipulação de string

As funções strings.Join, strings.Split e strings.ReplaceAll são algumas maneiras adicionais de manipular as strings em Go.

A função strings.Join é útil para combinar uma fração das strings em uma única e nova string.

Para criar uma string separada por vírgulas de uma fatia de strings, usaríamos essa função de acordo com o seguinte:

fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))

Output
sharks,crustaceans,plankton

Se quisermos adicionar uma vírgula e um espaço entre os valores da string na nossa nova string, podemos simplesmente reescrever nossa expressão com um espaço em branco após a vírgula: strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

Assim como podemos juntar strings, também podemos dividir as strings. Para fazer isso, podemos usar a função strings.Split e dividir nos espaços:

balloon := "Sammy has a balloon."
s := strings.Split(balloon, " ")
fmt.Println(s)

Output
[Sammy has a balloon]

O resultado é uma fatia de strings. Como a função strings.Println foi usada, é difícil distinguir o que seja o resultando apenas olhando para ele. Para verificar que se trata, de fato, de strings, utilize a função fmt.Printf com o verbo %q para citar as strings:

fmt.Printf("%q", s)

Output
["Sammy" "has" "a" "balloon."]

Outra função útil, além de strings.Split é a strings.Fields. A diferença é que a função strings.Fields irá ignorar todos os espaços em branco e irá dividir apenas os fields em questão em uma string:

data := "  username password     email  date"
fields := strings.Fields(data)
fmt.Printf("%q", fields)

Output
["username" "password" "email" "date"]

A função strings.ReplaceAll pode tomar uma string original e retornar uma string atualizada com algumas substituições.

Digamos que o balão de Sammy esteja perdido. Como Sammy já não tem esse balão, mudaríamos a substring "has"(tem) da string original balloon (balão) para "had" (tinha) em uma nova string:

fmt.Println(strings.ReplaceAll(balloon, "has", "had"))

Dentro dos parênteses, primeiro está a variável balloon que armazena a string original; a segunda substring "has" é a que gostaríamos de substituir e a terceira substring "had" é o que iria substituir a segunda substring. Nosso resultado ficaria parecida com a seguinte, depois que incorporarmos isto em um um programa:

Output
Sammy had a balloon.

Usar as funções string strings.Join, strings.Split e strings.ReplaceAll fornecerá a você um maior controle para manipular strings em Go.

Conclusão

Este tutorial examinou algumas das funções comuns do pacote string quanto ao tipo de dados de string que você pode usar para trabalhar e manipular strings em seus programas em Go.

Você pode aprender mais sobre outros tipos de dados em Entendendo os tipos de dados e ler mais sobre strings em Uma introdução para trabalhar com strings.