¿Cómo funcionan las cadenas en el lenguaje Go?

Las cadenas en Go son secuencias inmutables de bytes. Representan un "rebanado de bytes" ([]byte) con garantía de inmutabilidad.

Características clave:

• Inmutabilidad: Después de crear una cadena, no puede ser modificada. Cualquier operación que parezca modificarla, en realidad crea una nueva cadena.
• Representación: Por defecto, las cadenas en Go representan texto codificado en UTF-8. Sin embargo, simplemente son secuencias de bytes; la interpretación como UTF-8 ocurre al trabajar con runas.
• Runas: Los caracteres Unicode en Go se representan con el tipo rune, que es un alias para int32. La iteración sobre una cadena usando range decodifica automáticamente UTF-8 y proporciona las runas y sus índices iniciales en bytes.
• Longitud: La función len(s) devuelve la cantidad de bytes en la cadena, no la cantidad de caracteres (runas). Para obtener la cantidad de runas, se debe usar utf8.RuneCountInString(s) o iterar con range.
• Concatenación: Para unir cadenas, se usa el operador +. Esto crea una nueva cadena. Para una unión eficiente de muchas cadenas, se recomienda usar strings.Builder.

Ejemplos:

// Declaración de una cadena
str := "Hello, 世界"

// Longitud de la cadena (en bytes)
byteLen := len(str) // 13 (H(1) e(1) l(1) l(1) o(1) ,(1)  (1) 世(3) 界(3))

// Iteración sobre las runas
runeCount := 0
for index, runeValue := range str {
	// index - índice inicial de la runa en bytes
	// runeValue - la runa
	runeCount++
	// fmt.Printf("Índice: %d, Runa: %c (Valor: %d)\n", index, runeValue, runeValue)
}
// runeCount - número de runas (9)

// Acceso a un byte por índice
// Atención: esto es un byte, no un carácter!
// byteAtIndex := str[0] // 'H'
// byteAtIndex := str[7] // Byte inicial del carácter '世'

// Concatenación de cadenas
newStr := str + "!"

// Uso de strings.Builder para concatenación eficiente
// import "strings"
var builder strings.Builder
builder.WriteString("Hello, ")
builder.WriteString("World")
efficientStr := builder.String() // "Hello, World"