vector, 哈希与错误的基本操作

1, vector的基本操作

fn main() {
    //新建vector
    let mut v = Vec::new();
    v.push(1);
    v.push(2);
    println!("vec = {:?}", v);

    //读取 vector 的元素
    //索引语法或者 get 方法
    let mut v = vec![1, 2, 3, 4, 5];
    let third = &v[2];
    println!("the third ele is {}", third);
    v.push(6);  // 在前面发生借用的情况下,这个仍然可以修改
    match v.get(5) {
        Some(third) => {
            println!("The six ele is {}", third)
        },
        None => {
            println!("There is no six ele")
        }
    }

    //遍历不可变 vector 中的元素
    let v = vec![100, 23, 234, 33];
    for i in &v {
        println!("{} ", i);
    }

    //遍历 可变 vector 中的元素, 并且修改其中的值
    let mut v = vec![100, 300 ,400];
    for i in &mut v {
        *i += 50;
    }
    println!("可变vec修改后: {:?}", v);

    //使用枚举来储存多种类型
    enum SpreadsheetCell {
        Int(i32),
        Float(f64),
        Text(String),
    }
    let row = vec![
        SpreadsheetCell::Int(34),
        SpreadsheetCell::Float(12.32),
        SpreadsheetCell::Text("red".to_string()),
    ];
    let one = &row[0];  // 枚举不能够移动, 只能够引用
    match one {            //读取枚举的值
        SpreadsheetCell::Int(i) => {
            println!("int is {}", i)
        },
        SpreadsheetCell::Float(f) => {
            println!("float is {}", f);
        },
        SpreadsheetCell::Text(t) => {
            println!("t is {}", t);
        }
    }
}

2,哈希 map基本操作

fn main() {
    //新建一个哈希 map
    use std::collections::HashMap;

    let mut scores = HashMap::new();
    scores.insert(String::from("blue"), 10);
    scores.insert(String::from("yellow"), 40);
    println!("1, hash map : {:?}", scores);

    //另一个构建哈希 map 的方法是使用一个元组的 vector 的 collect 方法
    let teams = vec![String::from("red"), String::from("black")];
    let initial_scores = vec![10, 30];
    let scores : HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect();
    println!("2, hash map : {:?}", scores);

    //哈希 map 和所有权
    //对于像 i32 这样的实现了 Copy trait 的类型，其值可以拷贝进哈希 map。
    //对于像 String 这样拥有所有权的值，其值将被移动而哈希 map 会成为这些值的所有者，
    let field_name = String::from("Favorite color");
    let field_value = String::from("Blue");
    let mut map = HashMap::new();
    map.insert(field_name, field_value);
    println!("3, hash map : {:#?}", map);
    // 这里 field_name 和 field_value 不再有效，
    // 尝试使用它们看看会出现什么编译错误！

    //访问哈希 map 中的值
    let team_name = String::from("Favorite color");
    let score = map.get(&team_name);
    match score {
        Some(name) => {
            println!("访问hash中的变量: {}", name);
        },
        None => {
            println!("score is nothing");
        }
    }
    if let Option::Some(name) = score {
        println!("第二种: 访问hash中的变量: {}", name);
    }

    //遍历哈希 map 中的每一个键值对, 这会以任意顺序打印出每一个键值对
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);
    for (key, value) in &scores {
        println!("遍历: {}: {}", key, value);
    }

    //覆盖一个值
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Blue"), 25);
    println!("覆盖 : {:?}", scores);

    //只在键没有对应值时插入
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);

    scores.entry(String::from("Yellow")).or_insert(50);
    scores.entry(String::from("Blue")).or_insert(50);

    println!("键没有对应值时插入: {:?}", scores);

    //根据旧值更新一个值
    let text = "hello world wonderful world";
    let mut map = HashMap::new();
    for word in text.split_whitespace() {            //分割字符串
        let count = map.entry(word).or_insert(0);   // 没有键的时候插入为0
        *count += 1;                                 // 增加1
    }
    println!("根据旧值更新一个值 : {:?}", map);

}

3,错误操作

fn f(i: i32) -> Result<i32, bool> {
    if i >= 0 {
        Result::Ok(i)
    } else {
        Result::Err(false)
    }
}

fn g(i: i32) -> Result<i32, bool> {
    let t = f(i)?;  // Rust 中可以在 Result 对象后添加 ? 操作符将同类的 Err 直接传递出去：
    Ok(t) // 因为确定 t 不是 Err, t 在这里已经是 i32 类型
}

fn main() {
    let r = g(10000);
    if let Ok(v) = r {
        println!("Ok: g(10000) = {}", v);
    } else {
        println!("Err");
    }
    let a = Option::Some(1);
    if let Option::Some(a) = a {
        println!("a = {}", a);
    } else {
        println!("no record");
    }
}

// 获取错误的类型
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() {        // 判断 Result 的 Err 类型，获取 Err 类型的函数是 kind()。
                io::ErrorKind::NotFound => {
                    println!("No such file");
                },
                _ => {
                    println!("Cannot read the file");
                }
            }
        }
    }
}

// 简介的写法
use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut s = String::new();
    File::open("hello.txt")?.read_to_string(&mut s)?;  // ?有错误直接返回
    Ok(s)
}

fn main() {
    match read_username_from_file() {
        Ok(s) => {
            println!("s = {}", s);
        },
        Result::Err(e) => {
            println!("error: {}", e.to_string());
        }
    }
}

// 传播错误
use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let f : io::Result<File> = File::open("hello.txt");

    let mut f : File = match f {    // 从Result中取到File类型再赋值给f变量
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut s = String::new();

    match f.read_to_string(&mut s) {
        Ok(_) => Ok(s),
        Err(e) => Err(e),
    }
}

fn main() {
    match read_username_from_file() {
        Ok(s) => {
            println!("s = {}", s);
        },
        Result::Err(e) => {
            println!("error: {}", e.to_string());
        }
    }
}