¿Cómo puedes trabajar con cadenas en el lenguaje Go…

En Go, las cadenas son secuencias inmutables de bytes.

Las principales formas de trabajar con cadenas:

Creación:

// Literal de cadena
s1 := "Hello, Go!"

// Desde un slice de bytes
byteArray := []byte{'H', 'e', 'l', 'l', 'o'}
s2 := string(byteArray)

Concatenación:

s3 := "World"
result := s1 + " " + s3 // Uso del operador +

Para muchas concatenaciones, es más eficiente usar strings.Builder:

import "strings"

var sb strings.Builder
sb.WriteString("Hello")
sb.WriteString(", ")
sb.WriteString("World!")
result2 := sb.String()

Longitud:

En bytes:
```
byteLength := len(s1)
```

En caracteres (runes):

runeLength := utf8.RuneCountInString(s1) // Requiere importar "unicode/utf8"

Acceso a caracteres (runes) e iteración: En Go, las cadenas están compuestas por bytes, pero al iterar con range se decodifican en runas (puntos de código Unicode).
```
import "fmt"

for index, runeValue := range s1 {
    fmt.Printf("Índice: %d, Rune: %c, Tipo: %T\n", index, runeValue, runeValue)
}
```
El acceso directo por índice devuelve un byte, no una rune:
```
b := s1[0] // Devuelve el byte 'H'
```

Conversión:

A slice de bytes:
```
byteSlice := []byte(s1)
```
A slice de runas:
```
runeSlice := []rune(s1)
```

Paquete strings: Ofrece muchas funciones útiles para trabajar con cadenas:
- strings.Contains(s, substr): Verifica si contiene una subcadena.
- strings.HasPrefix(s, prefix): Verifica si tiene un prefijo.
- strings.HasSuffix(s, suffix): Verifica si tiene un sufijo.
- strings.Index(s, substr): Busca la primera ocurrencia de una subcadena.
- strings.ReplaceAll(s, old, new): Reemplaza todas las ocurrencias de una subcadena.
- strings.Split(s, sep): Divide la cadena por un separador.
- strings.Join(a []string, sep string): Une un slice de cadenas.
- strings.ToLower(s): Convierte a minúsculas.
- strings.ToUpper(s): Convierte a mayúsculas.
- strings.TrimSpace(s): Elimina espacios en blanco al principio y al final.
Paquete fmt: Para formatear y escanear cadenas.

Paquete strconv: Para convertir cadenas a tipos numéricos y viceversa.

import "strconv"

i, err := strconv.Atoi("123") // De string a int
s := strconv.Itoa(i)         // De int a string

La inmutabilidad de las cadenas es importante y significa que cualquier operación que parezca modificar la cadena (por ejemplo, concatenación o Replace) en realidad crea una nueva cadena.

¿Cómo puedes trabajar con cadenas en el lenguaje Go?