Handling input values in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

How do you read a line of input from the user in Rust?

You use the std::io::stdin().read_line(&mut input) method, where input is a mutable String variable to store the input.

beginner

What must you do to convert a string input to a number in Rust?

You use the trim() method to remove whitespace, then parse() to convert the string to a number type, handling possible errors.

beginner

Why do you need to declare the input variable as mutable when reading input in Rust?

Because read_line appends the input to the string, so the variable must be mutable to allow changes.

intermediate

What does the expect method do when handling input in Rust?

It stops the program and shows an error message if reading input or parsing fails, helping to catch errors early.

beginner

What is the purpose of using trim() on input strings?

It removes extra spaces and newline characters from the input, which helps avoid errors when converting the input to other types.

Which Rust method reads user input from the keyboard?

A input.parse()

B println!("Enter input")

C String::new()

D std::io::stdin().read_line(&mut input)

The read_line method reads a line of input from the user and stores it in a mutable string.

What does the trim() method do to a string in Rust?

A Parses string to a number

B Converts string to uppercase

C Removes whitespace and newline characters from both ends

D Makes string mutable

trim() removes spaces and newlines from the start and end of a string.

Why do you need to use mut when declaring the input variable for reading input?

A Because input must be constant

B Because the input string will be changed by read_line

C Because parse requires mutability

D Because trim needs mutable strings

The read_line method modifies the string by adding the input, so it must be mutable.

What happens if parse() fails to convert input to a number?

A It returns an error that you can handle

B It automatically converts to zero

C It crashes the program silently

D It ignores the input

parse() returns a Result type that can be an error if conversion fails.

What is the role of expect() when reading input?

A It shows an error message and stops if reading input fails

B It trims the input string

C It converts input to a number

D It makes the input variable mutable

expect() helps catch errors by stopping the program with a message if something goes wrong.

Explain step-by-step how to read a number input from the user in Rust and convert it to an integer.

Think about reading input as text first, then changing it to a number.

Why is it important to use trim() before parsing input in Rust?

Imagine the user presses Enter, what extra characters might be included?

Practice

1. What does the Rust function io::stdin().read_line(&mut input) do in a program?

easy

A. It clears the input buffer.

B. It writes a line of text to the screen.

C. It reads a line of text from the user and stores it in the variable input.

D. It converts a string to a number.

Solution

1. Step 1: Understand the function purpose

   io::stdin().read_line(&mut input) reads user input from the keyboard as a string.

2. Step 2: Recognize the role of input

   The input is stored in the mutable variable input passed by reference.

3. Final Answer:

   It reads a line of text from the user and stores it in the variable input. -> Option C

4. Quick Check:

   read_line reads user input [OK]

Hint: read_line reads user input into a variable [OK]

Common Mistakes:

• Thinking read_line writes output
• Confusing input reading with clearing buffer
• Assuming it converts types automatically

2. Which of the following Rust code snippets correctly reads a line of input and trims whitespace?

easy

A. let input = io::stdin().read_line().trim();

B. let mut input = String::new(); io::stdin().read_line(&mut input).expect("Failed"); let input = input.trim();

C. io::stdin().read_line(input); let input = input.trim();

D. let mut input = String::new(); io::stdin().read_line(input); input.trim();

Solution

1. Step 1: Check correct usage of read_line

   It requires a mutable String reference: read_line(&mut input).

2. Step 2: Confirm trimming is done on the input string

   Calling input.trim() removes whitespace correctly.

3. Final Answer:

   let mut input = String::new(); io::stdin().read_line(&mut input).expect("Failed"); let input = input.trim(); -> Option B

4. Quick Check:

   read_line needs &mut String and trim() cleans input [OK]

Hint: Use &mut String and call trim() after read_line [OK]

Common Mistakes:

• Forgetting &mut before input
• Calling trim() on read_line() result
• Not creating a mutable String first

3. What will be the output of this Rust code if the user inputs 42?

use std::io;
fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed");
    let num: i32 = input.trim().parse().expect("Not a number");
    println!("Number plus 10 is {}", num + 10);
}

medium

A. Number plus 10 is 52

B. Number plus 10 is 42

C. Not a number

D. Failed

Solution

1. Step 1: Read and parse input

   The input string "42" is trimmed and parsed to integer 42 successfully.

2. Step 2: Add 10 and print

   42 + 10 equals 52, so the output prints "Number plus 10 is 52".

3. Final Answer:

   Number plus 10 is 52 -> Option A

4. Quick Check:

   42 + 10 = 52 [OK]

Hint: Trim and parse input before math operations [OK]

Common Mistakes:

• Not trimming input before parse
• Parsing input as wrong type
• Ignoring parse errors

4. Identify the error in this Rust code snippet that reads an integer from input:

let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed");
let num: i32 = input.parse().expect("Not a number");
println!("Number: {}", num);

medium

A. parse() called without trimming input

B. Missing &mut before input in read_line

C. input is not mutable

D. println! macro syntax error

Solution

1. Step 1: Check read_line usage

   read_line correctly uses &mut input and input is mutable.

2. Step 2: Identify parse error cause

   parse() is called on input without trimming, so newline remains causing parse failure.

3. Final Answer:

   parse() called without trimming input -> Option A

4. Quick Check:

   Always trim input before parse() [OK]

Hint: Always trim input string before parsing to number [OK]

Common Mistakes:

• Forgetting to trim input before parse
• Assuming read_line returns trimmed string
• Misusing &mut in read_line

5. You want to read multiple numbers from user input separated by spaces and store them in a vector of integers. Which Rust code correctly does this?

use std::io;
fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed");
    let numbers: Vec<i32> = input.trim().split_whitespace()
        .map(|x| x.parse().expect("Not a number"))
        .collect();
    println!("Numbers: {:?}", numbers);
}

hard

A. read_line() cannot read multiple numbers at once.

B. Fails because split_whitespace() does not split strings.

C. parse() should be called before split_whitespace().

D. Correctly reads and parses space-separated numbers into a vector.

Solution

1. Step 1: Read input line and trim

   Input is read as a string and trimmed to remove trailing whitespace.

2. Step 2: Split and parse each number

   split_whitespace() splits input by spaces, map parses each piece to i32, collect gathers into vector.

3. Final Answer:

   Correctly reads and parses space-separated numbers into a vector. -> Option D

4. Quick Check:

   split_whitespace + map(parse) + collect = vector [OK]

Hint: Use split_whitespace, map parse, then collect to vector [OK]

Common Mistakes:

• Parsing before splitting input
• Using wrong iterator methods
• Assuming read_line reads multiple inputs separately