Comment utiliser l'entrée et la sortie du clavier dans Golang

Golang est un langage efficace et moderne, très pratique et pratique lors du développement d'applications. Cet article explique comment utiliser la saisie et la sortie du clavier dans Golang.

1. Utilisez le package fmt pour générer
Le package fmt est un package très couramment utilisé dans la bibliothèque standard Golang et fournit de nombreuses fonctions utiles. Cela inclut la sortie du contenu vers la console. Utiliser le package fmt pour afficher est très simple, il suffit d'appeler la fonction fmt.Println() :

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

Exécutez ce code, nous pouvons voir la sortie "Bonjour tout le monde sur la console !"

2. Utilisez le package bufio pour l'entrée
En plus de la sortie, l'entrée est également une fonction que nous devons souvent utiliser. Golang fournit le package bufio, qui peut facilement lire les entrées de l'utilisateur. Ce qui suit est un exemple simple de lecture des entrées utilisateur et de leur sortie :

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

Dans ce code, nous avons d'abord importé le package bufio et le package os, et créé une variable de lecteur dans la fonction principale pour lire les entrées utilisateur. Appelez la fonction fmt.Print() pour afficher les informations d'invite, attendez l'entrée de l'utilisateur, puis utilisez la fonction reader.ReadString() pour lire l'entrée de l'utilisateur. Enfin, utilisez la fonction fmt.Println() pour afficher ce que l'utilisateur a saisi.

3. Utilisez des bibliothèques tierces pour offrir une meilleure expérience d'entrée/sortie

Bien que la méthode ci-dessus soit pratique, elle n'implémente que les fonctions d'entrée et de sortie les plus élémentaires. Si une meilleure expérience utilisateur est nécessaire, nous pouvons envisager d'utiliser des bibliothèques tierces. Voici deux bibliothèques qui valent la peine d'être recommandées :

1. termui
   termui est une bibliothèque d'interface utilisateur basée sur un terminal qui fournit de nombreux composants d'interface utilisateur utiles pour donner à nos applications Golang un aspect plus professionnel. Voici un exemple simple implémenté à l'aide de 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 == "" { p.Text = "You entered " + tb.Text tb.SetText("") } termui.Render(p, tb) } } }

Dans cet exemple, nous utilisons les fonctions widgets.NewParagraph() et widgets.NewTextEdit() de termui pour créer un paragraphe et une zone d'édition de texte. La fonction Render() est utilisée pour restituer ces composants dans le terminal. Nous avons également utilisé la fonction PollEvents() pour gérer les entrées des utilisateurs. Lorsque l'utilisateur saisit la touche Entrée, nous utilisons p.Text pour mettre à jour les informations d'invite et tb.Text pour obtenir la saisie de l'utilisateur.

2. gocui
   gocui est une autre bibliothèque permettant de créer des interfaces graphiques de terminal. Il fournit certains composants GUI courants, tels que des fenêtres, des zones de saisie, des boutons, etc. Ce qui suit est un exemple simple implémenté à l'aide de 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 }

Dans cet exemple, nous utilisons la fonction gocui.NewGui() de gocui pour créer un objet GUI et utilisons la fonction g.SetManagerFunc() pour définir l'interface GUI sur Edit. boîte. Nous avons également utilisé la fonction g.SetKeybinding() pour définir les touches de raccourci et implémenté la fonction enterHandler() pour gérer les entrées de l'utilisateur.

Résumé :
Il est très pratique d'utiliser la saisie et la sortie du clavier dans Golang. Nous pouvons utiliser les packages fmt et bufio de la bibliothèque standard Golang pour effectuer les opérations d'entrée et de sortie de base. Si nous avons besoin d'une meilleure expérience utilisateur, nous pouvons également utiliser les bibliothèques tierces termui et gocui pour créer une interface graphique de terminal.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!