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

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

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

package main
import (
	"bufio"
	"fmt"
	"log"
	"os"
	"golang.org/x/term"
)
func main() {
	// fd 0 is stdin
	state, err := term.MakeRaw(0)
	if err != nil {
		log.Fatalln("setting stdin to raw:", err)
	}
	defer func() {
		if err := term.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
		}
	}
}

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
}

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

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

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

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