Schreiben einer CLI-Anwendung für einen Tippgeschwindigkeitstest in Golang

Mussten wir lange und intensiv über diesen Titel nachdenken? ... Jetzt, wo wir das geklärt haben, lasst uns ein paar verdammte Codes schreiben :)

Pumpen bremsen? kreischhhhh.... Lassen Sie uns eine kleine Einführung in das geben, was wir heute zu bauen versuchen werden. Falls der Titel nicht offensichtlich war, werden wir eine CLI-Anwendung erstellen, die Ihre Tippgeschwindigkeit in Golang berechnet – obwohl Sie buchstäblich dieselbe Anwendung erstellen können, indem Sie dieselben Techniken in jeder Programmiersprache Ihrer Wahl anwenden.

Jetzt lasst uns programmieren?

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

In unsere main.go-Datei importieren wir die Pakete, die wir zum Schreiben unserer Logik benötigen. Wir erstellen auch einen Satzausschnitt. Fühlen Sie sich frei, noch ein paar weitere hinzuzufügen.

// 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) < len(source) {
        invalid++
        source = source[:len(target)]
    }

    for i := 0; i < len(target); i++ {
        if target[i] == source[i] {
            valid++
        }
        if target[i] != source[i] {
            invalid++
        }
    }

    return valid, invalid
}

// Calculates the degree of correctness
func precision(pos, fal int) int {
    return pos / (pos + fal) * 100
}

// Self explanatory - don't stress me ?
func timeElapsed(start, end time.Time) float64 {
    return end.Sub(start).Seconds()
}

// Refer to the last comment
func accuracy(correct, total int) int {
    return (correct / total) * 100
}

// ?
func Speed(chars int, secs float64) float64 {
    return (float64(chars) / secs) * 12
}

Anschließend erstellen wir einige Funktionen, die sich beim Schreiben unserer Anwendungslogik als nützlich erweisen.

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")
            _ = <-timer.C

            sentence := Choice(sentences)
            fmt.Printf("%s\n", sentence)

            start := time.Now()
            response, err := Input(">> ")
            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")
        }
    }
}

In unserer Hauptfunktion schreiben wir eine Willkommensnachricht an das Terminal und erstellen eine Endlosschleife, um unser Programm auszuführen. Anschließend geben wir eine Bestätigungsmeldung an das stdout-Terminal aus, mit der Option, das Programm zu beenden. Wenn Sie fortfahren möchten, wird ein Satz aus den zuvor geschriebenen Sätzen ausgewählt und unmittelbar nach der Aufzeichnung der Startzeit im Terminal angezeigt. Wir sammeln die Benutzereingaben, berechnen Zeit, Geschwindigkeit, Präzision und Genauigkeit und zeigen die Ergebnisse dann wieder am Terminal an. Die Endlosschleife wird zurückgesetzt und die Anwendung wird erneut ausgeführt, bis Sie das Programm beenden.

Voila!!! Wir haben gerade unser erstes Programm in Golang geschrieben.

Das obige ist der detaillierte Inhalt vonSchreiben einer CLI-Anwendung für einen Tippgeschwindigkeitstest in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!