Wie kann ich Lesen Sie ein Zeichen aus stdin, ohne die enter-Taste drücken?

Möchte ich laufen eine ausführbare Datei, die Blöcke auf stdin und wenn eine Taste gedrückt wird, dass gleiche Zeichen wird sofort gedruckt, ohne Enter gedrückt werden.

Wie kann ich Lesen Sie ein Zeichen aus stdin zimmerreserviereung, ohne das Sie drücken Sie Enter? Angefangen habe ich mit diesem Beispiel:

fn main() {
    println!("Type something!");

    let mut line = String::new();
    let input = std::io::stdin().read_line(&mut line).expect("Failed to read line");

    println!("{}", input);
}

Ich sah durch die API und versucht, anstelle read_line() mit bytes(), aber alles, was ich versuchen muss ich drücken Sie Enter vor dem Lesen Auftritt.

Diese Frage wurde für C/C++, aber es scheint keinen standard-Weg, es zu tun: Erfassen Zeichen von standard-input, ohne zu warten, für Sie die EINGABETASTE gedrückt werden

Könnte es nicht machbar sein in Rust, da es nicht einfach ist in C/C++.

Dies ist ein Plattform-Problem, nicht eine Sprache. Auf windows gibt es Zeichen-Eingabe-Funktionen, aber auf unix - /linux-nehmen Sie das terminal aus der Linie buffered-Modus.
Sie können die getch Funktion aus dem oben genannten link. Sie müssen nur zu kompilieren, die in einem gemeinsamen Objekt, und verwenden Sie es vom Rost: gist.github.com/ihrwein/a4558d63d9250ee0bbf6 Sie benötigen einen C-compiler und es funktioniert nur auf Linux (zumindest habe ich es getestet).

InformationsquelleAutor bantl23 | 2014-10-12

rust

11

Verwenden Sie eine der " ncurses-Bibliotheken sind nun verfügbar, zum Beispiel diese.

Fügen Sie die Abhängigkeit im Cargo
```
[dependencies]
ncurses = "5.86.0"
```
und in main.rs:
```
extern crate ncurses;
use ncurses::*; //watch for globs
```
Folgen Sie den Beispielen in der Bibliothek ncurses initialisieren und warten, für ein einzelnes Zeichen, Eingabe wie diese:
```
initscr();
/* Print to the back buffer. */
printw("Hello, world!");

/* Update the screen. */
refresh();

/* Wait for a key press. */
getch();

/* Terminate ncurses. */
endwin();
```
Das funktioniert, aber es scheint unmöglich zu vermeiden, löschen des Bildschirms, die erzwungen wird durch initscr() wie besprochen here und die there.

InformationsquelleAutor Jon Anderson

Während @Jon ' s Lösung, die mit ncurses arbeiten, ncurses löscht den Bildschirm und design. Ich kam mit dieser Lösung, verwendet die termios Kiste für mein kleines Projekt, um zu erfahren Rost. Die Idee ist, ändern ECHO und ICANON Fahnen durch den Zugriff auf tcsetattr durch termios-Bindungen.

extern crate termios;
use std::io;
use std::io::Read;
use std::io::Write;
use termios::{Termios, TCSANOW, ECHO, ICANON, tcsetattr};

fn main() {
    let stdin = 0; //couldn't get std::os::unix::io::FromRawFd to work 
                   //on /dev/stdin or /dev/tty
    let termios = Termios::from_fd(stdin).unwrap();
    let mut new_termios = termios.clone();  //make a mutable copy of termios 
                                            //that we will modify
    new_termios.c_lflag &= !(ICANON | ECHO); //no echo and canonical mode
    tcsetattr(stdin, TCSANOW, &mut new_termios).unwrap();
    let stdout = io::stdout();
    let mut reader = io::stdin();
    let mut buffer = [0;1];  //read exactly one byte
    print!("Hit a key! ");
    stdout.lock().flush().unwrap();
    reader.read_exact(&mut buffer).unwrap();
    println!("You have hit: {:?}", buffer);
    tcsetattr(stdin, TCSANOW, & termios).unwrap();  //reset the stdin to 
                                                    //original termios data
}

Einen Vorteil Lesen eines einzelnen byte ist die Erfassung Pfeiltasten, Strg usw. Erweiterte F-Tasten sind nicht erfasst (obwohl ncurses kann diese aufzunehmen).

Diese Lösung soll für UNIX-ähnliche Plattformen. Ich habe keine Erfahrung mit Windows, aber nach dieser forum vielleicht etwas ähnliches erreicht werden kann, mit SetConsoleMode im Windows.

Sie können libc::STDIN_FILENO definiert in der libc Kiste statt der Festlegung stdin selbst.

InformationsquelleAutor dojuba

Können Sie auch termion, aber Sie aktivieren müssen, die raw TTY-Modus, welche änderungen das Verhalten der stdout als gut. Siehe das Beispiel unten (getestet mit Rost 1.34.0). Beachten Sie, dass intern auch wraps die termios UNIX-API.

Cargo.toml

[dependencies]
termion = "1.5.2"

main.rs

use std::io;
use std::io::Write;
use std::thread;
use std::time;

use termion;
use termion::input::TermRead;
use termion::raw::IntoRawMode;

fn main() {
    //Set terminal to raw mode to allow reading stdin one key at a time
    let mut stdout = io::stdout().into_raw_mode().unwrap();

    //Use asynchronous stdin
    let mut stdin = termion::async_stdin().keys();

    loop {
        //Read input (if any)
        let input = stdin.next();

        //If a key was pressed
        if let Some(Ok(key)) = input {
            match key {
                //Exit if 'q' is pressed
                termion::event::Key::Char('q') => break,
                //Else print the pressed key
                _ => {
                    write!(
                        stdout,
                        "{}{}Key pressed: {:?}",
                        termion::clear::All,
                        termion::cursor::Goto(1, 1),
                        key
                    )
                    .unwrap();

                    stdout.lock().flush().unwrap();
                }
            }
        }
        thread::sleep(time::Duration::from_millis(50));
    }
}

InformationsquelleAutor BenC

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.