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());
}
}
}
网友评论