垦荒学园
  • 中文

      • Rust 迭代器

      概述

      迭代器是 Rust 中处理数据集合的强大工具。

      🔄 基本迭代器

      fn main() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();
    
    for val in v1_iter {
        println!("Got: {}", val);
    }
}

      🔧 迭代器适配器

      fn main() {
    let v1: Vec<i32> = vec![1, 2, 3];
    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
    println!("{:?}", v2);
}

      继续学习：下一章 - Rust 闭包

      Rust 闭包

      概述

      闭包是可以捕获周围环境的匿名函数。

      🔧 基本闭包

      fn main() {
    let expensive_closure = |num| {
        println!("calculating slowly...");
        std::thread::sleep(std::time::Duration::from_secs(2));
        num
    };
    
    println!("{}", expensive_closure(5));
}

      📦 捕获环境

      fn main() {
    let x = 4;
    let equal_to_x = |z| z == x;
    let y = 4;
    assert!(equal_to_x(y));
}

      继续学习：下一章 - Rust 引用与借用

      Rust 引用与借用

      概述

      引用允许你使用值但不获取其所有权。

      🔗 不可变引用

      fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

      🔗 可变引用

      fn main() {
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

      继续学习：下一章 - Rust 生命周期

      Rust 生命周期

      概述

      生命周期确保引用的有效性。

      🕐 生命周期语法

      fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";
    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

      继续学习：下一章 - Rust Slice（切片）类型

      Rust Slice（切片）类型

      概述

      切片允许你引用集合中一段连续的元素序列。

      🍰 字符串切片

      fn main() {
    let s = String::from("hello world");
    let hello = &s[0..5];
    let world = &s[6..11];
    println!("{} {}", hello, world);
}

      🍰 数组切片

      fn main() {
    let a = [1, 2, 3, 4, 5];
    let slice = &a[1..3];
    println!("{:?}", slice);
}

      继续学习：下一章 - Rust 结构体

      Rust 结构体

      概述

      结构体是自定义数据类型，让你可以将相关的值打包在一起。

      🏗️ 定义结构体

      struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
    
    println!("User: {}", user1.username);
}

      🔧 方法

      impl User {
    fn new(email: String, username: String) -> User {
        User {
            email,
            username,
            active: true,
            sign_in_count: 1,
        }
    }
    
    fn is_active(&self) -> bool {
        self.active
    }
}

      继续学习：下一章 - Rust 枚举类