• 变量
    let a=123;变量声明后不能改变值,但是可以再次定义let a=456;
    let mut a=123;a=456;可变变量
    let _x=1; 未使用变量忽略使用_开头
    let (a, mut b): (bool,bool) = (true, false);相当于let a:bool=true;let must b:bool=false;
    let a: u64 = 123;64位无符号变量
  • 常量
    const MAX_POINTS: u32 = 100_000;Rust 常量的命名约定是全部字母都使用大写,并使用下划线分隔单词,另外对数字字面量可插入下划线以提高可读性

    基础类型

  • 数据类型
  1. 整形
    位长度 有符号 无符号
    8-bit i8 u8
    16-bit i16 u16
    32-bit i32 默认 u32
    64-bit i64 u64
    128-bit i128 u128
    arch 可变类型取决于平台 isize usize
    数字字面量示例
    十进制98_222
    十六进制0xff
    八进制0o77
    二进制0b1111_0000
    字节u8b'A'
  2. 浮点型 f32 f64(默认)
  3. 字符型char 占用4个字节,包含unnicode里面中文和emoji
    let a='中';只能单引号
  4. 布尔型 bool,1字节, 只有true flase
  5. 单元类型 ()比如main返回值就是此类型
  • 序列 1..5不包含5,1..=5包含5

    for i in 1..=5 {
      println!("{}",i);
    }
    for i in 'a'..='z' {
      println!("{}",i);
    }
  • 注释
    // 和 /* 内容注释*/
    /// 注释

  • 表达式
    表达式不能有分号,可以在函数内返回表达式,有分号是语句,表达式必有返回值,如果不想可以返回()

    let y = {
          let x = 3;
          x + 1
      };
    fn add_with_extra(x: i32, y: i32) -> i32 {
      let x = x + 1; // 语句
      let y = y + 5; // 语句
      x + y // 表达式
    }    
  • 函数,->是返回类型
    命名使用a_b_c小写,定义位置随意
    返回值没有时候返回类型()

    fn add(a: i32, b: i32) -> i32 {
      return a + b;
    }
    fn add(i: i32, j: i32) -> i32 {
     i + j
    }
  • 引用与租借
    引用符号&s 可变引用 &mut 解析引用*s
    同一作用域,特定数据只能有一个可变引用;
    可变引用与不可变引用不能同时存在

    let mut s = String::from("hello");
    {
      let r1 = &mut s;
    } // r1 在这里离开了作用域,所以我们完全可以创建一个新的引用
    let r2 = &mut s;
    
    let mut s = String::from("hello");
    
      let r1 = &s;
      let r2 = &s;
      println!("{} and {}", r1, r2);
      // 新编译器中,r1,r2作用域在这里结束
    
      let r3 = &mut s;
      println!("{}", r3);

    #![allow(unused_variables)] 属性标记,表示忽略未使用的变量,不要抛出 warning 警告
    #[allow(dead_code)] 忽略属性,结构体赋值未使用
    #[derive(Debug)] 自动为结构体、枚举或者联合体实现 Debug 特征
    !类型不会返回()属于无返回类型

    复合类型

  • 元组
    长度顺序固定
    let t: (i32, f64, u8) = (500, 6.4, 1);
    println!(“{:?}”, t);// (500, 6.4, 1)
    println!(“{:?}”, t.0); //500
    let (x, y, z) = t;//匹配方式解析元组
    println!(“{}, {}, {}”, x, y, z);

  • 数组
    array是长度固定,类型相同
    Vector动态数组

    let a = [1, 2, 3, 4, 5];
    let month = ["a","b","c"];
    let a: [i32; 5] = [1, 2, 3, 4, 5]; 类型|长度
    let arr=[3;5]; 重复5次3  [3, 3, 3, 3, 3]
    let a1 = a[0];
    数组切片 &[1,2]
    let a: [i32; 5] = [1, 2, 3, 4, 5];
    let slice: &[i32] = &a[1..3];
    assert_eq!(slice, &[2, 3]);
  • 结构体

    struct User {
      active: bool,
      username: String,
      email: String,
      sign_in_count: u64,
    }
    let mut user1 = User {
          email: String::from("someone@example.com"),
          username: String::from("someusername123"),
          active: true,
          sign_in_count: 1,
      };
      user1.username = String::from("anotheremail@example.com");
    println!("{:#?}", user1);//{:?}不换行,下面是输出
    dbg!(&user1); 打印
    User {
      active: true,
      username: "anotheremail@example.com",
      email: "someone@example.com",
      sign_in_count: 1,
    }
    • 元祖结构体
      struct Color(i32, i32, i32);
      let black = Color(0, 0, 0);
  • 字符串
    字符串切片,数组也支持切片

      let s = String::from("hello world");
      let hello = &s[0..5];
      let world = &s[6..11];
      let world = &s[6..s.len()]; //包含最后一个 s.len()
      let world = &s[6..];//等价上面到结束
      let world = &s[..];//等价[0..s.len]
      println!("{} {}", hello, world);//hello world,类型&str
      //中文是三个字节需要特别注意,包括unicode
      let a = [1, 2, 3, 4, 5];
      let slice = &a[1..3];
      println!("{:?}", slice);//输出[2,3],数组切片 &[i32]

    字符串切片类型,是不可变类型&str,属于基本类型

    let s="字符串"; 和下面等价
    let x: &str = "hello, world";
      let y = x;
      println!("{},{}",x,y);

    可变类型String,动态字符串,使用&引用,是复合类型

    let s = String::from("hello world");
    let s1:&str = s.as_str();//转换成&str
    let s1:&str = &s[..]//转换&str
    let s3:String = s2.to_string();//&str转换String
    //--------
    let mut hello = String::from("你好");//字符串操作需要可变
    let s1 = String::from("hello");
    let s2 = s1.clone(); //直接赋值会报错
    s.push_str("rust");//追加
    s.insert(0, '中');插入单个
    s.insert_str(3, "世");插入多个,但是012位置是中,插入会报错
    let s1 = s.replace("中","我"); 替换支持&str String
    s.replace_range(0..3,"中国"); 替换只支持String,中文0..3是中字
    let s1=s.pop(); 删除最后一个并返回 String
    let s1=s.remove(3); 删除返回的字符 String
    s.truncate(3); 删除位置到结尾字符,无返回 String
    s.clear(); s.truncate(0);清空字符串,无返回 String
    //======字符串链接必须右边是&str类型,返回String
    let s="Hello World";
      let s1 = String::from("中国");
      let s2 = String::from("world!");
      let s3 = s1.clone()+s;
      let  s4 = s1.clone()+&s2;
      let  s5 = s1+"中国";
      println!("{},{},{}",s3,s4,s5);
      //另一方法链接format!
       let s1 = "hello";
      let s2 = String::from("rust");
      let s = format!("{} {}!", s1, s2);
      println!("{}", s);
    let quotes = r#"And then I said: "There is no escape!""#;//r#"原始字符串字面量方法"#;#可以任意多个
    let s = r###"A string with "# in it. And even "##!"###;
    let raw_str = r"Escapes don't work here: \x3F \u{211D}";//r""保持不转义
  • 枚举类型
    任何类型的数据都可以放入枚举成员中

    enum Book {
      Papery(u32),
      Electronic(String),
    }
    let m=Book::Papery(12);
    enum Book {
      Papery { index: u32 },
      Electronic { url: String },
    }

    流程控制

  • 条件语句,支持多个else if

    let a=2;
    let b=if a > 0 { 1 } else { -1 };
    println!("{}",b); //1
  • 循环只有while for loop三种
    continue;跳过档次循环
    break; 可以直接跳出当前整个循环

    let a = [10, 20, 30, 40, 50];
      for i in a {
          println!("值为 : {}", i);
      }
    for i in 1..=5 {
          println!("{}", i);
      }
    let mut i = 0;
    while i < 10 {
      i += 1;
    }
    
    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;
      }
  • 访问权限公有pub私有不加修饰默认就是

  • IO操作

    `let args = std::env::args();`获取参数
    `use std::io::stdin;`命令行输入
    `let mut str_buf = String::new();`
    `stdin().read_line(&mut str_buf).expect("Failed to read line.");`读取
    `use std::fs;`
    `let text = fs::read_to_string("D:\\text.txt").unwrap();`字符串读取文件
    `let content = fs::read("D:\\text.txt").unwrap();` 二进制读取文件
    fs::write("D:\\text.txt", "FROM RUST PROGRAM") .unwrap();写入文件
作者:Yoby  创建时间:2020-07-25 14:49
最后编辑:Yoby  更新时间:2025-07-08 07:15
上一篇:
下一篇: