Tutorial

Introducción al paquete de Strings en Go

GoDevelopment

Introducción

El paquete string de Go tiene varias funciones disponibles para trabajar con el tipo de datos de cadena. Estas funciones nos permiten modificar y manipular fácilmente las cadenas. Podemos pensar que las funciones son acciones que realizamos en elementos de nuestro código. Las funciones integradas son aquellas que se definen en el lenguaje de programación de Go y están inmediatamente disponibles para su uso.

En este tutorial, revisaremos varias funciones diferentes que podemos usar para trabajar con cadenas en Go.

Aplicar mayúsculas y minúsculas a cadenas

Las funciones strings.ToUpper y strings.ToLower mostrarán una cadena con todas las letras de una cadena original convertidas a mayúsculas o minúsculas. Debido a que las cadenas son tipos de datos inmutables, la cadena devuelta será nueva. Cualquier carácter de la cadena que no sea una letra no se cambiará.

Para convertir la cadena "Sammy Shark" de modo que esté totalmente en mayúsculas, utilizaría la función strings.ToUpper:

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

Para la conversión a minúsculas:

fmt.Println(strings.ToLower(ss))
Output
sammy shark

Debido a usará el paquete strings, primero deberá importarlo a un programa. Para convertir la cadena a mayúsculas y minúsculas, todo el programa tendría el siguiente aspecto:

package main

import (
    "fmt"
    "strings"
)

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

Las funciones strings.ToUpper y strings.ToLower facilitan la evaluación y comparación de cadenas haciendo que las letras sean mayúsculas o minúsculas de manera uniforme. Por ejemplo, si un usuario escribe su nombre en minúsculas, aún podemos determinar si su nombre está en nuestra base de datos comparándolo con una versión totalmente en mayúsculas.

Funciones de búsqueda de cadena

El paquete strings tiene varias funciones que permiten determinar si una cadena contiene una secuencia de caracteres específica.

Función Uso
strings.HasPrefix Realiza búsquedas en la cadena desde el principio.
strings.HasSuffix Realiza búsquedas en la cadena desde el final.
strings.Contains Realiza búsquedas en cualquier parte de la cadena.
strings.Count Cuenta la cantidad de veces que aparece la cadena.

Las funciones strings.HasPrefix y strings.HasSuffix le permiten comprobar si una cadena comienza o finaliza con un conjunto específico de caracteres.

Por ejemplo, para comprobar si la cadena "Sammy Shark" comienza con Sammy y finaliza con Shark:

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

Usaría la función strings.Contains para comprobar si "Sammy Shark" contiene la secuencia Sh:

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

Finalmente, para ver cuántas veces aparece la letra S en la frase Sammy Shark:

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

Nota: Para todas las cadenas de Go se distinguen mayúsculas y minúsculas. Esto significa que Sammy no es igual que sammy.

Usar una s en minúsculas para obtener un recuento de Sammy Shark no es lo mismo que usar una S mayúscula:

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

Debido a que S es diferente de s, el recuento será 0.

Las funciones de cadenas son útiles cuando desea comparar o buscar cadenas en su programa.

Determinar la longitud de la cadena

La función integrada len() muestra el número de caracteres de una cadena. Esta función es útil cuando necesita aplicar extensiones mínimas o máximas de contraseñas, o para acortar cadenas más grandes de modo que estén dentro de ciertos límites para su uso como abreviaturas.

Para demostrar esta función, buscaremos la extensión de una cadena larga como una oración:

import (
    "fmt"
    "strings"
)

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

Establecemos la variable openSource igual a la cadena "Sammy contributes to open source." y dicha variable se pasa a la función len() con len(openSource). Finalmente, pasamos la función a la función fmt.Println() para poder ver el resultado del programa en la pantalla.

Tenga en cuenta que la función len() contará cualquier carácter vinculado por dobles comillas, como letras, números, caracteres de espacios en blanco y símbolos.

Funciones para la manipulación de cadenas

Las funciones strings.Join, strings.Split y strings.ReplaceAll son algunas formas adicionales de manipular cadenas en Go.

La función strings.Join es útil para combinar un segmento de cadenas en una nueva cadena única.

Para crear una cadena separada por comas a partir de un segmento de cadenas, usaríamos esta función de la siguiente forma:

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

Si deseamos añadir una coma y un espacio entre los valores de cadena de nuestra nueva cadena, podemos simplemente reescribir nuestra expresión con un espacio en blanco después de la coma: strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

Así como podemos unir cadenas, también podemos dividirlas. Para hacer esto, podemos usar la función strings.Split y realizar divisiones en los espacios:

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

El resultado es un segmento de cadenas. Debido a que se utilizó strings.Println, es difícil determinar el resultado con solo mirar. Para ver que es de hecho un segmento de cadenas, utilice la función fmt.Printf con el verbo %q para poner las cadenas entre comillas:

fmt.Printf("%q", s)
Output
["Sammy" "has" "a" "balloon."]

Otra función útil además de strings.Split es strings.Fields. La diferencia es que strings.Fields ignorará todos los espacios en blanco y solo dividirá los fields reales en una cadena:

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

La función strings.ReplaceAll puede tomar una cadena original y mostrar una cadena actualizada con alguna sustitución.

Digamos que el globo que Sammy tenía se perdió. Debido a que Sammy ya no tiene este globo, cambiaremos la subcadena "has" de la cadena original balloon por "had" en una nueva cadena:

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

Dentro de los paréntesis, primero está balloon, la variable que almacena la cadena original; la segunda subcadena "has" es lo que queremos sustituir y la tercera, "had", es la alternativa con la sustituiremos la segunda subcadena. Nuestro resultado tendrá este aspecto cuando lo incorporemos a un programa:

Output
Sammy had a balloon.

Usando la función de la cadena strings.Join, strings.Split y strings.ReplaceAll tendrá un mayor control para manipular cadenas en Go.

Conclusión

En este tutorial se repasaron algunas de las funciones más comunes del paquete string para el tipo de datos de cadena que puede usar para manipular y trabajar con cadenas en sus programas de Go.

Puede obtener más información sobre otros tipos de datos en Información sobre tipos de datos y leer más sobre las cadenas en Introducción al uso de cadenas.

Creative Commons License