Rust基础

//  函数名，使用冒号分隔变量名和变量类型、使用逗号分隔不同的参数
//  使用->符号来分隔参数和返回值类型
fn add(a :i8,b :i8)->i8{
    return a + b
}


fn syq(s:String){
    println!("s is {}",s)
}


fn pr(){
    println!("无输入的打印函数")
}

fn main() {

    // 1、输出函数使用
    //  不换行输出
    print!("不换行输出{}",233);
    //  换行输出
    let a = 12;
    println!("Hello, world!a is {}",a);

    // 2、无输入返回值的函数
    pr();
    // 3、有输入返回值的函数
    //  返回值赋值操作
    let c = add(a,3);
    // 变量不可修改
    // c = 4;
    //  声明可变变量

    // 4、可变变量
    let mut d = add(3, 3);
    println!("d is {}",d);
    // 修改可变变量的值
    d = 10;
    println!("change d is {}",d);
    println!("c is {}",c);

    // 5、组合数据类型
    // 元组、可包含不同的类型
    let tupa:(i8,i16,i8) = (1,2,3);
    println!("tupa.0 is {}",tupa.0);
    // 将str转为string类型
    let tupb:(i8,String) = (2,"3".to_string());
    println!("tupb.0 is {}",tupb.0);

    let tupc:(&str,i8) = ("2",3);
    println!("tupc.0 is {}",tupc.0);


    //  数组，只能包含相同类型数据、使用分号分隔类型和数组长度
    let d:[i8;5]= [1,2,3,4,5];
    println!("d.0 is {}",d[0]);

    // 6、循环结构
    let b = 5;
    //  if 语句、执行第一条符合条件的语句
    if b > 3{
        println!("b is biger than 3")

    }else if b > 4{
        println!("b is biger than 4")

    }else{
        println!("b is not biger than 3 and 4")
    }

    //  创建可变变量c
    let mut c = 5;
    //  while循环、满足条件则执行循环体
    while c != 0 {
        println!("now c is {}",c);
        // c的重复赋值、减一
        c -= 1;
    }
    
    //  声明一个数组
    let sa = [1,2,3,4];
    // for 循环一个数组
    for i in sa.iter(){
        println!("i is {}",i)
    }

    // 声明一个可变变量
    let mut cc = 0;
    // while循环、达到for循环
    while cc < 10{
        println!("cc is {}",cc);
        cc += 1
    }
    // loop 循环、死循环、可使用break来返回值
    let s2 = [1,2,3,4,5,6];
    let mut m = 0;
    let r = loop{
        let ch = s2[m];
        if ch == 5{
            break m;
        }
        m += 1;
    };
    println!("m is {}",r);

    //  7、所有权问题
    // 当为基本数据类型时、数据可进行移动和拷贝、原变量依旧可使用
    let sy1 = 1;
    let sy2 = sy1;
    println!("sy1 is {}",sy1);
    println!("sy2 is {}",sy2);
    // 当不为基本数据类型时
    let sy3 = String::from("rust");
    let sy4 = sy3;
    // sy3 数据被移动、无数据，报错：err:value borrowed here after move
    // println!("sy3 is {}",sy3);
    println!("sy4 is {}",sy4);
    //  克隆数据、不会导致原数据销毁
    let sy5  = sy4.clone();
    println!("sy5 is {}",sy5);

    // 当sy5 作为参数传入函数中时、就被移动了、sy5数据已销毁、基本数据类型不受影响
    syq(sy5);
    // println!("sy5 is {}",sy5) 报错：err:value borrowed here after move
    // 引用赋值并不会销毁源数据
    let sy6 = &sy4;
    println!("sy4 is {},sy6 is {}",sy4,sy6);

    // 引用、租借所有权，在原数据被移除所有权后，需要重新租借所有权、租借的使用权无法修改数值
    let mut sy7 = 2;
    let sy8 = &sy7;
    // println!("sy7 is {},sy8 is {}",sy7,sy8);
    // 数据引用被赋值后，可变变量不可更改值
    // sy7 = 5;
    println!("sy7 is {},sy8 is {}",sy7,sy8);

}