Reading input basics in Rust - Mini Project: Build & Apply

Reading input basics

📖 Scenario: You are creating a simple Rust program that asks the user for their name and age. This is a common task when you want to interact with people using your program.

🎯 Goal: Build a Rust program that reads the user's name and age from the keyboard and stores them in variables.

📋 What You'll Learn

Use the std::io module to read input

Create variables to store the user's name and age

Trim the input to remove extra spaces or newlines

Convert the age input from a string to a number

💡 Why This Matters

🌍 Real World

Reading input from users is essential for interactive programs like games, quizzes, or command-line tools.

💼 Career

Many programming jobs require handling user input safely and correctly, especially in backend or systems programming.

1

Create variables to store user input

Write code to create two mutable variables called name and age as empty String values.

Rust

let mut name = String::new();
let mut age = String::new();
// Your code here

Hint

Use String::new() to create empty strings for name and age.

2

Read user input for name and age

Add code to read input from the user into the variables name and age using io::stdin().read_line(&mut name) and io::stdin().read_line(&mut age).

Rust

use std::io;

fn main() {
    let mut name = String::new();
    let mut age = String::new();

    io::stdin().read_line(&mut name).expect("Failed to read name");
    io::stdin().read_line(&mut age).expect("Failed to read age");
    // Your code here
}

Hint

Use io::stdin().read_line(&mut variable) to read input into each variable.

3

Trim input and convert age to number

Add code to trim whitespace from name and age. Then convert age from a string to an u32 number using age.trim().parse::() and store it in a new variable called age_num.

Rust

use std::io;

fn main() {
    let mut name = String::new();
    let mut age = String::new();

    io::stdin().read_line(&mut name).expect("Failed to read name");
    io::stdin().read_line(&mut age).expect("Failed to read age");

    let name = name.trim();
    let age_num: u32 = age.trim().parse().expect("Please type a number!");
    // Your code here
}

Hint

Use trim() to remove spaces and parse() to convert the age string to a number.

4

Print the user's name and age

Write a println! statement to display the message: Hello, {name}! You are {age_num} years old. using the variables name and age_num.

Rust

use std::io;

fn main() {
    let mut name = String::new();
    let mut age = String::new();

    io::stdin().read_line(&mut name).expect("Failed to read name");
    io::stdin().read_line(&mut age).expect("Failed to read age");

    let name = name.trim();
    let age_num: u32 = age.trim().parse().expect("Please type a number!");

    println!("Hello, {}! You are {} years old.", name, age_num);
    // Your code here
}

Hint

Use println!("Hello, {}! You are {} years old.", name, age_num); to show the message.

Practice

1. What is the main purpose of using io::stdin().read_line(&mut input) in Rust?

easy

A. To read a line of text input from the user

B. To print text to the console

C. To declare a new variable

D. To create a new thread

Solution

1. Step 1: Understand the function of read_line

   This function reads a line of input from the user and stores it in a mutable string.

2. Step 2: Identify the purpose of io::stdin()

   io::stdin() accesses the standard input stream, allowing the program to receive user input.

3. Final Answer:

   To read a line of text input from the user -> Option A

4. Quick Check:

   Reading input = B [OK]

Hint: Remember: read_line reads user input into a string [OK]

Common Mistakes:

• Confusing input reading with printing output
• Forgetting to make the string mutable
• Using read_line without a mutable reference

2. Which of the following is the correct way to declare a mutable string variable to store user input in Rust?

easy

A. let input: &str = String::new();

B. let input = String::new();

C. let mut input = String::new();

D. let mut input: &str = String::new();

Solution

1. Step 1: Identify the need for mutability

   To store user input, the string must be mutable because read_line modifies it.

2. Step 2: Check the correct syntax for mutable String

   let mut input = String::new(); correctly declares a mutable String variable.

3. Final Answer:

   let mut input = String::new(); -> Option C

4. Quick Check:

   Mutable String declaration = A [OK]

Hint: Use 'mut' to allow input string to change [OK]

Common Mistakes:

• Omitting 'mut' keyword for the input string
• Using &str instead of String for input storage
• Declaring input as immutable

3. What will be the output of this Rust code if the user types "hello" and presses Enter?

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    println!("You typed: {}", input.trim());
}

medium

A. Compilation error

B. You typed: hello

C. You typed:

D. You typed: hello\n

Solution

1. Step 1: Understand input reading and trimming

   The program reads the input including the newline, but trim() removes whitespace like newlines.

2. Step 2: Analyze the output statement

   The trimmed input "hello" is printed after "You typed: ".

3. Final Answer:

   You typed: hello -> Option B

4. Quick Check:

   Trim removes newline, output = D [OK]

Hint: Remember to trim input to remove newline before printing [OK]

Common Mistakes:

• Not trimming input, so newline appears in output
• Expecting raw input without newline removal
• Confusing compile errors with runtime behavior

4. Identify the error in this Rust code snippet that tries to read user input:

use std::io;

fn main() {
    let input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    println!("Input: {}", input);
}

medium

A. The variable 'input' should be mutable

B. Missing 'use std::io::Write;' import

C. read_line should not use '&mut' reference

D. println! macro syntax is incorrect

Solution

1. Step 1: Check variable mutability

   read_line requires a mutable reference to modify the string, but input is not mutable.

2. Step 2: Confirm other parts are correct

   Imports and println! syntax are correct; only mutability is missing.

3. Final Answer:

   The variable 'input' should be mutable -> Option A

4. Quick Check:

   Mutable variable needed for read_line = C [OK]

Hint: Make input mutable to allow read_line to change it [OK]

Common Mistakes:

• Forgetting 'mut' keyword for input variable
• Thinking &mut is not needed for read_line
• Assuming println! syntax is wrong

5. You want to read a user's age as an integer from input. Which code snippet correctly reads the input, trims it, and converts it to an i32 in Rust?

hard

A. let age = String::new(); io::stdin().read_line(&age).expect("Failed"); let age: i32 = age.trim().parse().unwrap();

B. let age: i32 = io::stdin().read_line().trim().parse().expect("Invalid number");

C. let mut age = String::new(); io::stdin().read_line(age).expect("Failed"); let age: i32 = age.parse().unwrap();

D. let mut age = String::new(); io::stdin().read_line(&mut age).expect("Failed"); let age: i32 = age.trim().parse().expect("Invalid number");

Solution

1. Step 1: Read input into a mutable String

   Input must be stored in a mutable String variable passed as a mutable reference to read_line.

2. Step 2: Trim and parse input to i32

   Use trim() to remove whitespace, then parse() to convert to integer, handling errors with expect().

3. Final Answer:

   let mut age = String::new(); io::stdin().read_line(&mut age).expect("Failed"); let age: i32 = age.trim().parse().expect("Invalid number"); -> Option D

4. Quick Check:

   Mutable input + trim + parse = A [OK]

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

Common Mistakes:

• Not making input string mutable
• Forgetting to trim before parsing
• Passing input without &mut to read_line