03变量数据类型控制流

一.变量与可变性(20221215)

• 1.不可变变量let x=1; (相当于kotlin的val)
• 2.可变变量 let mut x=1; x=2//修改x值 (相当于kotlin的var)
• 3.shadow(变量覆盖)

let space="space";
let space=space.len();//同名变量遮蔽前一个变量

• 4.const 常量
  • Rust 的常量必须声明类型，且值是不可变的，可以在任何作用域声明
  • 常量编译器会内联
  • 例子const MAX_NUM:usize=1000;
• 5.static 全局常量
  • 全局唯一实例
  • static 和 const的区别
    • 1.static不会被内联.(基本跟c里声明的static变量对标)
    • 2.static可以是 mut的(可变的):static mut LEVELS: u32 = 0;
    • 3.常量：允许使用它们的时候对数据进行复制

二.数据类型

标量类型

• 定义：一个标量类型代表一个单独的值
• 四个主要标量类型
  • 1.整数
    • 无符号：u8、u16、u32、u64、u128、usize （usize和处理器架构相关联），取值范围[0 ,2^n-1]
    • 有符号：i8、i16、i32、i64、i128、isize （isize和处理器架构相关联），取值范围[-2^(n-1) ,2^(n-1)-1]
    • 字面值书写
      • Decimal(10进制)：使用下划线分隔符方便读数 (eg：98_222)
      • Hex(16进制)：0x开头 (eg：0o77、0xFF)
      • Octal(8进制)：0o开头 (eg：0o77)
      • Binary(2进制)：0b开头 (eg：0b1111_0000)
      • Byte(字节)：仅限于u8类型，b开头 (eg：0b1111_0000)
      • 除了byte类型外，所有的数值类型都可以使用类型后缀 (eg：57u8、-32i32)
  • 2.浮点
    • IEEE-754标准
    • 两种类型：f32(单精度)、f64(默认、双精度)
  • 3.布尔：true、false值，占用一个字节
  • 4.字符(char)
    • 字面值用单引号
    • 占用4个字节
    • 是Unicode标量值 (标量范围：[U+0000,U+D7FF], [U+E000,U+10FFFF])

复合类型

• 定义：复合类型可以将多个值放在一个类型里
• 2种基础的复合类型
  • 1.Tuple
    • tuple可将多种类型的多个值放在一个类型里
    • tuple的长度是固定的（声明后就无法改变）
    • 创建tuple：let tup:(i32, f64, u8) = (500, 6.4 1)
    • 获取tuple元素
      • 1.模式匹配解构(destructure)：let ( x, y, z) = tup;
      • 2.索引访问

        let tup:(i32, f64, u8)  = (500, 6.4 1);
        println!("t:{},{},{}",t.0,t.1,t.2);
      

  • 2.数组
    • 数组的每个元素的类型必须相同,数组的长度不可变
    • Rust 的数组分配在栈上(stack)单个块内存而不是堆(heap)上
    • 数组的声明
      • 1.自动推导：let a=[1,2,3,4,5];
      • 2.声明数组长度并指定值填充：let array=[value; len]. （eg: let a=[3; 5];//等于[3,3,3,3,3]）
      • 3.声明指明类型和长度：let array[type, len]=[…..]. （eg: let a[i32,5]=[1,2,3,4,5];）

三.函数和注释

• 命名规范： snake case（单词字母小写单词之间下划线分隔）
• 函数声明：
  • parameter：(p1:type[, p2:type2….])
  • return：func([p1:type, p2:type2....])-> type

    //1.函数返回值不写return
    fn five() -> i32 {
        5//有点类似java、kotlin的lambada返回
    }
    //2.典型的c系return
    fn plus_one(x: i32) -> i32{
        return x + 1;
    }
  

• 表达式和语句
  • 表达式
    • Rust 是一门基于表达式（expressionbased）的语言 (跟kolin差不多(if-else、try-catch可以返回值))
    • 表达式可返回值
    • 表达式除了大括号不以分号结尾

      //1.表达式可以是语句的一部分
      let y=5+1;//5+1是表达，是let语句的一部分
    
      //2.大括号{}也是一个表达式（后面必须分号结尾）
      let y = {
          let x = 3;
          x + 1//这里没加分号，所以是返回值
      };//这里必须有分号
    

    • 函数调用、宏调用是一个表达式
  • 语句：语句没有返回值（以分号结尾）

    let是绑定变量语句let y=6; //但不能let x = (let y = 6),在c里则可以int x=y=6(c的赋值语句会返回所赋的值)
  

• 注释
  • 典型的类C注释
  • 文档注释

四.控制流(20221215)

• if-else：if语句是一个表达式 (跟kotlin一样它可以有返回值)

let number = if condition { 5 } else { 6 };//分号必须

• 循环
  • loop
    • loop是表达式(可以有返回值)

      let result = loop {
          counter += 1;
          if counter == 10 {
              break counter * 2;
          }
      };//分号必须
    

    • 嵌套循环和标签：在处理嵌套循环的时候可以 break 或 continue 外层循环。

      'outer: loop {
          println!("Entered the outer loop");
    
          'inner: loop {
              println!("Entered the inner loop");
              // 这只是中断内部的循环
              //break;
              // 这会中断外层循环
              break 'outer;
          }
          println!("This point will never be reached");
      }
    

  • while

    while condition{
        //do somthing
    }
  

  • for
    • 1.常规写法

      let arr = [1, 2, 3];
      for (let i = 0; i < arr.length; i++) {
          console.log(arr[i]);
      }
    

    • 2.迭代器

      //1.
      for x in values{
          println!("x={}",x);
      }
      //2.
      for x in values.iter(){
          println!("x={}",x);
      }
    

    • 3.range

      //1.
      for x in (1 .. 4){//产数[1,4)数字
      }
      //2.
      for x in (1 .. 4).rev(){//产数[1,4)数字并反转
      }
    

脑图