一 变量

1 不可变的变量

提示：如果直接使用let关键字定义变量，那么此变量不可变。并且默认情况下，Rust中的变量是不可变的。

fn main() {
    let x = 6;
    println!("变量的值=={}", x);
    x=7;
    println!("重新赋值后的变量的值=={}", x);
}

上面的代码对变量x重新赋值，就会编译报错。

2 可变的变量

如果要想变量可变，那么需要加上mut关键字。

fn main() {
    let mut x = 6;
    println!("变量的值=={}", x);
    x=7;
    println!("重新赋值后的变量的值=={}", x);
}

3 变量和常量

对于Rust变量来说，默认是不可变的，那么是否可以说是常量呢？
答案是：不能。
1 变量默认是不变的，但是常量总是不变的，并且不能对常量使用let关键字。
2 常量可以在任何作用域声明
3 常量只能用在常量表达式，不能作为函数调用的结果

4 隐藏

fn main() {
    let x = 6;
    println!("变量的值=={}", x);
    let x=x+1;
    println!("重新赋值后的变量的值=={}", x);//7
    let x=x*2;
    println!("重新赋值后的变量的值=={}", x);//14
}

上述代码定义了变量x。默认是不可变的，当定义相同名称的变量的时候，会隐藏原来的变量。执行x=x+1 是相当于隐藏的值+1进行新的变量x的赋值操作。

隐藏和可变的区别是隐藏会创建新的变量

提示：以下是本篇文章正文内容，下面案例可供参考

二 数据类型

Rust中主要有四种标量类型。分别是：整数、浮点数、布尔、字符串

1.整数

Arch依赖于计算机架构。32位计算机就是32位，64位计算机则是64位

fn main() {
    let x:i8 = -129;
    println!("整数的值=={}",x);
}

上面代码运行则会报错：因为i8的范围是-127到128

  = note: `#[deny(overflowing_literals)]` on by default
  = note: the literal `129` does not fit into the type `i8` whose range is `-128..=127`
  = help: consider using the type `i16` instead

整数的进制表示

fn main() {
    let x=10_000;
    let y=0o77;
    let z=0b1111_0000;
    let a=0xff;
    let b=b'A';
    println!("基于10进制的值=={}",x); //10000
    println!("基于10进制的值=={}",y); //63
    println!("基于10进制的值=={}",z); //240
    println!("基于10进制的值=={}",a); //255
    println!("基于10进制的值=={}",b); //65
}

整数的隐式转换

as运算符

上面的代码1是i32位的，现在用i64来接受，那么会显示编译错误。此时就可以使用as

fn main() {
    let b: i64 = 1i32 as i64;
    println!("x的值=={}", b);
}

2.布尔型

这个和所有的变成语言一致。

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

3.字符类型

fn main() {
   let x='A';
   let y='好';
    println!("变量的值=={}",x);
    println!("变量的值=={}",y);
}

4.复合类型

1.元组

元组的定义:
let 变量名称:(数据类型1，数据类型2，数据类型3 …数据类型n)=(元素1，元素2，元素3…元素n)

let tup:(i32,i32,i32)=(500,777,800);

获取元组元素的值：

fn main() {
   let tup:(i32,i32,i32)=(500,777,800);
    let (a,b,c)=tup;
    
    println!("打印元组的数据=={}",a);//500
    println!("打印元组的数据=={}",b);//777
    println!("打印元组的数据=={}",c);//800
}

除了上述获取元素之外，也可以通过索引获取

fn main() {
   let tup:(i32,i32,i32)=(500,777,800);
    println!("打印元组的数据=={}",tup.1);//777
}

2.数组

数组的定义
let 数组名称：[元素数据类型；数组长度]=[数组中的元素]

let a:[i32;6]=[1,3,5,7,9,10];

当然也可以简化：

let a=[1,3,5,7,9,10];

数组元素的获取

fn main() {
   let a=[1,3,5,7,9,10];
    println!("数组元素的获取=={}",a[3]);
    println!("数组元素的获取=={}",a[10]);
}

下面的会有索引越界异常

三 函数

函数的定义

fn 函数名称（参数名称：参数类型）->返回值类型{
}

1 无参无返回值的函数

fn info(){
    println!("this is a function!");
}

上面的代码定义了一个没有参数和返回值的函数，功能是打印一句话。
调用如下：

fn main() {
   info();
}

2 有参无返回值的函数

下面定义了函数，一个参数，参数类型是i32.

fn main() {
   info(45);
}

fn info(x:i32){
    println!("this is a function!,参数的值是=={}",x);
}

有多个参数的时候，使用逗号隔开

fn info(x:i32,y:i32){
    println!("this is a function!,参数的值是=={}",x);
    println!("this is a function!,参数的值是=={}",y);
}

3 语句和表达式

1. 语句是产生一些列运算但是不产生返回值的指令
2. 表达式计算并产生一个之

如下面的let x= 5u32就是一个语句。

fn main() {
    /** 这是一个语句 */
    let x = 5u32;
}

因为上面的正是一个语句，所以不产生返回值，那么下面的语句是错误的。

 let x=(let y=6);

下面代码的执行是x=5,然后执行表达式y。x_squared =25，x_cube =125.最后 x_cube + x_squared + x=155.然后返回改值给y。所以y=155.
表达式z中由于是一个语句，所以不产生返回值，那么就是（）

fn main() {
    let x = 5u32;

    let y = {
        let x_squared = x * x;
        let x_cube = x_squared * x;
        x_cube + x_squared + x
    };

    let z = {
        2 * x;
    };

    let m={};

    println!("x is {:?}", x);//x is 5
    println!("y is {:?}", y);//y is 155
    println!("z is {:?}", z);//z is ()
    println!("m is {:?}", m);//m is ()
}

4 无参有返回值的函数

在rust中，返回值是表达式，因此不能使用分号结束。

fn main() {
    let i = info();
    println!("i的值是=={}",i);//i的值是==5
}


fn info()->i32{
    5
}

5 有参有返回值的函数

fn main() {
    let i = info(44);
    println!("i的值是=={}",i);//i的值是==44
}


fn info(x:i32)->i32{
    x
}

四 if表达式

fn main() {
    let n = 5;

    if n < 0 {
        print!("{} is negative", n);
    } else if n > 0 {
        print!("{} is positive", n);
    } else {
        print!("{} is zero", n);
    }
}

上面的代码，肯定执行else if中的代码。
在let中也可以使用if.因为if是表达式，所以有返回值的

fn main() {
    let n = 5;

    if n < 0 {
        print!("{} is negative", n);
    } else if n > 0 {
        print!("{} is positive", n);
    } else {
        print!("{} is zero", n);
    }

    let big_n =
        if n < 10 && n > -10 {
            println!(", and is a small number, increase ten-fold");

            // This expression returns an `i32`.
            10 * n
        } else {
            println!(", and is a big number, halve the number");
            n / 2

        };


    println!("{} -> {}", n, big_n);
}

执行结果如下：

5 is positive, and is a small number, increase ten-fold
5 -> 50

五 循环

1 loop

1 基本语法

loop{
//执行的代码
}

fn main() {
    let mut count = 0u32;
    loop {
        count += 1;
        if count == 3 {
            println!("数值是3");
            continue;
        }

        println!("{}", count);
        if count == 6 {
            println!("数值是6");
            break;
        }
    }
}

2 处理嵌套

fn main() {
    'outer: loop {
        println!("Entered the outer loop");
        'inner: loop {
            println!("Entered the inner loop");
            break 'outer;
        }
        println!("This point will never be reached");
    }

    println!("Exited the outer loop");
}

3 从loop中返回

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };
    assert_eq!(result, 20);
}

result的结果是20

2 while

while循环和大多数语言的语法基本一致，下面是一个例子

fn main() {
    let mut n = 1;
    while n < 101 {
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }
        // Increment counter
        n += 1;
    }
   
}

3 for

for循环的基本形式如下：

for item in container{
  //…
}

1 匿名循环

使用场景是不需要使用迭代元素的值，那么变量可以使用_替代。

fn main() {
    for _ in 0..10  {
        println!("xxx")
    }
}

2 基本循环

fn main() {
    for number in (1..4).rev()  {
        println!("number的值=={}",number)// 3 2 1
    }
}

3 数组的迭代

fn main() {
    let array=[1,2,3,4,5];
    for item in array  {
        println!("迭代数组元素=={}",item)
    }
}

操作索引获取元素

fn main() {
    let array=[1,2,3,4,5];
    for item in 0..array.len()  {
        println!("迭代数组元素=={}",array[item])
    }
}

六 数字的运算

1 不同类型的数据比较

上面直接编译报错。因此不同数据类型不能直接比较大小。使用as转换。

fn main() {
    let a: i32 = 10;
    let b: u16 = 100;
    if a < b as i32 {
        println!("xxxxxxxxxxxx")
    }
}