Fonction de Golang similaire à getchar
y a-t-il une fonction similaire à getchar
capable de gérer la pression tab dans la console? Je veux faire une sorte d'achèvement dans ma console application.
7 réponses
C getchar()
exemple:
#include <stdio.h>
void main()
{
char ch;
ch = getchar();
printf("Input Char Is :%c",ch);
}
équivalent Go:
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
reader := bufio.NewReader(os.Stdin)
input, _ := reader.ReadString('\n')
fmt.Printf("Input Char Is : %v", string([]byte(input)[0]))
// fmt.Printf("You entered: %v", []byte(input))
}
la dernière ligne commentée montre simplement que lorsque vous appuyez sur tab
le premier élément est U+0009 ('table des caractères').
Cependant pour vos besoins (onglet de détection) C getchar()
n'est pas adapté car il exige de l'utilisateur de frapper enter. Ce dont vous avez besoin, c'est quelque chose comme getch()/ readline/ jLine de ncurses comme mentionné par @miku. Avec ces, vous fait attendre pour une seule frappe.
donc vous avez plusieurs options:
-
Utiliser
ncurses
/readline
de liaison, par exemple https://code.google.com/p/goncurses/ ou l'équivalent comme https://github.com/nsf/termbox -
Roll your own see http://play.golang.org/p/plwBIIYiqG pour le point de départ
-
utilisez
os.Exec
pour exécuter stty ou jLine.
réfs:
https://groups.google.com/forum/?fromgroups=#!thème / golang-nuts / zhBE5MH4n-Q
https://groups.google.com/forum/?fromgroups=#!thème / golang-nuts/S9AO_kHktiY
https://groups.google.com/forum/?fromgroups=#!thème / golang-nuts/icMfYF8wJCk
en supposant que vous voulez une entrée libre (sans avoir à frapper enter), Cela fait le travail sur les systèmes UNIX:
package main
import (
"fmt"
"os"
"os/exec"
)
func main() {
// disable input buffering
exec.Command("stty", "-F", "/dev/tty", "cbreak", "min", "1").Run()
// do not display entered characters on the screen
exec.Command("stty", "-F", "/dev/tty", "-echo").Run()
// restore the echoing state when exiting
defer exec.Command("stty", "-F", "/dev/tty", "echo").Run()
var b []byte = make([]byte, 1)
for {
os.Stdin.Read(b)
fmt.Println("I got the byte", b, "("+string(b)+")")
}
}
il y a quelques projets wrappers autour de GNU readline, par exemple:
- https://bitbucket.org/binet/go-readline/src
- https://github.com/igoralmeida/readline-go/blob/master/readline.go
mais je ne sais pas si elles sont fonctionnelles. Une autre façon pourrait être l'émulation terminale, voir:
merci à Paul Rademacher-cette œuvre (au moins sur Mac):
package main
import (
"bytes"
"fmt"
"github.com/pkg/term"
)
func getch() []byte {
t, _ := term.Open("/dev/tty")
term.RawMode(t)
bytes := make([]byte, 3)
numRead, err := t.Read(bytes)
t.Restore()
t.Close()
if err != nil {
return nil
}
return bytes[0:numRead]
}
func main() {
for {
c := getch()
switch {
case bytes.Equal(c, []byte{3}):
return
case bytes.Equal(c, []byte{27, 91, 68}): // left
fmt.Println("LEFT pressed")
default:
fmt.Println("Unknown pressed", c)
}
}
return
}
Essayez ce qui suit:
https://github.com/paulrademacher/climenu/blob/master/getchar.go
les autres réponses ici n'ont pas fonctionné, et go-termbox est trop lourd (il veut prendre en charge l'ensemble de la fenêtre du terminal).
1-Vous pouvez utiliser C.getch()
:
cela fonctionne dans Windows ligne de commande, lit un seul caractère sans entrer:
(Exécutez le fichier binaire de sortie à l'intérieur du shell (terminal), pas à l'intérieur du tuyau ou de L'éditeur.)
package main
//#include<conio.h>
import "C"
import "fmt"
func main() {
c := C.getch()
fmt.Println(c)
}
2 - Pour Linux (testé sur Ubuntu):
package main
/*
#include <stdio.h>
#include <unistd.h>
#include <termios.h>
char getch(){
char ch = 0;
struct termios old = {0};
fflush(stdout);
if( tcgetattr(0, &old) < 0 ) perror("tcsetattr()");
old.c_lflag &= ~ICANON;
old.c_lflag &= ~ECHO;
old.c_cc[VMIN] = 1;
old.c_cc[VTIME] = 0;
if( tcsetattr(0, TCSANOW, &old) < 0 ) perror("tcsetattr ICANON");
if( read(0, &ch,1) < 0 ) perror("read()");
old.c_lflag |= ICANON;
old.c_lflag |= ECHO;
if(tcsetattr(0, TCSADRAIN, &old) < 0) perror("tcsetattr ~ICANON");
return ch;
}
*/
import "C"
import "fmt"
func main() {
fmt.Println(C.getch())
fmt.Println()
}
voir:
Qu'est-ce qui est équivalent à getch() & getche() dans Linux?
Pourquoi Je ne trouve pas < conio.h > sur Linux?
3- cela fonctionne aussi, mais nécessite "entrer":
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
r := bufio.NewReader(os.Stdin)
c, err := r.ReadByte()
if err != nil {
panic(err)
}
fmt.Println(c)
}
vous pouvez également utiliser ReadRune:
reader := bufio.NewReader(os.Stdin)
// ...
char, _, err := reader.ReadRune()
if err != nil {
fmt.Println("Error reading key...", err)
}
une rune est similaire à un caractère, car GoLang n'a pas vraiment de caractères, afin d'essayer de supporter plusieurs langues/unicode/etc.