A manipulação de strings é fundamental no desenvolvimento de software; afinal, a maioria das linguagens de programação fornece um tipo de string. Uma string é uma sequência de caracteres: letras, números e símbolos.
A manipulação de strings é útil para vários aplicativos, desde processamento de texto e análise de dados até desenvolvimento web. Operações populares de manipulação de strings são concatenação, validação de dados, extração e formatação. Go fornece um pacote de manipulação de string chamado “strings” na biblioteca padrão.
O pacote de cordas
O cordas O pacote fornece várias funções úteis para manipulação de strings e outras operações. O pacote inclui funcionalidade para operações de substring, corte, comparação de strings, conversão de string, construção de string, divisão e muito mais.
Você pode importar o pacote de strings especificando o nome do pacote em sua lista de importações.
importar"cordas"
Procurando Substrings
O cordas O pacote fornece três funções para pesquisar substrings: o contém função, o Contém Qualquer função, e o ContémRuna função.
O contém A função verifica se a string especificada contém a substring. O Contém Qualquer A função verifica se a string contém algum caractere na substring e o ContémRuna A função verifica se a string contém uma runa (um caractere Unicode).
importar (
"fmt"
"cordas"
)funçãoprincipal() {
aString := "Olá Mundo!"
substring := "Mundo"
personagens := "aeiou"
aRuna := 'o'
fmt. Println (strings. Contém (aString, substring)) // Saída: verdadeiro
fmt. Println (strings. ContémAny (aString, caracteres)) // Saída: verdadeiro
fmt. Println (strings. ContémRuna (aString, aRuna)) // Saída: verdadeiro
}
Você pode recuperar o índice de uma substring com o Índice, ÍndiceQualquer, IndexByte, e IndexFunc funções. O Índice A função retorna o índice de uma substring, se ocorrer em outra determinada string. O ÍndiceQualquer função retorna o índice da primeira instância de um ponto de código Unicode ou -1 se nenhum dos caracteres estiver presente.
importar (
"fmt"
"cordas"
)funçãoprincipal() {
aString := "Olá Mundo!"
substring := "mundo"
caracteres := "mundo"
byteCaractere := byte('o')
aRuna := runa('o')fmt. Println (strings. Índice (aString, substring)) // Saída: 7
fmt. Println (strings. IndexAny (aString, caracteres)) // Saída: 7
fmt. Println (strings. IndexByte (aString, byteCharacter)) // Saída: 4
f := função(r runa)bool {
retornar r == 'o'
}
fmt. Println (strings. IndexFunc (aString, f)) // Saída: 4
fmt. Println (strings. IndexRune (aString, aRune)) // Saída: 4
}
IndexByte retorna o índice da primeira instância do caractere de byte na string ou -1. O IndexFunc A função retorna o índice na string do primeiro ponto Unicode que satisfaz uma determinada função. finalmente, o Índice Runa A função retorna o índice da primeira instância do ponto de código Unicode da runa.
Substituindo Substrings em Go
O Substituir e Substitua tudo função ajuda com a substituição de substrings. O Substituir A função aceita a string, a substring original e a substituição e várias substituições. O Substitua tudo A função aceita apenas a string, a substring inicial e a substituição.
importar (
"fmt"
"cordas"
)
funçãoprincipal() {
theString := "Esta é uma string de teste a ser modificada."
fmt. Println (strings. Substituir (theString, "é", "era", 1))
fmt. Println (strings. Substituir (theString, "é", "era", -1))
fmt. Println (strings. SubstituirTodos (a String, "é", "era"))
}
Observe que você pode usar tanto Replace como ReplaceAll para substituir todas as ocorrências dentro da string.
Separando e juntando strings
O cordas pacote contém o Dividir, Dividir Depois, SplitAfterN, e DivisãoN funções para dividir strings que retornam uma fatia das strings.
O Dividir método divide por um delimitador especificado. Semelhante ao Dividir método, o Dividir Depois O método divide a string, mas inclui o separador em seus resultados.
importar (
"fmt"
"cordas"
)funçãoprincipal() {
s := "Esta é uma string de teste a ser dividida."
fmt. Println (strings. Divisão (s, " "))
fmt. Println (strings. SplitAfter (s, " "))
fmt. Println (strings. SplitAfterN(s, " ", 3))
fmt. Println (strings. DivisãoN(s, " ", 3))
}
O SplitAfterN método é semelhante ao Dividir Depois função exceto que a função divide a string em um máximo especificado de substrings. O DivisãoN O método divide a string em um número máximo especificado sem incluir o separador nas substrings.
Você pode juntar strings com o Juntar função do cordas pacote. O Juntar função recebe uma fatia e um delimitador.
importar (
"fmt"
"cordas"
)
funçãoprincipal() {
fmt. Println (strings. Juntar([]corda{"Olá", "Mundo"}, ":"))
// Saída: "Olá: Mundo"
}
Manipulando String Case
A manipulação de maiúsculas e minúsculas é útil para muitas tarefas, incluindo trabalhando com documentação. Você pode usar o Abaixar função para letras minúsculas, o ToUpper função para letras maiúsculas, e o ToTitle função para capitalização do título.
importar (
"fmt"
"cordas"
)funçãoprincipal() {
s := "Esta é uma string de teste."
fmt. Println (strings. ToLower (s)) // esta é uma string de teste.
fmt. Println (strings. Superior (s)) // ESTA É UMA STRING DE TESTE.
fmt. Println (strings. Para Título(s)) // ESTA É UMA STRING DE TESTE.
}
Construção de strings em Go
Os construtores de string são um tipo que permite uma concatenação eficiente em Go. O bytes. Amortecedor type é um dos construtores de strings comumente usados. O bytes. Amortecedor O método implementa um buffer crescente de bytes com métodos de leitura e gravação para operações, permitindo acréscimos de string eficientes sem a necessidade de fazer novas cópias, ao contrário do método + operação e o Juntar função.
importar (
"fmt"
"cordas"
)funçãoprincipal() {
var cordas b. Construtor// Escreve algumas strings para o construtor
b. WriteString("Esse ")
b. WriteString("é ")
b. WriteString("a ")
b. WriteString("teste ")
b. WriteString("corda.")// Obtém o comprimento do construtor
fmt. Imprimir (b. Len())// Converte o construtor em uma string
str := b. Corda()
fmt. Println (str)// Reinicializa o construtor
b. Reiniciar()// Escreva mais algumas strings para o construtor
b. WriteString("Esse ")
b. WriteString("é ")
b. WriteString("outro ")
b. WriteString("teste ")
b. WriteString("corda.")// Obtém a capacidade do construtor
fmt. Imprimir (b. Boné())
// Converte o construtor em uma string novamente
Str = b. Corda()
fmt. Println (str)
}
O principal função demonstra como você pode usar o cordas. Construtor tipo para construção de string eficiente. O WriteString método do Cordas. Construtor O tipo estende a sequência de strings entre si, e o Len O método retorna o comprimento da string construída.
O Corda O método converte o conteúdo do construtor em uma string e o Reiniciar O método redefine o construtor para construção de string adicional.
O Boné O método retorna a capacidade do construtor. Este é o espaço atual que Go alocou para a string.
Corte de strings em Go
O cordas pacote também fornece funcionalidade para aparar strings no Aparar, Aparar Esquerda, TrimPrefix, ApararDireita, TrimSpace, e TrimSuffix funções.
importar (
"cordas"
"fmt"
)funçãoprincipal() {
// a string completa
s := "Olá Mundo!"// o elemento para o trim
prefixo := "Olá"
sufixo := "Mundo!"// apara uma string pelo conjunto de aparas especificado
fmt. Println (strings. Corte (s, "!"))// corta por espaços no início e no final da string
fmt. Println (strings. TrimSpace(s))// apara da string esquerda pelo conjunto de aparas especificado
fmt. Println (strings. Aparar Esquerda (s, "Olá"))// apara da string direita pelo conjunto de aparas especificado
fmt. Println (strings. TrimRight (s, "Mundo!"))// corta um prefixo
fmt. Println (strings. TrimPrefix (s, prefixo))
// elimina um sufixo específico
fmt. Println (strings. TrimSuffix (s, sufixo))
}
O principal A função demonstra como você pode usar as funções para aparar. As diferentes funções aparam o s cadeia de várias maneiras:
Você pode formatar strings em Go
A biblioteca padrão Go também fornece o pacote fmt para formatação de strings. O pacote fmt usa verbos de formatação no estilo C para formatação eficiente de strings em Go.
