J'ai dû réfléchir longuement et sérieusement à ce titre ?... maintenant que nous avons réglé cela, écrivons un sacré code :)

Pompes de frein ? crihhhh.... Faisons une petite introduction à ce que nous allons tenter de construire aujourd'hui. Au cas où le titre ne serait pas évident, nous allons créer une application CLI qui calcule votre vitesse de frappe en golang - bien que vous puissiez littéralement créer la même application, en suivant les mêmes techniques dans n'importe quel langage de programmation de votre choix.

Maintenant, codons ?

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",
}

Dans notre fichier main.go, nous importons les packages dont nous aurons besoin pour écrire notre logique. Nous créons également une tranche de phrases. N'hésitez pas à en ajouter un peu plus.

// 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) 



Nous créons ensuite quelques fonctions qui nous seront utiles lorsque nous écrirons notre logique d'application.


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")
        }
    }
}




Dans notre fonction principale, nous écrivons un message de bienvenue sur le terminal et créons une boucle infinie pour exécuter notre programme. Nous imprimons ensuite un message de confirmation sur stdout - terminal - avec une option pour quitter le programme. Si vous choisissez de continuer, une phrase est sélectionnée parmi la tranche de phrases précédemment écrite et affichée dans le terminal juste après l'enregistrement de l'heure de début. Nous collectons les entrées de l'utilisateur et calculons le temps, la vitesse, la précision et l'exactitude, puis affichons les résultats sur le terminal. La boucle infinie se réinitialise et l'application s'exécute à nouveau jusqu'à ce que vous vous désinscriviez du programme.

Voila !!! Nous venons d'écrire notre premier programme en golang.