Cadenas de texto y manipulación

Operaciones básicas con cadenas

En Go, las cadenas son secuencias inmutables de bytes, lo que significa que cada vez que se manipula una cadena, se crea una nueva. Las operaciones básicas permiten trabajar con estas secuencias de forma eficiente. Una de las operaciones más comunes es la concatenación, que en Go se realiza utilizando el operador +. Por ejemplo:

cadena1 := "Hola,"
cadena2 := " mundo"
resultado := cadena1 + cadena2 // Resultado: "Hola, mundo"

El acceso a los caracteres de una cadena se realiza mediante índices. Las cadenas en Go son equivalentes a un array de bytes, por lo tanto, para acceder a un carácter específico, se utiliza la notación de corchetes. Es importante recordar que los índices empiezan en cero:

cadena := "Golang"
primerCaracter := cadena[0] // 'G'

Sin embargo, si la cadena contiene caracteres UTF-8, es recomendable iterar sobre la cadena usando un for con range para evitar problemas con caracteres multibyte:

cadena := "Hola, mundo"
for i, c := range cadena {
    fmt.Printf("Índice: %d, Carácter: %c\n", i, c)
}

La subcadenación permite extraer partes de una cadena utilizando un rango de índices. Esta operación se realiza con la sintaxis cadena[inicio:fin], donde inicio es inclusivo y fin es exclusivo:

cadena := "Hola, mundo"
subcadena := cadena[0:4] // "Hola"

Las cadenas en Go también se pueden comparar directamente usando los operadores relacionales estándar (==, !=, <, >, <=, >=). La comparación se realiza lexicográficamente, es decir, comparando el valor Unicode de los caracteres:

cadena1 := "Golang"
cadena2 := "Go"
esIgual := cadena1 == cadena2 // false

Para obtener la longitud de una cadena, se utiliza la función len, que devuelve el número de bytes que componen la cadena:

cadena := "Hola, mundo"
longitud := len(cadena) // 11

Es importante notar que len mide el número de bytes, no necesariamente el número de caracteres, especialmente en cadenas UTF-8. Para contar los caracteres, se debe iterar sobre la cadena con range.

Finalmente, para verificar si una cadena está vacía, se puede comparar directamente con una cadena vacía "" o utilizar la función len:

cadena := ""
estaVacia := len(cadena) == 0 // true

Estas operaciones básicas son fundamentales para la manipulación eficiente de cadenas en Go, permitiendo construir y analizar texto de manera directa y precisa.

Uso del paquete strings

El paquete strings en Go proporciona una serie de funciones que permiten realizar operaciones avanzadas sobre cadenas de texto. Este paquete es fundamental para manipular y analizar textos de manera eficiente y está optimizado para trabajar con cadenas codificadas en UTF-8.

Estas son algunas de las funciones más relevantes del paquete strings.

Contains()

Para verificar si una cadena contiene un determinado subtexto, se utiliza la función Contains. Esta función devuelve un valor booleano indicando si el subtexto está presente o no:

import "strings"

cadena := "Hola, mundo"
contiene := strings.Contains(cadena, "mundo") // true

Index()

Si se necesita encontrar el índice de la primera aparición de una subcadena dentro de otra, se puede utilizar la función Index. Devuelve el índice de la primera aparición o -1 si la subcadena no se encuentra:

indice := strings.Index(cadena, "mundo") // 6

EqualFold()

Para comparar cadenas ignorando diferencias de mayúsculas y minúsculas, se puede utilizar EqualFold. Esta función devuelve true si las cadenas son iguales sin tener en cuenta el caso:

igual := strings.EqualFold("GoLang", "golang") // true

Split()

La función Split permite dividir una cadena en un slice de subcadenas, utilizando un delimitador especificado. Esto es útil para procesar texto basado en separadores:

partes := strings.Split(cadena, ", ") // []string{"Hola", "mundo"}

Join()

Para unir un slice de cadenas en una sola cadena con un delimitador, se emplea la función Join. Esta operación es la inversa de Split:

unido := strings.Join(partes, ", ") // "Hola, mundo"

ToLower() y ToUpper()

Modificar una cadena para que todos sus caracteres estén en minúsculas o mayúsculas se logra con las funciones ToLower y ToUpper respectivamente:

minusculas := strings.ToLower(cadena) // "hola, mundo"
mayusculas := strings.ToUpper(cadena) // "HOLA, MUNDO"

TrimSpace()

Para eliminar espacios en blanco al inicio y al final de una cadena, se utiliza la función TrimSpace. Es útil para limpiar entradas de texto:

cadenaConEspacios := "   Hola, mundo   "
cadenaLimpia := strings.TrimSpace(cadenaConEspacios) // "Hola, mundo"

Replace()

El paquete strings también proporciona funciones para reemplazar partes de una cadena. Replace permite reemplazar todas o un número específico de ocurrencias de una subcadena por otra:

reemplazada := strings.Replace(cadena, "mundo", "Go", 1) // "Hola, Go"

Estas funciones del paquete strings son esenciales para realizar transformaciones y análisis de texto en aplicaciones Go, proporcionando una interfaz consistente y eficiente para el manejo de cadenas.

Formateo y construcción de cadenas con fmt

El paquete fmt en Go es esencial para el formateo de cadenas y la creación de salidas formateadas. Este paquete proporciona una serie de funciones que permiten construir cadenas complejas a partir de datos de manera eficiente y flexible. Las funciones más utilizadas del paquete fmt incluyen Printf, Sprintf, y Fprintf, cada una con su respectivo propósito.

Printf()

La función Printf se utiliza para imprimir texto formateado en la salida estándar. Los especificadores de formato, que comienzan con %, permiten definir cómo se debe presentar cada argumento. Algunos de los especificadores más comunes son:

• %v: Muestra el valor en su forma predeterminada.
• %T: Muestra el tipo del valor.
• %d: Formatea enteros en base decimal.
• %s: Formatea cadenas de texto.
• %f: Formatea números de coma flotante.

Por ejemplo, para imprimir un entero y una cadena:

nombre := "Juan"
edad := 30
fmt.Printf("Nombre: %s, Edad: %d\n", nombre, edad)

Sprintf()

La función Sprintf es similar a Printf, pero en lugar de imprimir el resultado directamente, devuelve la cadena formateada. Esto es útil cuando se necesita construir una cadena antes de usarla:

mensaje := fmt.Sprintf("Nombre: %s, Edad: %d", nombre, edad)

Fprintf()

Fprintf permite enviar la salida formateada a un destino específico, como un archivo o un buffer, en lugar de la salida estándar. Se requiere un io.Writer como primer argumento:

archivo, err := os.Create("salida.txt")
if err != nil {
    log.Fatal(err)
}
defer archivo.Close()
fmt.Fprintf(archivo, "Nombre: %s, Edad: %d\n", nombre, edad)

Formateo de cadenas

Para formatear cadenas, fmt proporciona especificadores adicionales que permiten un control más granular sobre el formato de salida. Por ejemplo, para controlar la precisión de un número de coma flotante, se puede usar %.[precision]f:

precio := 49.95
fmt.Printf("Precio: %.2f\n", precio) // Precio: 49.95

Alineamiento y ajuste de los campos de salida

Además, fmt permite alinear y ajustar la anchura de los campos de salida mediante especificadores como %[anchura]s o %[anchura]d. Esto es particularmente útil para crear tablas o columnas alineadas:

fmt.Printf("%-10s %10s\n", "Producto", "Precio")
fmt.Printf("%-10s %10.2f\n", "Manzanas", 1.23)
fmt.Printf("%-10s %10.2f\n", "Naranjas", 2.34)

El uso del paquete fmt es fundamental para la construcción de cadenas en Go, proporcionando herramientas robustas para el formateo y la presentación de datos. Estas capacidades son esenciales para generar salidas de texto claras y organizadas en aplicaciones Go.