La manipulación de cadenas es fundamental en el desarrollo de software; la mayoría de los lenguajes de programación proporcionan un tipo de cadena, después de todo. Una cadena es una secuencia de caracteres: letras, números y símbolos.
La manipulación de cadenas resulta útil para diversas aplicaciones, desde el procesamiento de texto y el análisis de datos hasta el desarrollo web. Las operaciones populares de manipulación de cadenas son la concatenación, la validación de datos, la extracción y el formateo. Go proporciona un paquete de manipulación de cadenas llamado "cadenas" en la biblioteca estándar.
El paquete de cuerdas
El instrumentos de cuerda El paquete proporciona varias funciones útiles para la manipulación de cadenas y otras operaciones. El paquete incluye funcionalidad para operaciones de subcadenas, recorte, comparación de cadenas, conversión de cadenas, construcción de cadenas, división y más.
Puede importar el paquete de cadenas especificando el nombre del paquete en su lista de importaciones.
importar"instrumentos de cuerda"
Búsqueda de subcadenas
El instrumentos de cuerda El paquete proporciona tres funciones para buscar subcadenas: el Contiene función, la ContieneCualquiera función, y la Contiene Runa función.
El Contiene La función comprueba si la cadena especificada contiene la subcadena. El ContieneCualquiera La función comprueba si la cadena contiene algún carácter en la subcadena, y la Contiene Runa La función comprueba si la cadena contiene una runa (un carácter Unicode).
importar (
"fmt"
"instrumentos de cuerda"
)funciónprincipal() {
una cadena := "¡Hola Mundo!"
subcadena := "Mundo"
personajes := "aeiou"
una Runa := 'o'
fmt. Println (cadenas. Contiene (unaCadena, subcadena)) // Salida: verdadero
fmt. Println (cadenas. ContieneCualquiera (unaCadena, caracteres)) // Salida: verdadero
fmt. Println (cadenas. Contiene Runa (una Cadena, una Runa)) // Salida: verdadero
}
Puede recuperar el índice de una subcadena con el Índice, ÍndiceCualquiera, ÍndiceByte, y IndexFunc funciones El Índice La función devuelve el índice de una subcadena, si ocurre en otra cadena dada. El ÍndiceCualquiera función devuelve el índice de la primera instancia de un punto de código Unicode o -1 si ninguno de los personajes está presente.
importar (
"fmt"
"instrumentos de cuerda"
)funciónprincipal() {
una cadena := "¡Hola Mundo!"
subcadena := "mundo"
caracteres := "wrld"
byteCharacter := byte('o')
una Runa := runa('o')fmt. Println (cadenas. Índice (unaCadena, subcadena)) // Salida: 7
fmt. Println (cadenas. IndexAny (una cadena, caracteres)) // Salida: 7
fmt. Println (cadenas. IndexByte (una cadena, byteCharacter)) // Salida: 4
f := función(r runa)bool {
devolver r == 'o'
}
fmt. Println (cadenas. IndexFunc (unaCadena, f)) // Salida: 4
fmt. Println (cadenas. RunaIndice (unaCadena, unaRuna)) // Salida: 4
}
ÍndiceByte devuelve el índice de la primera instancia del carácter de byte en la cadena o -1. El IndexFunc La función devuelve el índice en la cadena del primer punto Unicode que satisface una función dada. Finalmente, el IndexRune La función devuelve el índice de la primera instancia del punto de código Unicode de la runa.
Sustitución de subcadenas en Go
El Reemplazar y Reemplaza todo función de ayuda con la sustitución de subcadenas. El Reemplazar La función toma la cadena, la subcadena original y el reemplazo y varios reemplazos. El Reemplaza todo La función solo toma la cadena, la subcadena inicial y el reemplazo.
importar (
"fmt"
"instrumentos de cuerda"
)
funciónprincipal() {
laCadena := "Esta es una cadena de prueba para ser modificada".
fmt. Println (cadenas. Reemplazar (laCadena, "es", "era", 1))
fmt. Println (cadenas. Reemplazar (laCadena, "es", "era", -1))
fmt. Println (cadenas. ReemplazarTodo (laCadena, "es", "era"))
}
Tenga en cuenta que puede usar tanto Reemplazar como Reemplazar todo para reemplazar todas las ocurrencias dentro de la cadena.
Dividir y unir cadenas
El instrumentos de cuerda paquete contiene el Dividir, dividir después, DividirDespuésN, y DividirN funciones para dividir cadenas que devuelven una porción de las cadenas.
El Dividir el método se divide por un delimitador especificado. Similar a Dividir método, el dividir después El método divide la cadena, pero incluye el separador en sus resultados.
importar (
"fmt"
"instrumentos de cuerda"
)funciónprincipal() {
es := "Esta es una cadena de prueba para dividir".
fmt. Println (cadenas. dividir (s, " "))
fmt. Println (cadenas. dividir después (s, " "))
fmt. Println (cadenas. DividirDespuésN(s, " ", 3))
fmt. Println (cadenas. DividirN(s, " ", 3))
}
El DividirDespuésN método es similar al dividir después excepto que la función divide la cadena en un máximo especificado de subcadenas. El DividirN El método divide la cadena en un número máximo especificado sin incluir el separador en las subcadenas.
Puede unir cadenas con el Unirse función de la instrumentos de cuerda paquete. El Unirse La función toma un segmento y un delimitador.
importar (
"fmt"
"instrumentos de cuerda"
)
funciónprincipal() {
fmt. Println (cadenas. Unirse([]cadena{"Hola", "Mundo"}, ":"))
// Salida: "Hola: Mundo"
}
Caso de cadena de manipulación
La manipulación de mayúsculas y minúsculas es útil para muchas tareas, incluidas trabajando con documentacion. Puedes usar el Reducir función de minúsculas, la ParaSuperior función de mayúsculas, y la al título función para la cubierta del título.
importar (
"fmt"
"instrumentos de cuerda"
)funciónprincipal() {
es := "Esta es una cadena de prueba".
fmt. Println (cadenas. ParaBajar (s)) // esta es una cadena de prueba.
fmt. Println (cadenas. Superior (s)) // ESTA ES UNA CADENA DE PRUEBA.
fmt. Println (cadenas. Al título (s)) // ESTA ES UNA CADENA DE PRUEBA.
}
Creación de cadenas en Go
Los constructores de cadenas son un tipo que permite una concatenación eficiente en Go. El bytes Buffer type es uno de los constructores de cadenas más utilizados. El bytes Buffer implementa un búfer creciente de bytes con métodos de lectura y escritura para las operaciones, lo que permite anexar cadenas eficientemente sin necesidad de hacer nuevas copias, a diferencia del método + operación y el Unirse función.
importar (
"fmt"
"instrumentos de cuerda"
)funciónprincipal() {
variable cuerdas b. Constructor// Escribe algunas cadenas al constructor
b. EscribirCadena("Este ")
b. EscribirCadena("es ")
b. EscribirCadena("a ")
b. EscribirCadena("prueba ")
b. EscribirCadena("cadena.")// Obtener la longitud del constructor
fmt. Imprimir (n. Len())// Convierte el constructor en una cadena
cadena := b. Cadena()
fmt. Imprimir (str)// Reiniciar el constructor
b. Reiniciar()// Escribe algunas cadenas más al constructor
b. EscribirCadena("Este ")
b. EscribirCadena("es ")
b. EscribirCadena("otro ")
b. EscribirCadena("prueba ")
b. EscribirCadena("cadena.")// Obtener la capacidad del constructor
fmt. Imprimir (n. Gorra())
// Convierte el constructor en una cadena de nuevo
cadena = b. Cadena()
fmt. Imprimir (str)
}
El principal función demuestra cómo se puede utilizar el instrumentos de cuerda. Constructor tipo para la construcción eficiente de cadenas. El EscribirCadena metodo de la Instrumentos de cuerda. Constructor tipo extiende la secuencia de cadenas entre sí, y el Len El método devuelve la longitud de la cadena construida.
El Cadena El método convierte el contenido del constructor en una cadena y el Reiniciar El método restablece el generador para la creación de cadenas adicionales.
El Gorra El método devuelve la capacidad del constructor. Este es el espacio actual que Go ha asignado para la cadena.
Recorte de hilo en Go
El instrumentos de cuerda El paquete también proporciona funcionalidad para recortar cadenas en el Recortar, TrimLeft, TrimPrefix, Recortar a la derecha, TrimSpace, y TrimSufijo funciones
importar (
"instrumentos de cuerda"
"fmt"
)funciónprincipal() {
// la cadena completa
es := "¡Hola Mundo!"// el elemento para el recorte
prefijo := "Hola"
sufijo := "¡Mundo!"// recorta una cadena por conjunto de recorte especificado
fmt. Println (cadenas. Recortar (s, "!"))// recorta espacios al principio y al final de la cadena
fmt. Println (cadenas. TrimSpace(s))// recorta desde la cadena izquierda por el conjunto de recortes especificado
fmt. Println (cadenas. TrimLeft (s, "Hola"))// recorta de la cadena derecha por el conjunto de recorte especificado
fmt. Println (cadenas. RecortarDerecha (s, "¡Mundo!"))// recorta un prefijo
fmt. Println (cadenas. TrimPrefix (s, prefijo))
// recorta un sufijo específico
fmt. Println (cadenas. TrimSufijo (s, sufijo))
}
El principal función demuestra cómo puede utilizar las funciones para recortar. Las diferentes funciones recortan el s cadena de varias maneras:
Puede formatear cadenas en Go
La biblioteca estándar de Go también proporciona el paquete fmt para el formato de cadenas. El paquete fmt usa verbos de formato de estilo C para un formato de cadena eficiente en Go.