Example #

fn main() {
    panic!("error occured");
    println!("Hello, Rust");
}

Running result:

thread 'main' panicked at 'error occured', src\main.rs:3:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

Obviously, the program doesn’t run to println! (“Hello, Rust”) as expected, but on panic! The macro stopped running when it was called.

An unrecoverable error must cause the program to be fatally hit and stop running.

Let’s look at the two lines of error output:

• The first line outputs panic! the location of the macro call and the error message it outputs.

• The second line is a prompt, which translates into Chinese as “run through the ` RUST_BACKTRACE=1‘environment variable to display backtracking”. Next we will introduce backtrace.

Following the example just now, let’s create a new terminal in VSCode:

Set environment variables in the newly created terminal (different terminal methods are different, here are two main methods):

If you are in a Windows system version of Windows 7 or above, the terminal command line used by default is Powershell , use the following command:

$env:RUST_BACKTRACE=1 ; cargo run

If you are using a UNIX system such as Linux or macOS, the default is bash command line, use the following command:

RUST_BACKTRACE=1 cargo run

Then you will see the following text:

thread 'main' panicked at 'error occured', src\main.rs:3:5
stack backtrace:
  ...
  11: greeting::main
             at .\src\main.rs:3
  ...

Backtracking is another way to handle unrecoverable errors. It expands the running stack and outputs all the information, and then the program still exits. The ellipsis above omits a lot of output information, and we can findthe panic! error triggered by macro.

Example #

use std::fs::File;
fn main() {
    let f = File::open("hello.txt");
    match f {
        Ok(file) => {
            println!("File opened successfully.");
        },
        Err(err) => {
            println!("Failed to open the file.");
        }
    }
}

If hello.txt file does not exist and will be printed "Failed toopen the file." .

Of course, we talked about it in the enumeration section. if let syntaxcan be simplified match grammatical block:

Example #

use std::fs::File;
fn main() {
    let f = File::open("hello.txt");
    if let Ok(file) = f {
        println!("File opened successfully.");
    } else {
        println!("Failed to open the file.");
    }
}

If you want a recoverable error to be handled as an unrecoverable error, the Result class provides two methods: `` unwrap () `` and expect (message: & str):

Example #

use std::fs::File;
fn main() {
    let f1 = File::open("hello.txt").unwrap();
    let f2 = File::open("hello.txt").expect("Failed to open.");
}

This program is equivalent to Result for Err called when the panic! Macro. The difference between the two is expect , you can talk to panic! The macro sends a specified error message.

Example #

fn f(i: i32) -> Result<i32, bool> {
    if i >= 0 { Ok(i) }
    else { Err(false) }
}
fn main() {
    let r = f(10000);
    if let Ok(v) = r {
        println!("Ok: f(-1) = {}", v);
    } else {
        println!("Err");
    }
}

Running result:

Ok: f(-1) = 10000

The function f in this program is the source of the error, so now let’s write another function g that passes the error:

Example #

fn g(i: i32) -> Result<i32, bool> {
    let t = f(i);
    return match t {
        Ok(i) => Ok(i),
        Err(b) => Err(b)
    };
}

The function g passes a possible error in the function f (g here is just a simple example, but in fact the function that passes the error usually contains a lot of other operations).

It’s a bit lengthy to write like this, and you can use it in Rust Result add after object ? operator sets the same kind of Err pass it directly out:

Example #

fn f(i: i32) -> Result<i32, bool> {
    if i >= 0 { Ok(i) }
    else { Err(false) }
}
fn g(i: i32) -> Result<i32, bool> {
    let t = f(i)?;
    Ok(t) // Because it is certain that t is not Err, t is already of type i32 here
}
fn main() {
    let r = g(10000);
    if let Ok(v) = r {
        println!("Ok: g(10000) = {}", v);
    } else {
        println!("Err");
    }
}

Running result:

Ok: g(10000) = 10000

The actual function of the symbol ? is to set the Result .The non-abnormal value of the class is taken out directly, and if there is an exception, the exception will be taken out. Result go back out. Therefore, the ? symbol is only used to return a value of type Result<T, E> where the function of E type must be the same as ? what is handled Result of E type is the same.

Example #

use std::io;
use std::io::Read;
use std::fs::File;
fn read_text_from_file(path: &str) -> Result<String, io::Error> {
    let mut f = File::open(path)?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}
fn main() {
    let str_file = read_text_from_file("hello.txt");
    match str_file {
        Ok(s) => println!("{}", s),
        Err(e) => {
            match e.kind() {
                io::ErrorKind::NotFound => {
                    println!("No such file");
                },
                \_ => {
                    println!("Cannot read the file");
                }
            }
        }
    }
}

Running result:

No such file