console - alt_ - gets c++

Función Golang similar a getchar

Question

¿Hay una función similar a getchar capaz de manejar la pestaña presionar en la consola? Quiero hacer algún tipo de finalización en mi aplicación de consola.

Answer 1

1- Puedes usar C.getch() :

Esto funciona en la línea de comandos de Windows, lee solo un carácter sin Entrar:
(Ejecute el archivo binario de salida dentro de shell (terminal), no dentro de pipe o Editor).

package main
//#include<conio.h>
import "C"
import "fmt"
func main() {
c := C.getch()
fmt.Println(c)
}

2- Para Linux (probado en 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()
}

Ver:
¿Qué es Equivalente a getch () & getche () en Linux?
¿Por qué no puedo encontrar <conio.h> en Linux?

3- También esto funciona, pero necesita "Enter":

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

Answer 2

Gracias a Paul Rademacher: esto funciona (al menos en 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
}

Answer 3

Hay algunos proyectos de envoltorios alrededor de la línea de lectura de GNU, por ejemplo:

• https://bitbucket.org/binet/go-readline/src
• https://github.com/igoralmeida/readline-go/blob/master/readline.go

pero no estoy seguro de cuán funcionales son. Otra forma podría ser la emulación de terminal, ver:

• https://github.com/kylelemons/goat/

Answer 4

Prueba esto:

https://github.com/paulrademacher/climenu/blob/master/getchar.go

Las otras respuestas aquí no funcionaron, y go-termbox es demasiado pesado (quiere hacerse cargo de toda la ventana de la terminal).

Answer 5

Suponiendo que quiere entrada sin búfer (sin tener que presionar enter), esto hace el trabajo en los sistemas 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)+")")
}
}

Answer 6

También puedes usar ReadRune:

reader := bufio.NewReader(os.Stdin)
// ...
char, _, err := reader.ReadRune()
if err != nil {
fmt.Println("Error reading key...", err)
}

Una runa es similar a un personaje, ya que GoLang no tiene realmente caracteres, para tratar de admitir múltiples idiomas / unicode / etc.

Answer 7

getchar() de getchar() C:

#include <stdio.h>
void main()
{
char ch;
ch = getchar();
printf("Input Char Is :%c",ch);
}

Ir equivalente:

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 última línea comentada solo muestra que al presionar tab el primer elemento es U + 0009 (''TABULACIÓN DE CARACTERES'').

Sin embargo, para sus necesidades (pestaña de detección) el getchar() ) de C no es adecuado, ya que requiere que el usuario getchar() enter. Lo que necesitas es algo como el getch () / readline / jLine de ncurses como lo menciona @miku. Con esto, realmente esperas una sola pulsación de tecla.

Entonces tienes múltiples opciones:

1. Utilice el enlace ncurses / readline , por ejemplo https://code.google.com/p/goncurses/ o equivalente https://github.com/nsf/termbox

2. Haga rodar su propio http://play.golang.org/p/plwBIIYiqG vea http://play.golang.org/p/plwBIIYiqG como punto de partida

3. use os.Exec para ejecutar stty o jLine.

refs:

https://groups.google.com/forum/?fromgroups=#!topic/golang-nuts/zhBE5MH4n-Q

https://groups.google.com/forum/?fromgroups=#!topic/golang-nuts/S9AO_kHktiY

https://groups.google.com/forum/?fromgroups=#!topic/golang-nuts/icMfYF8wJCk