multiple - jquery tags input autocomplete

Cómo leer la entrada del usuario en Rust?

Question

Nota del editor: esta pregunta se refiere a partes de Rust que son anteriores a Rust 1.0, pero el concepto general sigue siendo válido en Rust 1.0.

Tengo la intención de hacer un tokenizer. Necesito leer cada línea que escribe el usuario y dejar de leer una vez que el usuario presiona ctrl - D.

Busqué alrededor y solo encontré un ejemplo en Rust IO que ni siquiera compila. Miré la documentación del módulo io y encontré que la función read_line() es parte de la interfaz ReaderUtil , pero stdin() devuelve un Reader .

El código que me gustaría sería esencialmente el siguiente en C ++

vector<string> readLines () {
vector<string> allLines;
string line;
while (cin >> line) {
allLines.push_back(line);
}
return allLines;
}

Answer 1

Nota del editor: esta respuesta es anterior a Rust 1.0. Por favor vea las otras respuestas para soluciones modernas.

En Rust 0.4, use el rasgo de ReaderUtil para acceder a la función read_line . Tenga en cuenta que debe convertir explícitamente el valor en un tipo de rasgo, por ejemplo, el reader as io::ReaderUtil

fn main() {
let mut allLines = ~[];
let reader = io::stdin();
while !reader.eof() {
allLines.push((reader as io::ReaderUtil).read_line());
}
for allLines.each |line| {
io::println(fmt!("%s", *line));
}
}

Answer 2

Nota del editor: esta respuesta es anterior a Rust 1.0. Por favor vea las otras respuestas para soluciones modernas.

Uh ... Después de muchas pruebas y errores, encontré una solución.

Todavía me gustaría ver una solución mejor, así que no voy a aceptar mi propia solución.

El siguiente código imprime exactamente lo que el usuario ingresa.

mod tokenizer {
pub fn read () -> ~[int] {
let reader = io::stdin();
let mut bytes: ~[int] = ~[];
loop {
let byte: int = reader.read_byte();
if byte < 0 {
return bytes;
}
bytes += [byte];
}
}
}
fn main () {
let bytes: ~[int] = tokenizer::read();
for bytes.each |byte| {
io::print(#fmt("%c", *byte as char));
}
}

Answer 3

A partir del 17 de abril de 2015 de mdcox en mozilla rust irc.

use std::io;
fn main() {
let mut stdin = io::stdin();
let input = &mut String::new();
loop {
input.clear();
stdin.read_line(input);
println!("{}", input);
}
}

Answer 4

En Rust 1.0 y posterior, puede usar el método de lines en cualquier elemento que implemente el rasgo std::io::BufRead para obtener un iterador sobre líneas en la entrada. También podría usar read_line , pero es más probable que usar el iterador sea lo que quiera. Aquí hay una versión de la función en la pregunta usando iteradores; vea abajo para una explicación más detallada. ( enlace de juegos )

use std::io;
use std::io::prelude::*;
pub fn read_lines() -> Vec<String> {
let stdin = io::stdin();
let stdin_lock = stdin.lock();
let vec = stdin_lock.lines().filter_map(|l| l.ok()).collect();
vec
}

Y aquí hay una versión que se parece más a la versión en C ++ de la pregunta, pero no es realmente la manera idiomática de hacer esto en Rust ( playground ):

use std::io;
use std::io::prelude::*;
pub fn read_lines() -> Vec<String> {
let mut vec = Vec::new();
let mut string = String::new();
let stdin = io::stdin();
let mut stdin_lock = stdin.lock();
while let Ok(len) = stdin_lock.read_line(&mut string) {
if len > 0 {
vec.push(string);
string = String::new();
} else {
break
}
}
vec
}

Para obtener algo que implemente BufRead , que se necesita para llamar a lines() o read_line() , llame a std::io::stdin() para obtener un identificador para la entrada estándar, y luego llame a lock() sobre el resultado de eso para obtener el control exclusivo del flujo de entrada estándar (debe tener control exclusivo para obtener un BufRead , porque de lo contrario el almacenamiento en búfer podría producir resultados arbitrarios si dos hilos estuvieran leyendo de stdin a la vez).

Para recopilar el resultado en un Vec<String> , puede usar el método de collect en un iterador. lines() devuelve un iterador sobre Result<String> , por lo que debemos gestionar casos de error en los que no se pudo leer una línea; para este ejemplo, simplemente ignoramos los errores con un filter_map que simplemente omite cualquier error.

La versión similar a C ++ utiliza read_line , que agrega la línea de lectura a una cadena dada, y luego empujamos la cadena en nuestro Vec . Debido a que transferimos la propiedad de la cadena al Vec cuando lo hacemos, y debido a que read_line continuaría añadiendo a la string , tenemos que asignar una nueva cadena para cada ciclo (esto parece ser un error en la versión original de C ++ en el pregunta, en la que se comparte la misma cadena y así seguirá acumulando cada línea). Usamos while let continuar leyendo hasta que alcanzamos un error, y nos rompemos si leemos cero bytes que indica el final de la entrada.

Answer 5

Esto es lo que se me ocurrió (con la ayuda de gente amable del canal de IRC #rust en irc.mozilla.org):

use core::io::ReaderUtil;
fn read_lines() -> ~[~str] {
let mut all_lines = ~[];
for io::stdin().each_line |line| {
// each_line provides us with borrowed pointers, but we want to put
// them in our vector, so we need to *own* the lines
all_lines.push(line.to_owned());
}
all_lines
}
fn main() {
let all_lines = read_lines();
for all_lines.eachi |i, &line| {
io::println(fmt!("Line #%u: %s", i + 1, line));
}
}

Y prueba de que funciona :)

$ rustc readlines.rs
$ echo -en ''this/nis/na/ntest'' | ./readlines
Line #1: this
Line #2: is
Line #3: a
Line #4: test

Answer 6

Hay pocas maneras en que puedo pensar.

Lee toda la entrada en una sola String

let mut input = String::new();
io::stdin().read_to_end(&mut input);

Leer líneas en Vector . Éste no entra en panic cuando lee una línea falla, sino que omite esa línea fallida.

let stdin = io::stdin();
let locked = stdin.lock();
let v: Vec<String> = locked.lines().filter_map(|line| line.ok()).collect();

Además, si quieres analizarlo:

Después de leerlo en una cuerda haz esto. Puede analizarlo en otras colecciones que implementa FromIterator . Los elementos contenidos en la colección también deben implementar FromStr . Siempre que la restricción de rasgo satisfaga, puede cambiar Vec a cualquier Collection:FromIterator , Collection<T: FromStr>

let v: Vec<i32> = "4 -42 232".split_whitespace().filter_map(|w| w.parse().ok()).collect();

También puedes usarlo en StdinLock

let vv: Vec<Vec<i32>> = locked
.lines()
.filter_map(|l|
l.ok().map(|s|
s.split_whitespace().filter_map(|word| word.parse().ok()).collect()
)
)
.collect();

Answer 7

La pregunta es leer líneas de stdin y devolver un vector. En Rust 1.7:

fn readlines() -> Vec<String> {
use std::io::prelude::*;
let stdin = std::io::stdin();
let v = stdin.lock().lines().map(|x| x.unwrap()).collect();
v
}

Answer 8

Rust 1.x (ver documentation ):

use std::io;
use std::io::prelude::*;
fn main() {
let stdin = io::stdin();
for line in stdin.lock().lines() {
println!("{}", line.unwrap());
}
}

Rust 0.10-0.12 (ver documentation ):

use std::io;
fn main() {
for line in io::stdin().lines() {
print!("{}", line.unwrap());
}
}

Rust 0.9 (ver documentación 0.9 ):

use std::io;
use std::io::buffered::BufferedReader;
fn main() {
let mut reader = BufferedReader::new(io::stdin());
for line in reader.lines() {
print(line);
}
}

Rust 0.8:

use std::io;
fn main() {
let lines = io::stdin().read_lines();
for line in lines.iter() {
println(*line);
}
}

Rust 0.7:

use std::io;
fn main() {
let lines = io::stdin().read_lines();
for lines.iter().advance |line| {
println(*line);
}
}