Menulis Aplikasi CLI Ujian Kelajuan Menaip di Golang

Terpaksa berfikir panjang tentang tajuk itu ?... sekarang setelah kita berjaya mengatasinya, mari tulis kod buruk :)

Pam brek ? screechhhhh.... Mari kita buat sedikit pengenalan tentang apa yang akan kita cuba bina hari ini. Sekiranya tajuk itu tidak jelas, kami akan membina aplikasi CLI yang mengira kelajuan menaip anda dalam golang - walaupun anda benar-benar boleh membina aplikasi yang sama, mengikut teknik yang sama dalam mana-mana bahasa pengaturcaraan pilihan anda.

Sekarang, mari kod ?

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

Dalam fail main.go kami, kami mengimport pakej yang kami perlukan untuk menulis logik kami. Kami juga mencipta sepotong ayat. Jangan ragu untuk menambah banyak lagi.

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

Kami kemudiannya membuat beberapa fungsi yang akan berguna apabila kami menulis logik aplikasi kami.

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

Dalam fungsi utama kami, kami menulis mesej selamat datang ke terminal dan mencipta gelung tak terhingga untuk menjalankan program kami. Kami kemudian mencetak mesej pengesahan ke stdout - terminal - dengan pilihan untuk keluar dari program. Jika anda memilih untuk meneruskan, ayat dipilih daripada hirisan ayat yang ditulis sebelum ini dan dipaparkan dalam terminal sejurus selepas masa mula direkodkan. Kami mengumpul input pengguna dan mengira masa, kelajuan, ketepatan dan ketepatan kemudian memaparkan keputusan kembali ke terminal. Gelung tak terhingga ditetapkan semula dan aplikasi berjalan semula sehingga anda menarik diri daripada program.

Vila!!! Kami baru sahaja menulis program pertama kami di golang.

Atas ialah kandungan terperinci Menulis Aplikasi CLI Ujian Kelajuan Menaip di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!