Nivel 5: Creemos un Analizador de Texto Multifuncional utilizando bucles

Hoy aprenderás uno de los conceptos más fundamentales y versátiles de Go: los bucles for. A diferencia de muchos otros lenguajes que tienen while, do-while, foreach, etc., Go simplifica las cosas con un único tipo de bucle: for. Pero no te dejes engañar por su aparente simplicidad; este único bucle puede hacer todo lo que los otros tipos de bucles hacen en otros lenguajes, ¡y más!

Para demostrar la flexibilidad y poder del bucle for en Go, vamos a crear un Analizador de Texto Multifuncional. Este proyecto no solo nos permitirá explorar las diferentes formas de usar for, sino que también nos dará herramientas útiles para el procesamiento de texto.

Preparando el Terreno 🏗️

Primero, configuremos nuestro proyecto:

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    texto := `Go es un lenguaje de programación concurrente y compilado 
    inspirado en la sintaxis de C. Ha sido desarrollado por Google, y sus 
    diseñadores iniciales fueron Robert Griesemer, Rob Pike y Ken Thompson. 
    Go es eficiente, escalable y productivo.`

    fmt.Println("Analizador de Texto Multifuncional")
    fmt.Println("----------------------------------")

    // Llamadas a nuestras funciones irán aquí
}

Ahora, implementemos cada función de nuestro analizador, explorando diferentes usos del bucle for.

1. Contar Palabras: El Bucle for Tradicional

El bucle for tradicional en Go es similar al de C o Java. Es perfecto cuando necesitas un control preciso sobre la iteración.

func contarPalabras(texto string) int {
    palabras := strings.Fields(texto)
    count := 0
    for i := 0; i < len(palabras); i++ {
        count++
    }
    return count
}

Este bucle es equivalente al for clásico en otros lenguajes. Inicializamos una variable, definimos una condición de continuación y especificamos cómo se incrementa el contador.

Uso en main():

fmt.Printf("1. Número total de palabras: %d\n", contarPalabras(texto))

Output:

1. Número total de palabras: 38

2. Palabra Más Larga: Bucle for con range

El bucle for con range es el equivalente de Go al foreach en otros lenguajes. Es ideal para iterar sobre slices, arrays, maps o strings.

func palabraMasLarga(texto string) string {
    palabras := strings.Fields(texto)
    masLarga := ""
    for _, palabra := range palabras {
        if len(palabra) > len(masLarga) {
            masLarga = palabra
        }
    }
    return masLarga
}

Aquí, range nos proporciona cada palabra del slice palabras. El _ ignora el índice que range normalmente proporciona, ya que no lo necesitamos.

Uso en main():

fmt.Printf("2. Palabra más larga: %s\n", palabraMasLarga(texto))

Output:

2. Palabra más larga: programación

func mostrarFrecuenciaLetras(texto string) {
    frecuencia := make(map[rune]int)
    textoRunes := []rune(texto)
    i := 0

    fmt.Println("3. Frecuencia de letras:")

    // Ejemplo de cómo 'len' puede cambiar con caracteres especiales
    // Créeme, esto te evitará dolores de cabeza al usar len, a veces es una total locura
    palabraNormal := "cafeteria"
    palabraConTilde := "cafetería"
    fmt.Printf("   Longitud de '%s': %d\n", palabraNormal, len(palabraNormal))
    fmt.Printf("   Longitud de '%s': %d\n", palabraConTilde, len(palabraConTilde))
    fmt.Printf("   Longitud real de '%s': %d\n", palabraConTilde, len([]rune(palabraConTilde)))

    // Bucle principal para contar frecuencia de letras
    for i < len(textoRunes) {
        letra := textoRunes[i]
        letraLower := unicode.ToLower(letra)
        if unicode.IsLetter(letraLower) {
            frecuencia[letraLower]++
        }
        i++
    }
    
    // Mostrar resultados
    for letra, freq := range frecuencia {
        fmt.Printf("   %c: %d\n", letra, freq)
    }

    fmt.Printf("   Total de letras únicas: %d\n", len(frecuencia))
}

texto := `Go es un lenguaje de programación concurrente y compilado 
inspirado en la sintaxis de C. Ha sido desarrollado por Google, y sus 
diseñadores iniciales fueron Robert Griesemer, Rob Pike y Ken Thompson. 
Go es eficiente, escalable y productivo. También maneja texto en español: á, é, í, ó, ú.`

mostrarFrecuenciaLetras(texto)

3. Frecuencia de letras:
   Longitud de 'cafeteria': 9
   Longitud de 'cafetería': 10  //Nota cómo "pareciera" que la tilde también se cuenta en el len
   Longitud real de 'cafetería': 9
   a: 15
   b: 2
   c: 5
   d: 7
   e: 20
   f: 2
   g: 4
   i: 11
   l: 8
   m: 4
   n: 13
   o: 15
   p: 4
   r: 11
   s: 11
   t: 7
   u: 3
   v: 1
   x: 1
   y: 3
   á: 1
   é: 1
   í: 1
   ó: 1
   ú: 1
   Total de letras únicas: 25

Los bucles for anidados son útiles para operaciones más complejas, como manipular cada carácter de cada palabra.

func invertirPalabras(texto string) string {
    palabras := strings.Fields(texto)
    for i, palabra := range palabras {
        runes := []rune(palabra)
        for j, k := 0, len(runes)-1; j < k; j, k = j+1, k-1 {
            runes[j], runes[k] = runes[k], runes[j]
        }
        palabras[i] = string(runes)
    }
    return strings.Join(palabras, " ")
}

Aquí tenemos un bucle for con range para iterar sobre las palabras, y dentro de él, un bucle for tradicional para invertir los caracteres.

Uso en main():

fmt.Printf("4. Texto con palabras invertidas: %s\n", invertirPalabras(texto))

Output:

4. Texto con palabras invertidas: oG se nu ejaugnel ed nóicamargorp etnerrucnoc y odalipmoc ...

5. Buscar Palabras Clave: Bucle for con break y continue

Este ejemplo muestra cómo usar break y continue dentro de un bucle for para controlar el flujo de ejecución.

func buscarPalabrasClave(texto string, claves []string) int {
    palabras := strings.Fields(strings.ToLower(texto))
    count := 0
    for _, palabra := range palabras {
        for _, clave := range claves {
            if palabra == strings.ToLower(clave) {
                count++
                break // Evita contar la misma palabra más de una vez
            }
        }
    }
    return count
}

El break aquí nos permite salir del bucle interno una vez que encontramos una coincidencia.

Uso en main():

fmt.Printf("5. Número de palabras clave: %d\n", buscarPalabrasClave(texto, []string{"Go", "programación", "Google"}))

Output:

5. Número de palabras clave: 4

6. Analizar Estructura de Oraciones: Bucle for Infinito con break

El bucle for infinito es útil cuando no sabemos cuántas iteraciones necesitaremos. Usamos break para salir cuando sea necesario.

func analizarEstructuraOraciones(texto string) {
    oraciones := strings.Split(texto, ".")
    for i := 0; ; i++ {
        if i >= len(oraciones) {
            break
        }
        oracion := strings.TrimSpace(oraciones[i])
        if oracion == "" {
            continue
        }
        palabras := strings.Fields(oracion)
        fmt.Printf("Oración %d: %d palabras\n", i+1, len(palabras))
    }
}

Este bucle for sin condición crearía un bucle infinito, pero usamos break para salir cuando hemos procesado todas las oraciones.

Uso en main():

fmt.Println("6. Análisis de estructura de oraciones:")
analizarEstructuraOraciones(texto)

Output:

6. Análisis de estructura de oraciones:
Oración 1: 12 palabras
Oración 2: 15 palabras
Oración 3: 5 palabras

Source code

https://github.com/Gognition/gognition-nivel5-analizador-textos-con-bucles.git

Conclusión

Como hemos visto, el bucle for en Go es increíblemente versátil. Puede replicar el comportamiento de while, do-while, foreach, y cualquier otro tipo de bucle que puedas necesitar. Esta simplicidad en el diseño del lenguaje hace que el código de Go sea más fácil de leer y mantener, sin sacrificar funcionalidad.

Recapitulemos los diferentes usos del for que hemos explorado:

1. Bucle tradicional: for i := 0; i < n; i++ { }
2. Bucle tipo "foreach": for index, value := range collection { }
3. Bucle tipo "while": for condition { }
4. Bucle infinito: for { }

Cada uno de estos patrones tiene sus usos, y dominarlos te permitirá escribir código Go más eficiente y elegante.

¿Qué otros usos interesantes del bucle for has encontrado en tus proyectos de Go? ¿Hay alguna funcionalidad de bucles en otros lenguajes que extrañes en Go? ¡Comparte tus pensamientos en los comentarios!

Happy coding, Gophers! 🐹💻