User Input and Output

# CHAPTER 6

User Input and Output #

1. Chapter Introduction #

2. Learning Objectives #

• Import the standard Input/Output library (std::io).

• Read a line of text from the user's keyboard.

• Understand basic error handling with .expect().

• Parse strings into integers or floats.

• Trim whitespace from input strings.

3. The std::io Library #

use std::io; // Brings the io module into scope

fn main() {
    println!("Please enter your name:");
}

4. Reading User Input #

use std::io;

fn main() {
    println!("Please enter your name:");

    // 1. Create a MUTABLE, empty String to hold the input
    // String::new() is a function that creates a new, empty string.
    let mut user_name = String::new();

    // 2. Read the line from standard input
    io::stdin()
        .read_line(&mut user_name) // Pass a mutable reference to our string
        .expect("Failed to read line"); // Handle potential errors

    // 3. Print the result
    println!("Hello there, {}", user_name);
}

What is happening here?

• &mut username: readline needs to modify the string we created. The & indicates a Reference (which we will learn later), and mut means it is allowed to change it.

• .expect(): If the OS fails to read the input (e.g., the user hits an invalid shortcut key), the program will crash safely and print the custom error message. Rust forces you to handle errors explicitly!

5. Parsing Input into Numbers #

use std::io;

fn main() {
    println!("Enter your age:");

    let mut age_input = String::new();

    io::stdin()
        .read_line(&mut age_input)
        .expect("Failed to read line");

    // 1. Trim removes whitespace and the hidden '\n' newline character
    // 2. Parse converts the string into a number
    // 3. We define the type (u32) so parse() knows what to convert it into
    let age: u32 = age_input.trim().parse().expect("Please type a valid number!");

    println!("Next year you will be {}", age + 1);
}

6. Mini Project: User Profile App #

use std::io;

fn main() {
    println!("--- Welcome to the Profile Builder ---");
    
    // Read Name
    println!("Enter your username:");
    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read name");

    // Read Weight
    println!("Enter your weight in kg:");
    let mut weight_input = String::new();
    io::stdin().read_line(&mut weight_input).expect("Failed to read weight");
    
    let weight: f64 = weight_input.trim().parse().expect("Invalid weight entered");

    println!("\nProfile Created!");
    println!("Username: {}", name.trim()); // Trim to remove the newline from printing
    println!("Weight: {} kg", weight);
}

7. Common Mistakes #

• Forgetting &mut: If you write readline(username) without the &mut, the compiler will fail. readline requires a mutable reference to the variable so it can inject the data into it.

• Forgetting .expect(): readline and parse both return a Result type. If you don't handle the potential failure using .expect(), the code will not compile.

8. Best Practices #

• Handle errors gracefully: While .expect() crashes the program, later in the course we will learn how to use match to loop and ask the user to try again without crashing!

9. Exercises #

1. 1. Write a program that asks the user for the length and width of a rectangle.

1. 2. Read both inputs as strings, trim them, and parse them into f64.

1. 3. Calculate the Area and print it to the screen.

10. MCQs with Answers #

11. Interview Questions #

• Q: Why does Rust force developers to use .expect() or handle errors when taking user input, unlike languages like Python?

• Q: Describe the process of converting a user's terminal input into a mathematical integer in Rust.

12. FAQs #

• Can I hide the user's input (like typing a password)? Not with standard std::io. You would need to add a third-party "crate" (package) like rpassword to your Cargo.toml.

13. Summary #

14. Next Chapter Recommendation #