let start = Instant::now(); // 记录开始时间点
let mut text1 = text.chars();
for i in 0..1000 {
    let a = text1.nth(500);
}
let elapsed = start.elapsed(); // 计算时间间隔
let elapsed_ms = elapsed.as_secs() as f64 * 1000.0 + elapsed.subsec_nanos() as f64 / 1_000_000.0; // 转换为毫秒
println!("用时 {}", elapsed_ms);
// 0.05 ms

let start = Instant::now(); // 记录开始时间点
let text1 = text.clone().into_bytes();
for i in 0..1000 {
    let a = text1[500];
}
let elapsed = start.elapsed(); // 计算时间间隔
let elapsed_ms = elapsed.as_secs() as f64 * 1000.0 + elapsed.subsec_nanos() as f64 / 1_000_000.0; // 转换为毫秒
println!("用时 {}", elapsed_ms);
// 0.01 ms

let a: &[u8; 3] = &[65, 68, 66];

// 以下4种方式时间消耗从高到低
let b1 = String::from_utf8(a.to_vec()).unwrap();
let b3 = unsafe { String::from_utf8_unchecked(a.to_vec()) };
let b2 = std::str::from_utf8(a).unwrap();
let b4 = unsafe { std::str::from_utf8_unchecked(a) };
// 时间消耗分别是 `4.542µs, 375ns, 84ns, 42ns`

fn fn_add(a: i32, b: i32) -> i32 {
    return a + b;
}
fn fn_sub(a: i32, b: i32) -> i32 {
    return a - b;
}

// 可以把他们放到一个 arr 里面，前提是 这些函数的输入/输出的数量和类型都要一样
let fn_arr = [fn_add, fn_sub];

// 可以先定义它，在之后的代码具体赋值
let fun_op: fn(i32, i32) -> i32;
let idx = 0;
fun_op = fn_arr[idx];
println!("{}", fun_op(1, 2))

struct ClsOpt {
    idx: i32,
    func: fn(i32, i32) -> i32,
}

lazy_static! {
     static ref obj_add: ClsOpt={
        let idx=1;

        ClsOpt{
        idx,
        func: fn_add
    }};
}

fn main() {
    println!("Counter: {}", (obj_add.func)(1, 3));
}

// 一段不合法的 utf-8 编码，可能导致报错
let a: [u8; 3] = [230, 230, 220];
// let a: [u8; 3] = [97,98,99];
let val = String::from_utf8(a.to_vec());

// 推荐做法
match val {
    Ok(x) => println!("{}", x),
    Err(err) => println!("{}", err)
}

// unwrap_or_else 允许在遇到 Error 时执行一个回调函数来得到默认值
println!("hello {}", val.unwrap_or_else(|err| {
    println!("报错");
    "默认值".to_string()
}));

// 慎用的做法
val.unwrap(); // val 正确的时候，返回值。错误的时候 Panic
val.unwrap_err(); // val 正确的时候 Panic，错误的示范返回错误类型
val.unwrap_or("错啦".to_string()) // 错误的时候返回自定义值
val.unwrap_or_default(); // 错误则返回默认值

unsafe { println!("hello {}", val.unwrap_unchecked()); } // 必须与 unsafe 模块连用。不做检查，不抛出错误。
unsafe { println!("hello {}", val.unwrap_err_unchecked()); } // 必须与 unsafe 模块连用。不做检查，不抛出错误。

// 这个代码中间某个位置反复报错，但可以
for i in 0..10 {
    let x = i;
    let result = panic::catch_unwind(|| {
        if x % 2 == 0 {
            panic!("错啦！x = {}", x);
        } else { return 0; }
    });

    match result {
        Ok(value) => println!("正确的: {:?}", value),
        Err(error) => println!("错误的: {:?}", error),
    }
}

// bytes 对应的 index，char 对应的 index
let s = "你好，hello";
let mut char_idx = 0;
for (byte_idx, _) in s.char_indices() {
    println!("{},{}", byte_idx, char_idx);
    char_idx += 1;
}

// 加上 mut 是可变的(mutable)，不加是不可变的
let mut guess = String::new();


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

//
println!("You guessed: {}", guess);

// rand = "0.8.3"
use std::cmp::Ordering;
use std::io;
use rand::Rng;

fn main() {
    println!("Guess the num!");

    let secret_num = rand::thread_rng().gen_range(1..101);

    println!("secret num is {}", secret_num);

    let mut guess = String::new();

    loop {
        println!("Please input you guess:");

        // read_line 的时候，不会覆盖，而是会添加到后面，所以每次循环要clear
        guess.clear();
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");


        // let guess: u32 = guess.trim().parse().expect("Please type a number!");
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("pleas input a num!");
                continue;
            }
        };


        println!("You guessed: {}", guess);


        match guess.cmp(&secret_num) {
            Ordering::Less => println!("Too small"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

// 相当于 enumerate
str1.char_indices()