¿Cómo están estructadas las cadenas en el lenguaje de programación Go?

Una cadena en Go es una secuencia inmutable de bytes.

Características clave:

• Inmutabilidad: después de crearla, la cadena no puede ser modificada.
• Representación: se almacena como un puntero y una longitud. El puntero apunta al primer byte de la secuencia en memoria. La longitud es la cantidad de bytes.
• Codificación: las cadenas en Go no contienen información sobre la codificación. A menudo se usan para almacenar UTF-8, pero pueden contener cualquier byte.
• Iteración por bytes: el ciclo for index, value range string al iterar sobre una cadena devuelve el índice y la rune (int32), no el byte.
• Iteración por runas: una rune representa un punto de código Unicode. Go usa UTF-8, por lo que una rune puede ocupar de 1 a 4 bytes.
• Obtener una subcadena: la operación de corte string[start:end] crea una nueva cadena que apunta a la misma sección de memoria, pero con límites diferentes.

Ejemplos:

// Declaración e inicialización
var s string
s = "Привет" // Literal de cadena en Go - secuencia de bytes,
             // generalmente interpretada como UTF-8

// Longitud de la cadena en bytes
byteLength := len(s) // 12, ya que "П", "р", "и", "в", "е", "т" son caracteres multibyte en UTF-8

// Iteración por runas
runeCount := 0
for index, runeValue := range s {
    // index - índice del inicio de la rune en bytes
    // runeValue - valor de la rune (int32)
    _ = index // Uso de un identificador anónimo _ para variable no utilizada
    // fmt.Printf("Índice: %d, Rune: %c (U+%04X)\n", index, runeValue, runeValue)
    runeCount++
}
// runeCount será 6

// Iteración por bytes
byteCount := 0
for i := 0; i < len(s); i++ {
    // s[i] - byte en el índice i
    _ = s[i] // Uso de un identificador anónimo
    // fmt.Printf("Byte en índice %d: %d\n", i, s[i])
    byteCount++
}
// byteCount será 12

// Obtener una subcadena (corte de bytes)
// Importante: el corte de bytes puede romper una rune multibyte
// sub := s[0:5] // Esto puede ser una secuencia UTF-8 inválida

// Uso de paquetes strings o unicode/utf8 para trabajar de forma segura con runas

Comparación con un corte de bytes ([]byte):

Característica	String	[]byte
Mutabilidad	No	Sí
Representación	Puntero + Longitud	Puntero + Longitud + Capacidad
Tipo	Primitive incorporado	Slice (corte)
Uso	Texto inmutable	Datos modificables (bytes)

Conversión entre string y []byte:

// string -> []byte
byteSlice := []byte(s)

// []byte -> string
newString := string(byteSlice)