cd path
cargo new project

rustc filename.rs

cd project
cargo build

let var; //默认定义的变量是不可变的
let mut var;//定义可变变量

const cst:i32; //定义时必须指定类型

let num = 1;
let num = 2;

let thing1: u8 = 89.0 as u8;
assert_eq!('B' as u32, 66);
assert_eq!(thing1 as char, 'Y');
let thing2: f32 = thing1 as f32 + 10.5;
assert_eq!(true as u8 + thing2 as u8, 100);

let thing1 = 89.0 as u8;
let thing1: u8 = 89.0;

fn fun(a:i32, b:char) -> i32
{  
    return a;
}

fn fun1(a:i32, b:char) -> （i32，i32）
{  
    (a,a+1)
}

fn main()
{
    let y = {
        let x = 3;
        x + 1    //表达式无分号
    }; //y的定义语句才有分号
    println!("y = {}",y)；
}

fn main()
{
    let num = 3;
    if num < 4
    {    //不可省略花括号
        println!("num<4");
    }
    else
    {
        println!("num>4");
    }
}

fn main()
{
    let x = 1;    //x不是bool变量
    let y = if x {0} else {1};
    println!("{y}");
}

fn main()
{
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter==10{
            break counter * 2;
        }
    }
    println!("{result}");
}

fn main() {

    let mut count = 0;
    'count_up: loop{
        println!("{count}");
        let mut remaining = 10;
        loop{
            if remaining==9 {
                break;
            }
            if count==2 {
                break 'count_up;
            }
            remaining -= 1;
            println!("{remaining}");
        }
        count += 1;
    }
}

fn main(){

    let a = [10,20,30,40,50,60];
    for element in a{
        println!("{element}");
    }    

}

fn main() {
    let s = String::from("hello world");
    let s2;
    let b = false;
    if b {
        s2 = s;
    }
    println!("{}", s);
}

fn main()
{
    let first = String::from("Ferris");
    let full = add_suffix(first);
    println!("{full}");
}

fn add_suffix(mut name: String)
{
    name.push_str("Jr.");
    name
}

fn main() {
    let m1 = String::from("hello");
    let m2 = String::from("world");
    println!("m1:{m1}");
    println!("m1 addr:{:p}",&m1);
    greet(&m1,&m2);
}

fn greet(g1:&String, g2:&String)
{
    println!("{},{}",g1,g2);
    let addr_in_g1 = g1 as *const String;
    println!("{g1}");
    println!("g1 content:{:p}",addr_in_g1);
    println!("g1 addr:{:p}",&g1);
}

let x = 0;
let mut x_ref = &x;    //此时，x_ref有写的权限，但是*x_ref没有写的权限，也就是说，x_ref的指向可以被改变，但是指向的值也就是x不可被改变

    let s3:&str= "banana";
    let arr:[i32] = [1, 2, 3, 4, 5];

    let s3 = "banana";
    let arr = [1, 2, 3, 4, 5];

trait Draw {
    fn draw(&self) -> Self;
}

#[derive(Clone)]
struct Button;
impl Draw for Button {
    fn draw(&self) -> Self {
        return self.clone()
    }
}

fn main() {
    let button = Button;
    let newb = button.draw();
}

let v= Vec::new();    //Self调用关联函数
v.pop()；    //调用实例方法

struct UserStruct{
    active:bool,
    username:string,
    num:u64,
}

let mut user = User{
    email:String::from("@email.com"),
    username:String::from("name"),
    active:true,
    num:3,
};

let mut user2 = User{
    num:4,
    ..user1
};

struct Color(i32,i32,i32)

struct AlwaysEqual;
fn main()
{
    let subject = AlwaysEqual;
}

struct Point{x:i32,y:i32};

fn prt(p: &Point)
{
    println!("{}",p.x);
}

fn main() {
    
    let mut p = Point{x:0, y:0};

    let px = &mut p.x;
    
    p.y += 1;    //这里是有权限的
    
    *px+=1;
}

struct Rectangle{
    width:u32,
    height:u32,
}

impl Rectangle{
    fn new() -> Rectangle{
        Rectangle{width:0,height:0}
    }
    fn area(&self) -> u32{    //这里返回值类型不能省略，编译器不能自行推断
        self.height*self.width
    }

    fn can_hold(&self,other:&Rectangle) ->bool{
        self.height>other.height && self.width>other.width
    }

    fn square(size:u32) -> Self{ //参数不是self的方法被称为关联方法
        Self{
            width:size,
            height:size,
        }
    }
}

fn main() {
    let rect1 = Rectangle{
        width:1,
        height:3,
    };

    let rect2 = Rectangle{
        width:2,
        height:4,
    };

    println!("{}",rect1.can_hold(&rect2));
    println!("{}",Rectangle::can_hold(&rect1, &rect2));    //是上一行的语法糖
}

struct Rectangle {
    width: u32,
    height: u32,
}
impl Rectangle {    
  fn area(&self) -> u32 {
    self.width * self.height
  }

  fn set_width(&mut self, width: u32) {
    self.width = width;
  }

  fn max(self, other: Self) -> Self {
    let w = self.width.max(other.width);
    let h = self.height.max(other.height);
    Rectangle { 
      width: w,
      height: h
    }
  }
    fn set_to_max(&mut self, other: Rectangle) {
        *self = self.max(other);    //注意这里
    }
}

enum IpAddrKind{
    V4(u8,u8,u8,u8),
    V6(String),
}
    
fn main()
{ 
    let home = IpAddrKind::V4(127,0,0,1);
    let loopback = IpAddrKind::V6(String::from("::1"));
}

impl IpAddrKind{
    fn call(&self){
        
    }
}

enum IpAddrKind{
    V4,
    V6,
}
    
fn main()
{ 
    struct IpAddr{
        kind:IpAddrKind,
        adress:String,
    }

    let home = IpAddr{
        kind:IpAddrKind::V4,
        address:String::from("127.0.0.1"),
    }
    
    let loopback = IpAddr{
        address:IpAddrKind::V6,
        address:String::from("::1"),
    }
}

impl IpAddrKind{
    fn call(&self){
        
    }
}

enum Option<T>{
    None,
    Some<T>,
}

fn main() { 
    let x = Some(10);
    let y = 20;
    match x {
        Some(5)=>println!("5"),
        Some(y)=>println!("y = {}",y),
        _=>println!("0"),
    }
}

struct Point{
    x:i32,
    y:i32,
}

fn main() { 
    let p = Point{x:3,y:5};
    let Point{x,y} = p;
}

let var:u8 = 3;
match var{
    1=>do_something(),
    4=>do_anything(),
    other=>do_the_one_thing(),    //也可以换成其它变量
}

fn do_something(){
    
}

fn do_anything(){
    
}

fn do_the_one_thing(){
    
}

match var{
    1=>do_something(),
    4=>do_anything(),
    _=>do_the_one_thing(),    //也可以换成其它变量
}

other=>do_the_one_thing(other),

let opt:Option<String> = Some(String::from("hello world"));

match opt {
    Some(s) => println!("{}",s),
    None => println!("None"),
}

println!("{:?}",opt);

let opt:Option<String> = Some(String::from("hello world"));

match &opt {
    Some(s) => println!("{}",s); 
    None => println!("None");
}

println!("{:?}",opt);

let opt:Option<String> = Some(String::from("hello world"));

match &opt {
    Some(s) if s.len() < 5 => println!("{}",s); //match guard
    _ => println!("_");    //这里汇集了len>5和opt为None的情况，因此只能使用_
}

println!("{:?}",opt);

let max:u8;
let config = Some(3u8);
if let Some(max) = config {    //不是==号
    println!("{}",max);
}
else{
    println!("None");
}

mod mod_name;

// inline, mode {} 文件内部使用内联导入模块
// mod_name.rs 在src/model.rs寻找模块
// models/mod_name.rs 在src/models/mod_name.rs寻找模块

sc/main.rs
fn main() {
    crate::m1::m2::fun1();    //绝对路径访问方式
}

src/models.rs
mod m1{
    pub mod m2{
        pub fn fun1(){

        }
    }
}

mod x1{
    mod x2{
        fn fun2(){
            super::super::m1    //相对路径访问方式，想要返回上一级应该使用super
        }
    }
}

use std::fmt::Result;
use std::io::Result as IoResult;

let v:Vec<i32> = Vec::new();    //使用方法创建
let v:Vec<i32> = vec![1,2,3];    //使用宏创建

fn main() {
    let mut v = Vec::new();
    v.push(1);
    v.push(2);
    v.push(3);
    v.push(4);

    //let v1 = &v[2];
    let v2 = v.get(2);
    match v2 {
        Some(v2)=>println!("{:?}",v2),
        None=>println!("None"),
    }
}

//iterator
let mut v: Vec<i32> = vec![1,2];
let mut iter: std::slice::Iter<'_, i32> = v.iter();
let n1: &i32 = iter.next().unwrap();
let n2: &i32 = iter.next().unwrap();
let end: Option<&i32> = iter.next();

//len
let mut range: Range<usize> = 0..v.len();    //这里获取的是数组的下标的范围
let i1: usize = range.next().unwrap();
let n1: &i32 = &v[i1];

let mut s = String::new();

let data = "hello";
let s2 = data.to_string();
let s3 = "hello".to_string();
let s4 = String::from("hello");

let mut s = String::from("hello");
s.push_str("world");
println!("{s}");
s.push('!');
println!("{s}");

let s1 = String::from("hello");
let s2 = String::from("world");
let s3 = s1 + &s2;

println!("{s3}");

//单个unicode标量值
for c in "你好".chars(){
    println!("{c}");
}

//存储在计算机中的字节
for b in "你好".bytes(){
    println!("{b}");
}

pub struct String {
    vec: Vec<u8>,
}

scores.insert(String::from("blue"), 10);
scores.insert(String::from("red"), 50);

let vec = vec![("hello","10"),("world","50")];
let map:HashMap<_, _> = vec.into_iter().collect();

let mut scores = HashMap::new();
scores.insert(String::from("blue"), 10);

let teamname = String::from("blue");
let scores = scores.get(&teamname).copied().unwrap_or(0);

let mut scores = HashMap::new();
scores.insert(String::from("blue"), 10);

for (key,value) in &scores {
    println!("{}:{}",key,value);
}

enum Result<T,E>
{
    Ok(T),
    Err(E),
}

use std::{fs::File, io::{self, Read}};

fn read_username_from_file() -> Result<String,io::Error>{
    let username_file_result: Result<File, io::Error> = File::open("hello.txt");
    let mut username_file: File = match username_file_result {
        Ok(file)=>file,
        Err(err)=>return Err(err), //也可能从这返回
    };

    let mut username_str: String = String::new();
    match username_file.read_to_string(&mut username_str) {
        Ok(_)=>Ok(username_str),    //_可以让编译器自动推断类型
        Err(err)=>Err(err),    //没有分号，match表达式的结果就是函数返回的结果
    }
}

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

    let mut username_str: String = String::new();
    username_file_result.read_to_string(&mut username_str)?;
    Ok(username_str)
}

    let mut username_str: String = String::new();
    let mut username_file_result = File::open("hello.txt")?.read_to_string(&mut username_str)?;
   
    Ok(username_str)

fs::read_to_string("hello.txt")

fn first(arr: &[i32]) -> Option<&i32> {
   arr.get(0)?
}

fn main() {
    let s1 = Some("abcde");
    let s2 = Some(5);

    let n1: Option<&str> = None;
    let n2: Option<usize> = None;

    let o1: Result<&str, &str> = Ok("abcde");
    let o2: Result<usize, &str> = Ok(5);

    let e1: Result<&str, &str> = Err("abcde");
    let e2: Result<usize, &str> = Err("abcde");

    let fn_character_count = |s: &str| s.chars().count();

    assert_eq!(s1.map(fn_character_count), s2); // Some1 map = Some2
    assert_eq!(n1.map(fn_character_count), n2); // None1 map = None2

    assert_eq!(o1.map(fn_character_count), o2); // Ok1 map = Ok2
    assert_eq!(e1.map(fn_character_count), e2); // Err1 map = Err2
}

fn main() {
    let s = Some(10);
    let n: Option<i8> = None;

    let fn_closure = |v: i8| v + 2;
    let fn_default = || 1;

    assert_eq!(s.map_or_else(fn_default, fn_closure), 12);
    assert_eq!(n.map_or_else(fn_default, fn_closure), 1);

    let o = Ok(10);
    let e = Err(5);
    let fn_default_for_result = |v: i8| v + 1; // 闭包可以对 Err 中的值进行处理，并返回一个新值

    assert_eq!(o.map_or_else(fn_default_for_result, fn_closure), 12);
    assert_eq!(e.map_or_else(fn_default_for_result, fn_closure), 6);
}

fn main() {
    const V_DEFAULT: u32 = 1;

    let s: Result<u32, ()> = Ok(10);
    let n: Option<u32> = None;
    let fn_closure = |v: u32| v + 2;

    assert_eq!(s.map_or(V_DEFAULT, fn_closure), 12);
    assert_eq!(n.map_or(V_DEFAULT, fn_closure), V_DEFAULT);
}

use std::fmt;

// AppError 是自定义错误类型，它可以是当前包中定义的任何类型，在这里为了简化，我们使用了单元结构体作为例子。
// 为 AppError 自动派生 Debug 特征
#[derive(Debug)]
struct AppError;

// 为 AppError 实现 std::fmt::Display 特征
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "An Error Occurred, Please Try Again!") // user-facing output
    }
}

// 一个示例函数用于产生 AppError 错误
fn produce_error() -> Result<(), AppError> {
    Err(AppError)
}

fn main(){
    match produce_error() {
        Err(e) => eprintln!("{}", e),
        _ => println!("No error"),
    }

    eprintln!("{:?}", produce_error()); // Err({ file: src/main.rs, line: 17 })
}