Rust - 安装环境、基本类型、流程控制、函数、模块、泛型、所有权

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

source $HOME/.cargo/env //设置环境变量

rustc --version //查看安装版本

cargo run [项目名称]
cargo build 

.
|-- Cargo.lock
|-- Cargo.toml
|-- src
|   `-- main.rs
`-- target
    |-- CACHEDIR.TAG
    `-- debug
        |-- build
        |-- deps
        |   |-- stark-2c1445affc8ccd97
        |   `-- stark-2c1445affc8ccd97.d
        |-- examples
        |-- incremental
        |-- stark
        `-- stark.d

 fn main() {
    let number :i8 = 32;
    println!("{}",number);
}

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
}

fn main() {
    let t = true;
    let f: bool = false;
}

fn main() {
    let a: i32= 10;
    let b = 'A';
    //创建一个元组
    let mytuple:(i32,char) = (a,b);
    // 从元组中读取一个值
    println!("{},{}",mytuple.0,mytuple.1);
    //解封装
    let(c , d) = mytuple;
    println!(" {} , {} ",c , d);
}

fn main() {
    //初始化数组
    let myarray: [u32;5] = [1,2,3,4,5];
    println!("myarray[1] = {}",myarray[1]);

    //数组越界
    //let index = "5".parse::<usize>().unwrap();
    //println!("myarray[5]={}",myarray[index]);

    let mut mybuffer: [u32;32 * 1024] = [10;32*1024];
    println!("mybuffer[1024] = {}", mybuffer[1024]);

    //修改数组的值
    mybuffer[1024] = 13;
    println!("mybuffer[1024] = {}", mybuffer[1024]);
}

fn main() {
    //切片可以切数组
    let myarray: [u32;5] = [1,2,3,4,5];
    let slice = &myarray[0..3];
    println!("slice[0] = {}, slice.length = {} ",slice[0],slice.len());
    //切片还可以切字符串
    
    let s = String::from("broadcast");
    let part1 = &s[0..5];
    let part2 = &s[5..9];
    println!("{}={}+{}", s, part1, part2);
}

//元组结构
struct Pair(i32,f32);

//经典的C结构
struct Peison {
    name:String,
    age:u8
}

fn main() {
 let pair = Pair(10,4.2);
 let person = Peison{
     name: String::from("stark"),
     age:32
 };

 println!("pair.0 = {}",pair.0);
 println!("person.name = {}, person.age = {}",person.name,person.age);
}

#[derive(Debug)]


struct Peison {
    name:String,
    age:u8
}

fn main() {
 let person = Peison {
     name: String::from("stark"),
     age:32
 };

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

}

#[derive(Debug)]

enum IPAddr {
    IPv4(u8,u8,u8,u8),
    IPv6(u8,u8,u8,u8,u8,u8,u8,u8,u8,u8,u8,u8),
}

fn main() {
    let localhost :IPAddr = IPAddr::IPv4(127,0,0,1);
    match localhost {
        IPAddr::IPv4(a,b,c,d) => {
            println!("{},{},{},{}",a,b,c,d);
        }
        _ => {}
    }
}

fn main() {
    let number = 3;
    if number < 5 {
        println!("条件为 true");
    } else {
        println!("条件为 false");
    }
}

fn main() {
    let s = ['R', 'U', 'N', 'O', 'O', 'B'];
    let mut i = 0;
    loop {
        let ch = s[i];
        if ch == 'O' {
            break;
        }
        println!("\'{}\'", ch);
        i += 1;
    }
}

fn main() {
    for i in 0..5 {
        println!("i value is {}",i);
    }
    
    println!("-------------");    

    for i in 0..=5 {
        println!("i value is {}",i);
    }
}

fn main() {
    let mut myarray = [1,2,3];
    for i in myarray.iter(){
        println!("i value is {} ",i);
    }

    for  i in myarray.iter_mut() {
        *i *= 2;
    }

    for i in myarray.iter(){
        println!("i value is {} ",i);
    }
}

fn main() {
    let myarray = ["a","b","c"];
    for i in myarray.iter(){
        println!("i value is {} ",i);
    }
}

let x = 5;

match x {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    4 => println!("four"),
    5 => println!("five"),
    _ => println!("something else"),
}

fn sum_number(n:u64) -> u64 {
    if n < 2 {
        n
    }else{
        n+1
    }
}

fn main() {
    println!("sumNumber is {}",sum_number(10))
}

fn main() {
    let time3 = |n:u32| -> u32 { n * 3 };
    println!("time3 is {}",time3(10));
}

use std::thread;
fn main() {
    let hi = "hi,stark";
    thread::spawn(move || {
        println!("stark value {}",hi);
    }).join();
}

fn action(method:fn(u32,u32)->u32,a: u32,b: u32) -> u32 {
    method(a,b);
}

fn add(a:u32,b:u32) ->  u32 {
    a + b 
}

fn sub(a:u32,b:u32) ->  u32 {
    a - b 
}

fn main() {
  println!("{}",action(add,10,20))
}

[root@b0b5a9371ce4 stark]# tree
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

mod mod1 {
    pub const MESSAGE :&str = "Hello,world";
}
fn main() {
  println!("{}",mod1::MESSAGE)
}

pub fn sum_number<T: std::ops::Add<Output = T>>(a:T,b:T) -> T {
    return a+b;
}

struct Point<T> {
    x:T,
    y:T
}

struct Line<T> {
    x: Point<T>,
    y: Point<T>
}

fn main() {
  println!("{}",cc::MESSAGE);
  println!("{}",cc::sum_number(10,20));

  let pointx = Point{x:0,y:0};
  let pointy = Point{x:10,y:10};
  let line = Line {x:pointx, y:pointy};

  println!("{},{},{}",line.x.x,line.x.y,line.y.x);
}

fn main() {
    let s2:String;
    {
        let s1 = String::from("Hello,world");
        s2 = s1;
        //println!("s1 value {}",s1);
        //value borrowed here after move
    }
    println!("s2 value {}",s2);
}

fn echo(s:String){
    println!("{}",s);
}
fn main() {
    let s = String::from("hello.world");
    echo(s);
    println!("{}",s);
}

fn echo(s:&String){
    println!("{}",s);
}
fn main() {
    let s = String::from("hello.world");
    echo(&s);
    println!("{}",s);
}

fn change(s: &mut String){
    s.push_str("chenged!")
}
fn main() {
    // 要借用的变量s也需要是可变的变量
    let mut s = String::from("hello.world");
    change(&mut s);
    println!("{}",s);
}

fn main() {
    let mut s = String::from("hello.world");
    let s1_ref = &mut s;
    let s2_ref = &mut s;
    println!("{}",s1_ref);
    println!("{}",s2_ref);
}

fn bigger (str1:&str,str2:&str) -> &str {
    if str1 > str2 {
        str1
    }else{
        str2
    }
}
fn main() {
    println!("{}",bigger("a","b"));
}

#[derive(Debug)]

struct Person {
    name: String
}

fn main() {
   let p = Person{ name:String::from("zhangyu") };
   println!("{:?}",p );
}