Rustのmatch文とデフォルトケース（_）を徹底解説！初心者でも簡単に理解できる使い方

match 値 {
    パターン1 => 処理1,
    パターン2 => 処理2,
    ...
    パターンN => 処理N,
}

fn main() {
    let number = 3;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other"),
    }
}

fn main() {
    let color = "red";

    match color {
        "red" => println!("The color is red!"),
        "blue" => println!("The color is blue!"),
        _ => println!("Unknown color!"),
    }
}

fn main() {
    let number = 7;

    match number {
        1..=5 => println!("Between 1 and 5"),
        6..=10 => println!("Between 6 and 10"),
        _ => println!("Out of range"),
    }
}

fn main() {
    let point = (0, 5);

    match point {
        (0, y) => println!("On the y-axis at y = {}", y),
        (x, 0) => println!("On the x-axis at x = {}", x),
        _ => println!("Not on any axis"),
    }
}

fn main() {
    let fruit = "apple";

    match fruit {
        "banana" => println!("It's a banana."),
        "orange" => println!("It's an orange."),
        _ => println!("It's some other fruit."),
    }
}

fn main() {
    let number = 42;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        _ => println!("Other number"), // 1や2以外の数字に対応
    }
}

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let color = Color::Red;

    match color {
        Color::Red => println!("Red"),
        Color::Green => println!("Green"),
        // Color::Blueが漏れてしまう
        _ => println!("Unknown color"),
    }
}

fn main() {
    let value: i32 = 10;

    match value {
        1 => println!("One"),
        2..=10 => println!("Between two and ten"),
        _ => println!("Out of range"),
    }
}

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let color = Color::Red;

    match color {
        Color::Red => println!("Red"),
        Color::Green => println!("Green"),
        // Color::Blueが網羅されていないためエラーになる
    }
}

fn main() {
    let number = 7;

    match number {
        1..=10 => {
            match number % 2 {
                0 => println!("Even number between 1 and 10"),
                1 => println!("Odd number between 1 and 10"),
                _ => unreachable!(), // Rustでは到達しないケースを示す
            }
        }
        _ => println!("Number is out of range"),
    }
}

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 0, y: 5 };

    match point {
        Point { x, y: 0 } => println!("Point is on the x-axis at x = {}", x),
        Point { x: 0, y } => {
            match y {
                1..=10 => println!("Point is on the y-axis in range 1 to 10"),
                _ => println!("Point is on the y-axis but out of range"),
            }
        }
        _ => println!("Point is somewhere else"),
    }
}

fn check_y_range(y: i32) {
    match y {
        1..=10 => println!("Point is on the y-axis in range 1 to 10"),
        _ => println!("Point is on the y-axis but out of range"),
    }
}

fn main() {
    let point = (0, 7);

    match point {
        (0, y) => check_y_range(y),
        _ => println!("Point is not on the y-axis"),
    }
}

fn main() {
    let number = 15;

    match number {
        1..=10 => println!("Number is between 1 and 10"),
        11..=20 => {
            println!("Number is between 11 and 20");
            if number % 2 == 0 {
                println!("It's even");
            } else {
                println!("It's odd");
            }
        }
        _ => println!("Number is out of range"),
    }
}

fn main() {
    let operator = '+';
    let operand1 = 10;
    let operand2 = 5;

    match operator {
        '+' => println!("{} + {} = {}", operand1, operand2, operand1 + operand2),
        '-' => println!("{} - {} = {}", operand1, operand2, operand1 - operand2),
        '*' => println!("{} * {} = {}", operand1, operand2, operand1 * operand2),
        '/' => {
            if operand2 != 0 {
                println!("{} / {} = {}", operand1, operand2, operand1 / operand2);
            } else {
                println!("Error: Division by zero");
            }
        }
        _ => println!("Unsupported operator"),
    }
}

use std::io;

fn main() {
    let mut operator = String::new();
    let mut operand1 = String::new();
    let mut operand2 = String::new();

    println!("Enter the first number:");
    io::stdin().read_line(&mut operand1).expect("Failed to read line");
    let operand1: i32 = operand1.trim().parse().expect("Invalid input");

    println!("Enter the operator (+, -, *, /):");
    io::stdin().read_line(&mut operator).expect("Failed to read line");
    let operator: char = operator.trim().chars().next().expect("Invalid input");

    println!("Enter the second number:");
    io::stdin().read_line(&mut operand2).expect("Failed to read line");
    let operand2: i32 = operand2.trim().parse().expect("Invalid input");

    match operator {
        '+' => println!("{} + {} = {}", operand1, operand2, operand1 + operand2),
        '-' => println!("{} - {} = {}", operand1, operand2, operand1 - operand2),
        '*' => println!("{} * {} = {}", operand1, operand2, operand1 * operand2),
        '/' => {
            if operand2 != 0 {
                println!("{} / {} = {}", operand1, operand2, operand1 / operand2);
            } else {
                println!("Error: Division by zero");
            }
        }
        _ => println!("Unsupported operator"),
    }
}

enum Color {
    Red,
    Green,
    Blue,
    Yellow,
}

fn main() {
    let color = Color::Yellow;

    match color {
        Color::Red => println!("Red"),
        Color::Green => println!("Green"),
        Color::Blue => println!("Blue"),
        _ => println!("Unknown color"), // 新たなColor::Yellowもこのケースに入る
    }
}

match color {
    Color::Red => println!("Red"),
    Color::Green => println!("Green"),
    Color::Blue => println!("Blue"),
    Color::Yellow => println!("Yellow"),
}

fn main() {
    let value: i32 = 100;

    match value {
        1 => println!("One"),
        2 => println!("Two"),
        _ => println!("Other"), // valueが意図せずこのケースに入る可能性
    }
}

match value {
    1 => println!("One"),
    2 => println!("Two"),
    3..=10 => println!("Between three and ten"),
    _ => println!("Out of range"),
}

match value {
    1 => println!("Case 1"),
    _ => println!("Fallback case"), // ここが多用されると処理の意図が不明確に
}

match value {
    1 => println!("Case 1"),
    2 => println!("Case 2"),
    _ => println!("Unexpected value: {}", value),
}

use std::fs::File;
use std::io::Error;

fn main() {
    let file_result = File::open("example.txt");

    match file_result {
        Ok(file) => println!("File opened successfully: {:?}", file),
        Err(error) => println!("Failed to open file: {}", error),
    }
}

use std::fs::File;
use std::io::{self, ErrorKind};

fn main() {
    let file_result = File::open("example.txt");

    match file_result {
        Ok(file) => println!("File opened successfully: {:?}", file),
        Err(ref error) if error.kind() == ErrorKind::NotFound => {
            println!("File not found. Creating a new file...");
            match File::create("example.txt") {
                Ok(_) => println!("File created successfully."),
                Err(e) => println!("Failed to create file: {}", e),
            }
        }
        Err(error) => println!("Unexpected error occurred: {}", error),
    }
}

use std::fs::File;
use std::io::{self, Read};

fn main() {
    match File::open("example.txt") {
        Ok(mut file) => {
            let mut content = String::new();
            match file.read_to_string(&mut content) {
                Ok(_) => println!("File content: {}", content),
                Err(error) => println!("Failed to read file: {}", error),
            }
        }
        Err(error) => println!("Failed to open file: {}", error),
    }
}

use std::fs::File;
use std::io::{self, Error, Read};

fn open_and_read_file(path: &str) -> Result<String, Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match open_and_read_file("example.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(error) => println!("Error: {}", error),
    }
}