Cara menggunakan input dan output papan kekunci di Golang

Golang ialah bahasa yang cekap dan moden yang sangat mudah dan praktikal semasa membangunkan aplikasi. Artikel ini akan memperkenalkan cara menggunakan input dan output papan kekunci dalam Golang.

1. Gunakan pakej fmt untuk mengeluarkan
Pakej fmt ialah pakej yang sangat biasa digunakan dalam perpustakaan standard Golang dan menyediakan banyak fungsi berguna. Ini termasuk mengeluarkan kandungan ke konsol. Menggunakan pakej fmt untuk mengeluarkan adalah sangat mudah, hanya panggil fungsi fmt.Println():

package main

import "fmt"

func main() {
    fmt.Println("Hello, world!")
}

Jalankan kod ini, kita boleh melihat output "Hello, world!"

2. Gunakan pakej bufio untuk input
Selain output, input juga merupakan fungsi yang sering kita perlu gunakan. Golang menyediakan pakej bufio, yang boleh membaca input pengguna dengan mudah. Berikut ialah contoh mudah membaca input dan output pengguna:

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Enter text: ")
    text, _ := reader.ReadString('\n')
    fmt.Println("You entered: ", text)
}

Dalam kod ini, kami mula-mula mengimport pakej bufio dan pakej os, dan mencipta pembolehubah pembaca dalam fungsi utama untuk input pengguna Baca. Panggil fungsi fmt.Print() untuk mengeluarkan maklumat segera, tunggu input pengguna, dan kemudian gunakan fungsi reader.ReadString() untuk membaca input pengguna. Akhir sekali, gunakan fungsi fmt.Println() untuk mengeluarkan perkara yang dimasukkan pengguna.

3. Gunakan perpustakaan pihak ketiga untuk memberikan pengalaman input/output yang lebih baik

Walaupun kaedah di atas mudah, ia hanya melaksanakan fungsi input dan output yang paling asas. Jika pengalaman pengguna yang lebih baik diperlukan, kami boleh mempertimbangkan untuk menggunakan perpustakaan pihak ketiga. Berikut ialah dua perpustakaan yang patut disyorkan:

1. termui
   termui ialah perpustakaan antara muka pengguna berasaskan terminal yang menyediakan banyak komponen UI yang berguna untuk menjadikan aplikasi Golang kami kelihatan lebih utama. Berikut ialah contoh mudah yang dilaksanakan menggunakan termui:

package main

import (
    "github.com/gizak/termui/v3"
    "github.com/gizak/termui/v3/widgets"
)

func main() {
    err := termui.Init()
    if err != nil {
        panic(err)
    }
    defer termui.Close()

    p := widgets.NewParagraph()
    p.Text = "Enter text here:"
    p.SetRect(0, 0, 25, 3)

    tb := widgets.NewTextEdit()
    tb.SetRect(0, 3, 25, 5)

    termui.Render(p, tb)

    for e := range termui.PollEvents() {
        if e.Type == termui.KeyboardEvent {
            if e.ID == "q" {
                return
            }
            if e.ID == "<Enter>" {
                p.Text = "You entered " + tb.Text
                tb.SetText("")
            }
            termui.Render(p, tb)
        }
    }
}

Dalam contoh ini, kami menggunakan widget termui.NewParagraph() dan widgets.NewTextEdit() berfungsi untuk mencipta perenggan dan kotak Edit teks. Fungsi Render() digunakan untuk menjadikan komponen ini dalam terminal. Kami juga menggunakan fungsi PollEvents() untuk mengendalikan input pengguna. Apabila pengguna memasukkan kekunci Enter, kami menggunakan p.Teks untuk mengemas kini maklumat segera dan tb.Teks untuk mendapatkan input pengguna.

2. gocui
   gocui ialah perpustakaan lain untuk mencipta GUI terminal. Ia menyediakan beberapa komponen GUI biasa, seperti tingkap, kotak input, butang, dll. Berikut ialah contoh mudah yang dilaksanakan menggunakan gocui:

package main

import (
    "github.com/jroimartin/gocui"
)

func main() {
    g, err := gocui.NewGui(gocui.OutputNormal)
    if err != nil {
        panic(err)
    }
    defer g.Close()

    g.SetManagerFunc(func(g *gocui.Gui) error {
        if v, err := g.SetView("prompt", 0, 0, 25, 3); err != nil {
            if err != gocui.ErrUnknownView {
                return err
            }
            v.Title = "Enter text"
            v.Editable = true
            v.Wrap = true
            if _, err := g.Cursor(true); err != nil {
                return err
            }
            if err := g.SetKeybinding("prompt", gocui.KeyEnter, gocui.ModNone, enterHandler); err != nil {
                return err
            }
            if err := v.SetCursor(0, 0); err != nil {
                return err
            }
        }
        return nil
    })

    if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
        panic(err)
    }
}

func enterHandler(g *gocui.Gui, v *gocui.View) error {
    if _, err := g.View("prompt"); err != nil {
        return err
    }
    text := v.Buffer()
    if err := g.DeleteView("prompt"); err != nil {
        return err
    }
    if _, err := g.SetCurrentView(""); err != nil {
        return err
    }
    g.Update(func(g *gocui.Gui) error {
        return g.Close()
    })
    println("You entered: ", text)
    return nil
}

Dalam contoh ini, kami menggunakan fungsi gocui.NewGui() gocui untuk mencipta objek GUI dan menggunakan fungsi g.SetManagerFunc( ) menetapkan Antara muka GUI ke kotak edit. Kami juga menggunakan fungsi g.SetKeybinding() untuk menetapkan kekunci pintasan dan melaksanakan fungsi enterHandler() untuk mengendalikan input pengguna.

Ringkasan:
Sangat mudah untuk menggunakan input dan output papan kekunci dalam Golang. Kita boleh menggunakan pakej fmt dan bufio dalam pustaka standard Golang untuk melengkapkan operasi input dan output asas. Jika kami memerlukan pengalaman pengguna yang lebih baik, kami juga boleh menggunakan perpustakaan pihak ketiga termui dan gocui untuk mencipta GUI terminal.

Atas ialah kandungan terperinci Cara menggunakan input dan output papan kekunci di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!