基础知识

基础类型

序列 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();写入文件