Функция, аналогичная getchar

Есть ли функция Go, аналогичная C getchar, способная обрабатывать нажатие на клавиши в консоли? Я хочу сделать своего рода завершение в моем консольном приложении.

Ответ 1

C getchar() пример:

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

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

Последняя прокомментированная строка просто показывает, что при нажатии tab первым элементом является U + 0009 ( "ХАРАКТЕРИСТИКА" ).

Однако для ваших нужд (вкладка обнаружения) C getchar() не подходит, так как пользователю требуется нажать enter. Что вам нужно, это что-то вроде ncurses 'getch()/readline/jLine, как упоминалось в @miku. При этом вы на самом деле ожидаете одного нажатия клавиши.

Итак, у вас есть несколько вариантов:

Используйте привязку ncurses/readline, например https://code.google.com/p/goncurses/ или эквивалент, например https://github.com/nsf/termbox
Загрузите свой собственный файл http://play.golang.org/p/plwBIIYiqG для начальной точки
используйте os.Exec для запуска stty или 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

Ответ 2

Предполагая, что вам нужен небуферизованный ввод (без нажатия клавиши ввода), это выполняет работу в системах 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)+")")
    }
}

Ответ 3

Существует несколько проектов оберток вокруг строки чтения GNU, например:

но я не уверен, насколько они функциональны. Другим способом может быть эмуляция терминала, см.

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

Ответ 4

Благодарит Paul Rademacher - это работает (по крайней мере, на 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
}

Ответ 5

Попробуйте следующее:

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

Другие ответы здесь не работают, а go-termbox слишком тяжелый (он хочет захватить все окно терминала).

Ответ 6

Другие ответы здесь предлагают такие вещи как:

Использование cgo
- неэффективное
- "Я не иду"
os.Exec из stty
- не переносимый
- неэффективное
- подвержен ошибкам
используя код, который использует /dev/tty
- не переносимый
используя пакет readline GNU
- неэффективно, если он является оболочкой для C readline или если реализован с использованием одного из вышеуказанных методов
- в остальном все в порядке

Однако для простого случая это легко, просто используя пакет из вложенных репозиториев Go Project.

В основном используйте terminal.MakeRaw и terminal.Restore, чтобы установить стандартный ввод в необработанный режим (проверка на наличие ошибок, например, если stdin не является терминалом); затем вы можете либо прочитать байты непосредственно из os.Stdin, либо, что более вероятно, через bufio.Reader (для повышения эффективности).

Например, что-то вроде этого:

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

Ответ 7

1- Вы можете использовать C.getch():

Это работает в командной строке Windows, Читает только один символ без Enter:
(Запустите выходной двоичный файл внутри оболочки (терминал), а не внутри трубы или редактора.)

package main

//#include<conio.h>
import "C"

import "fmt"

func main() {
    c := C.getch()
    fmt.Println(c)
}

2- Для Linux (тестируется на 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()
}

См:
Что эквивалентно getch() и getche() в Linux?
Почему я не могу найти < conio.h > в Linux?

3- Также это работает, но требуется "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)
}

Ответ 8

Мое решение по этому вопросу, хотя это очень поздно для игры. Может быть, это поможет кому-то другому. Я использовал C-привязку, как это. Мне не нравятся терминологические хаки и предпочитают решение на основе чистого кода.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <termios.h>

static struct termios g_old_kbd_mode;

static int kbhit(void) {
    struct timeval timeout;
    fd_set read_handles;
    int status;

    FD_ZERO(&read_handles);
    FD_SET(0, &read_handles);
    timeout.tv_sec = timeout.tv_usec = 0;
    status = select(0 + 1, &read_handles, NULL, NULL, &timeout);
    return status;
}

int readkey( void ) {
    int ch;
    struct termios new_kbd_mode;

    tcgetattr(0, &g_old_kbd_mode);
    memcpy(&new_kbd_mode, &g_old_kbd_mode, sizeof(struct termios));

    new_kbd_mode.c_lflag &= ~(ICANON | ECHO);
    new_kbd_mode.c_cc[VTIME] = 0;
    new_kbd_mode.c_cc[VMIN]  = 1;

    tcsetattr(0, TCSANOW, &new_kbd_mode);

    while (!kbhit())
    {
        ch = getchar();
        tcsetattr(0, TCSANOW, &g_old_kbd_mode);
        return ch;
    }

    tcsetattr(0, TCSANOW, &g_old_kbd_mode);
    return ch;
}

Тогда в Go используйте его как

package keyboard

/*
#include "cgetkey.h"
*/
import "C"

const HOME   = 149 // DOS Keycode #0 + #71
const END    = 152 // DOS Keycode #0 + #79
const PG_UP  = 153 // DOS Keycode #0 + #73
const PG_DN  = 154 // DOS Keycode #0 + #81
const KEY_UP = 165 // DOS Keycode #0 + #72
const KEY_DN = 166 // DOS Keycode #0 + #80
const KEY_RT = 167 // DOS Keycode #0 + #77
const KEY_LF = 168 // DOS Keycode #0 + #75


/**
 *
 *  ReadKey
 *
 *  Reads a single keystroke and returns it ASCII value.
 *  If a special key is pressed such as an arrow-key, it will process
 *  the ^] + ] return codes and return the ASCII value + 100.
 *
 *  @return Integer
 *
 */
func ReadKey() int {
    var ch int

    ch = int(C.readkey())
    if ch == 27 { // ESC
        if int(C.readkey()) == 91 { // [ bracket
            ch = int(C.readkey()) + 100 // Add 100 to ASCII value.
        }
    }

    return ch
}


/**
 *
 *  RawKey
 *
 *  Reads a single keystroke and returns it ASCII value.
 *  Does nothing with special keys being pressed.
 *  You will have to read each character code and process them
 *  yourself.
 *
 *  @return Integer
 *
 */
func RawKey() int {
    return int(C.readkey())
}

Я создал эту библиотеку здесь. https://github.com/tlorens/go-ibgetkey

Ответ 9

Вы также можете использовать ReadRune:

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

Руна похожа на символ, поскольку у GoLang действительно нет символов, чтобы попытаться поддерживать несколько языков /unicode и т.д.