学习笔记
fn main() {
println!("1111");
// ① 函数 main函数是 二进制可执行文件的起点，对库来说 main函数不是必要的
fn add(x: i32, y: i32) -> i32 {
x + y
}
println!("{}", add(1, 2)); // 3
//方法 方法大多是结构体绑定的 类似 面向对象编程
struct Info {
Nane: String,
Age: i32,
}
impl Info {
fn GetName(&self) -> String {
self.Nane.to_string()
}
fn SetAgeAdd(&mut self, age: i32) -> i32 {
self.Age += age;
self.Age
}
}
let mut user = Info {
Nane: String::from("刘洋"),
Age: 24,
};
let name = user.GetName(); // GetName 就是方法
let age = user.SetAgeAdd(10);
println!("{}", name); // 刘洋
println!("{}", age); // 34
// 函数指针，也叫匿名函数
fn max(x: i32, y: i32) -> i32 {
if x > y {
x
} else {
y
}
}
let fn_max = max;
println!("{}", fn_max(11, 10)); // 11
// 函数做参数
type MathOp = fn(i32, i32) -> i32;
fn math(op: MathOp, x: i32, y: i32) -> i32 {
op(x, y)
}
fn adds(x: i32, y: i32) -> i32 {
x + y
}
fn subtract(x: i32, y: i32) -> i32 {
x - y
}
let (x, y) = (8, 3);
println!("adds {}", math(adds, x, y)); // adds 11
println!("subtract {}", math(subtract, x, y)); // subtract 5
// 函数做返回值
fn math_op_return(op: &str) -> MathOp {
match op {
"add" => adds,
_ => subtract,
}
}
let (x, y) = (8, 3);
let o = math_op_return("add");
let o1 = math_op_return("add111");
println!("o {}", o(x, y)); // o 11
println!("o1 {}", o1(x, y)); // o1 5
// ② 闭包
// 闭包 和其他语言不一样 不能直接在函数里面访问 上下文, 只能通过管道符|| 实现
let bbb = 10;
// fn maxB(x: i32) -> i32 { x + bbb } // bbb 作用域不存在
let maxB = |x: i32| -> i32{ x + bbb };
let maxB = |x| { x + bbb };
println!("{}", maxB(5)); // 15 bbb = 10 传入的5
// ③ 迭代器
let v = [1, 2, 3, 4, 5, 6];
let mut iter = v.iter(); // 把数组转成迭代器
// println!("{:?}", iter.next()); // 下一个
// 消费器 sum 他将迭代器中每个元素进行累加并返回总和
let total: i32 = v.iter().sum();
println!("{}", total); // 21
// 消费器 any 可以查找 迭代器中 是否有满足的条件 必须使用 引用和 解引用方式
let result = v.iter().any(|x| {
*x == 1
});
println!("{}", result); // true
let result = v.iter().any(|&x| {
x == 100
});
println!("{}", result); // false
// 消费器 collect 可以将迭代器转换成指定容器里
let result: Vec<i32> = v.iter().map(|x| x + 1).collect();
println!("{:?}", result); // [2, 3, 4, 5, 6, 7]
// 适配器 map 对迭代器每个元素调用闭包生成新的迭代器 和上面用法一直
// take 生成一个只迭代原迭代器中的n个元素
let result = v.iter().take(2);
for i in result {
println!("{}", i) //只显示前两个 1 2
}
// 适配器 filter 过滤成一个新迭代器
println!("{:?}", v); // [1, 2, 3, 4, 5, 6]
// 转成迭代器，map 给每个元素加3，filter过滤 元素 能陪3整除，组成一个数组
let result: Vec<i32> = v.iter()
.map(|x| x + 3)
.filter(|x| x % 3 == 0)
.collect();
println!("{:?}", result); // [6, 9]
// 适配器 rev 倒序打印查看
let result = v.iter().rev();
for i in result {
println!("{}", i); // 6 5 4 3 2 1
}
// 适配器 zip 将两个迭代器压缩在一起处理
let v1 = [1, 2, 3];
let v2 = [4, 5, 6];
// 将两个迭代器 通过.map 相加，在通过collect返回一个新的动态数组
let result: Vec<i32> = v1.iter().zip(v2.iter()).map(|(a, b)| a + b).collect();
println!("{:?}", result);//[5, 7, 9]
}
发表评论