¿Tuviste que pensar detenidamente en ese título?... ahora que lo hemos eliminado, escribamos un maldito código :)

¿Freno de bombas? screechhhhh.... Hagamos una pequeña introducción a lo que intentaremos construir hoy. En caso de que el título no sea obvio, crearemos una aplicación CLI que calcula su velocidad de escritura en golang, aunque literalmente puede crear la misma aplicación, siguiendo las mismas técnicas en cualquier lenguaje de programación de su elección.

Ahora, ¿vamos a codificar?

package main

import (
    "bufio"
    "fmt"
    "log"
    "math/rand"
    "os"
    "strings"
    "time"
)

var sentences = []string{
    "There are 60 minutes in an hour, 24 hours in a day and 7 days in a week",
    "Nelson Mandela is one of the most renowned freedom fighters Africa has ever produced",
    "Nigeria is the most populous black nation in the world",
    "Peter Jackson's Lord of the rings is the greatest film of all time",
}

En nuestro archivo main.go, importamos los paquetes que necesitaremos para escribir nuestra lógica. También creamos una porción de oraciones. No dudes en agregar muchos más.

// A generic helper function that randomly selects an item from a slice
func Choice[T any](ts []T) T {
    return ts[rand.Intn(len(ts))]
}

// Prompts and collects user input from the terminal
func Input(prompt string) (string, error) {
    fmt.Print(prompt)
    r := bufio.NewReader(os.Stdin)

    line, err := r.ReadString('\n')
    if err != nil {
        return "", err
    }

    return strings.Trim(line, "\n\r\t"), nil
}

// Compares two strings and keeps track of the characters  
// that match and those that don't
func CompareChars(target, source string) (int, int) {
    var valid, invalid int

    // typed some of the words
        // resize target to length of source
    if len(target) > len(source) {
        diff := len(target) - len(source)
        invalid  = diff
        target = target[:len(source)]
    }

    // typed more words than required
        // resize source to length of target
    if len(target) 



Luego creamos un par de funciones que serán útiles cuando escribamos la lógica de nuestra aplicación.



func main() {
    fmt.Println("Welcome to Go-Speed")
    fmt.Println("-------------------")

    for {
        fmt.Printf("\nWould you like to continue? (y/N)\n\n")
        choice, err := Input(">> ")
        if err != nil {
            log.Fatalf("could not read value: %v", err)
        }

        if choice == "y" {
            fmt.Println("Starting Game...")
            timer := time.NewTimer(time.Second)
            fmt.Print("\nBEGIN TYPING NOW!!!\n\n")
            _ = > ")
            if err != nil {
                log.Fatalf("could not read value: %v", err)
            }

            elasped := timeElapsed(start, time.Now())
            valid, invalid := CompareChars(sentence, response)
            fmt.Print("\nResult!\n")
            fmt.Println("-------")
            fmt.Printf("Correct Characters: %d\nIncorrect Characters: %d\n", valid, invalid)
            fmt.Printf("Accuracy: %d%%\n", accuracy(valid, len(sentence)))
            fmt.Printf("Precision: %d%%\n", precision(valid, invalid))
            fmt.Printf("Speed: %.1fwpm\n", Speed(len(sentence), elasped))
            fmt.Printf("Time Elasped: %.2fsec\n", elasped)
        }

        if choice == "N" {
            fmt.Println("Quiting Game...")
            break
        }

        if choice != "N" && choice != "y" {
            fmt.Println("Invalid Option")
        }
    }
}




En nuestra función principal, escribimos un mensaje de bienvenida en la terminal y creamos un bucle infinito para ejecutar nuestro programa. Luego imprimimos un mensaje de confirmación en stdout (terminal) con una opción para salir del programa. Si elige continuar, se selecciona una oración del segmento de oraciones escritas previamente y se muestra en la terminal justo después de registrar la hora de inicio. Recopilamos la entrada del usuario y calculamos el tiempo, la velocidad, la precisión y la exactitud y luego mostramos los resultados en la terminal. El bucle infinito se reinicia y la aplicación se ejecuta nuevamente hasta que usted cancele su participación en el programa.

 ¡¡¡Voilá!!! Acabamos de escribir nuestro primer programa en golang.