So verwenden Sie die Tastatureingabe und -ausgabe in Golang

Golang ist eine effiziente und moderne Sprache, die bei der Entwicklung von Anwendungen sehr praktisch und praktisch ist. In diesem Artikel wird die Verwendung der Tastatureingabe und -ausgabe in Golang vorgestellt.

1. Verwenden Sie das fmt-Paket zur Ausgabe von
Das fmt-Paket ist ein sehr häufig verwendetes Paket in der Golang-Standardbibliothek und bietet viele nützliche Funktionen. Dazu gehört auch die Ausgabe von Inhalten auf der Konsole. Die Verwendung des fmt-Pakets zur Ausgabe ist sehr einfach. Rufen Sie einfach die Funktion fmt.Println() auf:

package main

import "fmt"

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

Führen Sie diesen Code aus. Wir können die Ausgabe „Hello, world!“ auf der Konsole sehen.

2. Verwenden Sie das Bufio-Paket für die Eingabe.
Neben der Ausgabe ist auch die Eingabe eine Funktion, die wir häufig verwenden müssen. Golang stellt das Bufio-Paket zur Verfügung, mit dem Benutzereingaben bequem gelesen werden können. Das Folgende ist ein einfaches Beispiel für das Lesen von Benutzereingaben und -ausgaben:

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

In diesem Code haben wir zuerst das Bufio-Paket und das OS-Paket importiert und in der Hauptfunktion eine Reader-Variable zum Lesen von Benutzereingaben erstellt. Rufen Sie die Funktion fmt.Print() auf, um Eingabeaufforderungsinformationen auszugeben, warten Sie auf Benutzereingaben und verwenden Sie dann die Funktion reader.ReadString(), um die Benutzereingaben zu lesen. Verwenden Sie abschließend die Funktion fmt.Println(), um auszugeben, was der Benutzer eingegeben hat.

3. Verwenden Sie Bibliotheken von Drittanbietern, um ein besseres Eingabe-/Ausgabeerlebnis zu bieten.

Obwohl die obige Methode praktisch ist, implementiert sie nur die grundlegendsten Eingabe- und Ausgabefunktionen. Wenn wir eine bessere Benutzererfahrung benötigen, können wir die Verwendung von Bibliotheken von Drittanbietern in Betracht ziehen. Die folgenden zwei Bibliotheken sind empfehlenswert:

1. termui
   termui ist eine terminalbasierte Benutzeroberflächenbibliothek, die viele nützliche UI-Komponenten für unsere Golang-Anwendungen bereitstellt. Das Programm sieht professioneller aus. Das Folgende ist ein einfaches Beispiel, das mit termui implementiert wurde:

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

In diesem Beispiel verwenden wir die Funktionen widgets.NewParagraph() und widgets.NewTextEdit() von termui, um einen Absatz und ein Textbearbeitungsfeld zu erstellen . Mit der Funktion Render() werden diese Komponenten im Terminal gerendert. Wir haben auch die Funktion PollEvents() verwendet, um Benutzereingaben zu verarbeiten. Wenn der Benutzer die Eingabetaste eingibt, verwenden wir p.Text, um die Eingabeaufforderungsinformationen zu aktualisieren, und tb.Text, um die Benutzereingaben zu erhalten.

2. gocui
   gocui ist eine weitere Bibliothek zum Erstellen von Terminal-GUIs. Es stellt einige gängige GUI-Komponenten wie Fenster, Eingabefelder, Schaltflächen usw. bereit. Das Folgende ist ein einfaches Beispiel, das mit gocui implementiert wurde:

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
}

In diesem Beispiel verwenden wir die Funktion gocui.NewGui() von gocui, um ein GUI-Objekt zu erstellen und g.SetManagerFunc()-Funktionssätze zu verwenden die GUI-Schnittstelle zu einem Bearbeitungsfeld. Wir haben auch die Funktion g.SetKeybinding() verwendet, um die Tastenkombinationen festzulegen, und die Funktion enterHandler() implementiert, um Benutzereingaben zu verarbeiten.

Zusammenfassung:
Die Verwendung der Tastatureingabe und -ausgabe in Golang ist sehr praktisch. Wir können die Pakete fmt und bufio in der Golang-Standardbibliothek verwenden, um grundlegende Eingabe- und Ausgabevorgänge durchzuführen. Wenn wir eine bessere Benutzererfahrung benötigen, können wir auch die Drittanbieterbibliotheken termui und gocui verwenden, um eine Terminal-GUI zu erstellen.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Tastatureingabe und -ausgabe in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!