【rust学习】rust基础知识清单详情（全）

模        块	问题	答案
安装	如何安装rust	1.linux  mac安装rust     1. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh     2. 执行  rustc  -v  查看是否安装成功 和 版本
	环境搭建	1.如何用命令新建项目   cargo new  project 2.如何构建项目   1.cargo build    2.cargo run
cargo教程	cargo的作用	1.项目管理：通过cargo 构建 运行 测试项目   1.允许开发者配置构建选项 如编译器选项，特性 和 目标平台   2.通过 cargo new命令快速创建项目   3.通过 cargo test 命令来运行项目的单元测试   4.通过 cargo publish 将库发布到 crates.io 上   5.只从跨平台构建 2.包管理：通过在项目中引入第三方依赖项   1.通过cargo.toml 文件管理依赖项   2.允许开发者搜索 添加 管理 第三方库
输出到命令行	println!()用法	1.println!("a is {}",a);   {}是占位符  2.如果想把a输出两遍，如何输出     println!("a is {0}, a again is {0}",a )
基础语法	如何声明变量	1.rust是强类型语言 2.通过let 关键字 声明    let a = 123; 3.声明后 a的值不可改变 ，如果想a的值可以改变需要用 let mut a = 123；a=456
	常量与不可变变量的区别	1.let a = 123;    let a = 456;   以上程序合法 2.const a : i32 =123;    let a = 456;   以上程序不合法
	重影 是什么	变量的名称可以被重新使用      let x= 5   let x = x + 1   let x = x * 2      x = 12
	重影和赋值的区别	1.重影：用同一个名字重新代表另一个变量实体 类型，可变属性，值都可以改变 2.可变变量赋值：仅仅值能改变    let mut s = "123"   s = s.len()   以上程序会报错，因为s是字符传类型的，不能赋值给整型
rust的数据类型	rust的整型数据类型有哪些	i8  u8 i16 u16 i32  u32 i64  u64 i128  u128 isize  usize
	isize和usize的解释及用法	1.解释   1.这两个数据类型可以存储数据的长度取决于所处平台。如32位架构的 处理器则存储32位的整型   2.用法   1.数组索引      1.数组索引通常用usize类型          let array: [i32; 5] = [1,2,3,4,5]   2.指针运算   3.集合大小   4.内存地址
	浮点类型	1.f32 表示32位浮点数，  f64表示64位浮点数 2.现代计算器对两个浮点类型的处理速度基本相同，但是64位浮点数精度更高
	数学运算	let sum = 5 + 10; // 加  let difference = 95.5 - 4.3; // 减  let product = 4 * 30; // 乘  let quotient = 56.7 / 32.2; // 除  let remainder = 43 % 5; // 求余
	字符型	1.字符类型用 char 表示 2.char类型大小位4字节（单个char类型变量占用4字节，不是字符串）    如果一个字符 串是 hello， 那么它包含5个字符，因此会占用 5 * 4 = 20个字节空间 3.用法   1.声明类型(用单引号)        let letter = 'A'   2.char类型和字符串类型是不一样的     1.单个字符  let c:char = 'a' //单个字符     2.字符串切片 let s: &str = "hello" //字符串切片     3.可变字符串  let string: String = String::from("world") //可变字符串   3.char转换为整数类型      let char = 'A'      let int_vlaue = ch as u32
	复合类型	1.元组用()包含一组数据    1.定义元组  let  tuple_example = (10, "hello", 3.14)   2.访问元组中元素  let first = tuple_example.0   3.解构元组      1.let (x,y,z) = tumple         println !("{} {} {}",x,y,z) 2.数组用[]包含相同数据    1.定义数组 let a =[1,2,3,4,5]    2.访问数组元素 let first = a[0]    3.定义可变数组 let mut a = [1,2,3]
	rust注释	代码注释   1. /**/    2.// 文档注释   ///
函数	定义函数	1.定义函数使用fn关键字。  2.函数可以有参数 也可以没有 3.函数可以有返回值 也可以不返回值 fn function_name(parameters) -> return_type {     //函数体     //最后一个表达式通常是返回值（如果没有分号） }
	不带参数的函数	fn main() {       say_hello() } fn say_hello() {      println!("hello,world"); }
	带参数的函数	fn main() {     let name = "Alice";     greet(name); } fn greet(name: &str) {     println!("Hello, {}!", name); }
	返回值的函数	fn main() {     let result = add(5, 3);     println!("The result is {}", result); } fn add(x: i32, y: i32) -> i32 {     x + y // 这里没有分号，所以这是返回值 }
	函数中的表达式	1.表达式是什么     1.表达式是计算某个值的代码片段      2.表达式不以分号（;）结束     3.如  x+1 就是表达式 2.举例： fn calculate(x: i32, y: i32) -> i32 {     let z = x * y;     z + 10  // 这里是返回值 }
	控制流	1.函数中可以使用 if  loop for  while等循环 fn main() {     let number = 6;     if number % 4 == 0 {         println!("number is divisible by 4");     } else if number % 3 == 0 {         println!("number is divisible by 3");     } else if number % 2 == 0 {         println!("number is divisible by 2");     } else {         println!("number is not divisible by 4, 3, or 2");     } }
	函数中使用闭包	fn main() {     let plus_one = |x: i32| -> i32 { x + 1 };     let result = plus_one(5);     println!("The result is {}", result); }
	条件语句	1.if语句 if number < 5 { } else { } rust中条件表达式必须是bool类型   let number = 3;   if number {}    会报错 if <condition> {block 1} else { block 2 }  block1和block2是函数体表达式 let number = if a > 3 { 0 } else { 1 } 2.if let语句：用于处理模式匹配，它允许你将一个特定的模式与一个值进行比较，如果匹配，则执行对应的代码块 let some_value = Some(3); if let Some(3) = some_value {     println!("three"); } else {     println!("not three"); }
循环	rust循环	1.while循环     1.while number != 4 {}    2. while i < 10 {           i += 1;       } 2.for循环    let a = [10,20,30,40]    for i in a.iter(){       println !("值为：{}",i)     }    //通过下标访问数组    for i in 0..5 {      println!("a[{}] = {}",i,a[i])    } 3. loop循环    1.无限循环     2.loop {}  会一直执行 直到遇到break      let mut counter = 0;     loop {         counter += 1;         println!("Counter: {}", counter);         if counter == 10 {             break;         }     }
迭代器	迭代器	1.高效便利数据的方式 2.不需要管理或者循环索引 3.迭代过程中不能修改元素
	如何创建迭代器	1.创建借用迭代器      let  vec = vec![1,2,3.4]      let  iter = vec.iter(); 2.创建可变借用迭代器（允许在遍历过程中修改集合元素 ）      let mut vec = vec![1,2,3,4,5]      let iter_mut = vec.iter_mut();      for num in iter_mut {         *num *= 2; //修改每个元素      } 3.创建所有权迭代器     let vec = vec![1,2,3,4.5]     let into_iter = vec.into_iter();     for num in iter {         println!("{}",num);     }     // 下面的代码会导致编译错误，因为 `vec` 已经被 `into_iter` 消耗了     // println!("{:?}", vec); // 编译错误：borrow of moved value
	常见的迭代器方法	1.使用map和filter   fn main() {     let numbers = vec![1, 2, 3, 4, 5];     // 创建一个迭代器，对每个元素乘以 2     let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();  //collect：将迭代器中的元素收集到一个集合中     // 创建一个迭代器，筛选出偶数     let even_numbers: Vec<i32> = numbers.into_iter().filter(|x| x % 2 == 0).collect();     println!("Doubled: {:?}", doubled);     println!("Even numbers: {:?}", even_numbers);   } 2.使用fold计算总和 fn main() {     let numbers = vec![1, 2, 3, 4, 5];     // 使用 fold 计算总和     let sum: i32 = numbers.iter().fold(0, |acc, &x| acc + x);  //fold：将迭代器中的元素累积成一个单一的值     println!("Sum: {}", sum); } 3.迭代器的链式调用 fn main() {     let numbers = vec![1, 2, 3, 4, 5];     // 链式调用：筛选出偶数，然后对每个元素乘以 2，最后收集到一个 Vec 中     let result: Vec<i32> = numbers.into_iter()                                   .filter(|x| x % 2 == 0)                                   .map(|x| x * 2)                                   .collect();     println!("Result: {:?}", result); }
闭包	闭包定义 声明 使用	1.闭包是什么     1.闭包允许在其定义的作用域之外访问变量  2.闭包如何声明     let a = | 传递给闭包的参数 | -> 闭包返回的类型 {         闭包的实现     } 3.如何调用闭包    像调用函数一样被调用 let result = 函数名(参数1，参数2) 4.闭包可以使用闭包外的环境变量     let x = 5;     let square = |num| num * x     println !("{}",square(3))  //输出15 5.获取所有权：获取到外部变量的使用权后，闭包可以访问该变量，外部不能访问   let s = String::from("hello")   let print_s = move || println !("{}",s )  //move：获取变量的所有权 而不是借用它们   print_s()   //prilntln !("{}",s ) //这行代码会报错，因为s的所有权已经转到了闭包
	闭包作为参数	6.闭包如何作为参数   1.定义了函数，它可以接收一个泛型参数，这个泛型参数可以是任何类型   2.但不能使用这个参数，因为它还不是一个具体类型   3.需要给泛型 取一个名字 比如F   4.rust编译器不知道F是什么类型，它需要一些帮助来解释F是什么 这就是泛型约束    fn call_fn<F>(f: F) where F: Fn() {  //<F>:泛型参数的声明    where F:Fn()   F必须实现Fn() trait     f();F }
	闭包和错误处理	7.闭包和错误处理   1.错误处理       fn divide(a: i32, b: i32) -> Result<i32, String> {          if b == 0 {             return Err("Divisionby zero".to_string());          }         Ok(a / b)      }   2.闭包的错误处理        .filter(|x| x % 2 === 0 )        .collect::<Result<Vec<_>,String>>()?   解释       .collect::<Result<Vec<_>,String>>()       .collect:Vec类型的一个方法，将迭代器中的元素收集到一个向量中       :：作用域解析运算符 访问结构体 枚举 模块 和关联函数的成员      <>  指定泛型参数的类型约束      Result<>  result