web-dev-qa-db-fra.com

fonction similaire à getchar

Existe-t-il une fonction Go similaire à getchar capable de gérer la pression de tabulation dans la console? Je veux faire une sorte de complétion dans mon application console.

consolegogetchar
34
demi

Exemple de getchar() de C:

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

Aller équivalent:

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 ('CHARACTER TABULATION').

Cependant, pour vos besoins (onglet de détection), la getchar() de C ne convient pas car elle nécessite que l'utilisateur appuie sur Entrée. Ce dont vous avez besoin est quelque chose comme getch ()/readline/jLine de ncurses comme mentionné par @miku. Avec ceux-ci, vous attendez réellement une seule touche.

Vous avez donc plusieurs options:

  1. Utilisez la liaison ncurses/readline, par exemple https://code.google.com/p/goncurses/ ou équivalent comme https: // github.com/nsf/termbox

  2. Lancez votre propre voir http://play.golang.org/p/plwBIIYiqG pour le point de départ

  3. utilisez os.Exec pour exécuter stty ou 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

20
rputikar

En supposant que vous souhaitez une entrée sans tampon (sans avoir à appuyer sur Entrée), 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)+")")
    }
}
14
blinry

Il y a quelques projets d'encapsuleurs autour de GNU readline, par exemple:

mais je ne sais pas comment ils sont fonctionnels. Une autre façon pourrait être l'émulation de terminal, voir:

5
miku

Merci à Paul Rademacher - cela fonctionne (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
}
4
Slava V

Essaye ça:

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 reprendre toute la fenêtre du terminal).

3
Paul Rademacher

D'autres réponses suggèrent ici des choses telles que:

  • Utiliser cgo

  • os.Exec de stty

    • pas portable
    • inefficace
    • sujette aux erreurs

  • en utilisant du code qui utilise /dev/tty

    • pas portable

  • en utilisant un GNU package readline

    • inefficace s'il s'agit d'un wrapper vers la ligne de lecture C ou s'il est mis en œuvre en utilisant l'une des techniques ci-dessus
    • sinon d'accord

Cependant, pour le cas simple, cela est facile en utilisant simplement un package des Go Project's Sub-repositories .

Fondamentalement, utilisez terminal.MakeRaw et terminal.Restore pour mettre l'entrée standard en mode brut (vérification des erreurs, par exemple si stdin n'est pas un terminal); alors vous pouvez soit lire les octets directement depuis os.Stdin, ou plus probablement, via un bufio.Reader (pour une meilleure efficacité).

Par exemple, quelque chose comme ceci:

package main

import (
    "bufio"
    "log"
    "os"

    "golang.org/x/crypto/ssh/terminal"
)

func main() {
    // fd 0 is stdin
    state, err := terminal.MakeRaw(0)
    if err != nil {
        log.Fatalln("setting stdin to raw:", err)
    }
    defer func() {
        if err := terminal.Restore(0, state); err != nil {
            log.Println("warning, failed to restore terminal:", err)
        }
    }()

    in := bufio.NewReader(os.Stdin)
    for {
        r, _, err := in.ReadRune()
        if err != nil {
            log.Println("stdin:", err)
            break
        }
        fmt.Printf("read rune %q\r\n", r)
        if r == 'q' {
            break
        }
    }
}
1
Dave C

1- Vous pouvez utiliser C.getch():

Cela fonctionne en ligne de commande Windows, lit un seul caractère sans entrée:
(Exécutez le fichier binaire de sortie à l'intérieur de Shell (terminal), pas à l'intérieur du tube 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 () sous Linux?
Pourquoi ne puis-je pas trouver <conio.h> sous Linux?

3- Cela fonctionne aussi, mais nécessite "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)
}
0
user6169399