::collections::HashMap;
fn main(){
println!("-----------------------------------------");
println!("hello world, hello rust 1.50 ***");
println!("");
println!("************* 1: helloworld **************");
let mut a_number = 10;
let a_boolean = true;
println!("the number is {}", a_number);
println!("the boolean is {}", a_boolean);
a_number = 15;
println!("and now the number is {}.", a_number);
// new var will gide prev var (shadow handle var)
let num = 5;
let num = num + 5;
let num = num * 2;
println!("num is {}", num);
println!();
println!("************* 2: data type **************");
// type annotations needed
// let number = "123".parse().expect("Not a number!");
let number:u32 = "123".parse().expect("Not a number!");
println!("{:?}", number);
/*
data types:
1. number: i8 u8, i16 u16, i32 u32, i64 u64 , i128 u128 | f32 f64
2. bool: true false
3. char & string: '' String::from
4. tuple: 元组是集中到一个复合体中的不同类型值的分组。 元组具有固定长度，这表示在声明后，它们便无法增大或缩小。 元组的类型由各元素类型的序列定义
5. struct: 结构是多个其他类型的组合体。 与元组一样，结构的各个部分可以是不同的类型，但我们可以为每个数据片段命名，以便清楚说明值的含义
-> 经典结构、元组结构和单元结构
6. enum:
*/
// 默认类型为 f64，因为在新式 CPU 上，其速度大致与 f32 相同，但精度更高
// 1
let x = 2.0; // f64, default type
let y: f32 = 3.0; // f32
println!("{}, {}", x,y);
// 2
let is_bigger = 1>4;
println!("{:?}", is_bigger);
// 3
let c = 'z';
println!("{:?}", c);
let mut hello = String::from("Hello, ");
hello.push('W'); // char
hello.push_str("orld!");
println!("{:?}", hello);
// 4
let tuple = ("hello", 5, 'c');
println!("{}", tuple.0);
println!("{}", tuple.1);
println!("{}", tuple.2);
// 5
struct Person{
name: String,
age: u8,
likes_oranges: bool
}
let p1 = Person{
name: String::from("adley"),
likes_oranges: true,
age: 25
};
println!("p1 is: {}, {}, {}", p1.name, p1.age, p1.likes_oranges);
struct Ponit(u32, u32);
let p2 = Ponit(200, 400);
println!("p2 is: {}, {}",p2.0, p2.1);
// 6
#[derive(Debug)]
enum Week {
Monday,
Tuesday,
Wednesday
};
println!("Monday is {:?}", Week::Monday);
println!("Tuesday is {:?}", Week::Tuesday);
println!("Wednesday is {:?}", Week::Wednesday);
println!();
println!("************* 3: fn **************");
another_function();
let r = is_divisable_by(12, 6);
println!("is_divisable_by result is: {}", r);
println!();
println!("************* 4: collection 复合类型 **************");
/*
* collection 复合类型:
* 1. Array: 数组长度在编译时已知
* 2. Vector: 向量可以随时增大或缩小, 用户可以使用 vec! 宏初始化向量
*/
let weeks = [
"Monday",
"Tuesday",
"Wednesday"
];
println!("{}, {}, {}", weeks[0], weeks[1], weeks[2]);
// 2
let three_numbers = vec![1, 2, 3];
println!("init vec is: {:?}", three_numbers);
let mut v = Vec::new();
v.push(123);
v.push(456);
v.push(789);
println!("{:?}", v);
v.pop();
println!("{:?}", v);
// index out of bounds
// let v = vec![1, 2, 3, 4, 5];
// let does_not_exist = v[100];
println!();
println!("************* 5: hashMap 哈希映射 **************");
let mut people = HashMap::new();
people.insert("name", "adley");
people.insert("age", "18");
people.insert("like_orange", "true");
println!("len: {}", people.len());
println!("{:?}", people);
let basket = fruit_basket();
println!("{:?}", basket);
println!();
println!("************* 6: if/else **************");
let number = 17;
if number >= 18 {
println!("you are audit");
}else {
println!("you are child");
}
println!();
println!("************* 7: loop **************");
// 1 loop
let mut i=1;
let oi = loop {
i *= 2;
if i > 10 {
break i;
}
};
println!("{}", oi);
// 2 while
let mut j = 0;
while j < 10 {
j += 2;
println!("{}", j);
}
// 3 for
let a = [10, 20, 30, 40, 50];
for el in a.iter() {
println!("el is {}", el);
}
// 3-2 for range
for i in 3..9 {
println!("range el is: {}", i);
}
println!();
println!("************* 8: error handle **************");
// panic!("Farewell!");
let fruits = vec!["banana", "apple", "coconut", "orange", "strawberry"];
// pick the first item:
let first = fruits.get(0);
println!("{:?}", first);
// pick the third item:
let third = fruits.get(2);
println!("{:?}", third);
// pick the 99th item, which is non-existent:
let non_existent = fruits.get(99);
println!("{:?}", non_existent);
println!("------");
for &index in [0,1,99].iter() {
println!("{:?}", index);
match fruits.get(index) {
Some(&"apple") => println!("oh, is apple yee!! "),
Some(fruit_name) => println!("It's a delicious: {}", fruit_name),
None => println!("There is no fruit :("),
}
}
let gift = Some("candy");
println!("{:?}", gift.unwrap());
let empty_gift: Option<&str> = None;
// assert_eq!(empty_gift.unwrap(), "candy"); // This will panic!
println!("{:?}", empty_gift.unwrap_or("haha"));
// let b: Option<&str> = None;
// b.expect("fruit is healthy~");
println!();
println!("************* 9: ownership **************");
// 所有权和借用
// Rust 无需垃圾回收器就能实现内存安全保证，这不同于许多其他语言
// 在 Rust 中，变量仅在特定作用域（由大括号 {} 表示）内有效
// {
// let mascot = "feeris";
// }
// println!("{:?}", mascot);
// &mut T - 可变借用, 向借用者授予读取/写入访问权限
// &T 通过“不可变引用”或“不可变借用”来借用数据。 然后，借用者就可以读取数据，但无法修改它
caller();
let str1 = String::from("aaaaaba");
let str2 = String::from("aaba12232323");
let result = longest_word(&str1, &str2);
println!("{:?}", result);
}
fn another_function(){
println!("hello from another function ...");
}
fn is_divisable_by(dividend: u32, divisor: u32) -> bool {
if divisor == 0 {
return false;
}
dividend % divisor == 0
}
fn fruit_basket() -> HashMap<String, u32> {
let mut basket = HashMap::new();
basket.insert(String::from("banaa"), 2);
basket.insert(String::from("apple"), 12);
basket.insert(String::from("pear"), 23);
basket
}
fn caller(){
// &mut T
let mut s = String::from("greeting");
process(&mut s);
process(&mut s);
// &T
let s = String::from("greeting");
process2(&s);
process2(&s);
}
fn process(input: &mut String){
input.push_str(" hi~");
println!("[&mut T]: {:?}", input);
}
fn process2(input: & String){
println!("[&T]: {:?}", input);
}
fn longest_word<'a>(x: &'a str , y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
