20天学会rust(四)常见系统库的使用

这篇具有很好参考价值的文章主要介绍了20天学会rust(四)常见系统库的使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前面已经学习了rust的基础知识,今天我们来学习rust强大的系统库,从此coding事半功倍。

集合

数组&可变长数组

在 Rust 中,有两种主要的数组类型:固定长度数组(Fixed-size Arrays)和可变长度数组(Dynamic-size Arrays)。

  1. 固定长度数组(Fixed-size Arrays):
    固定长度数组的长度在编译时就确定,并且长度不可改变。你可以使用以下语法定义一个固定长度数组:
fn main() {
    let arr: [i32; 5] = [1, 2, 3, 4, 5];
}

在上面的例子中,我们定义了一个类型为 i32 的固定长度数组 arr ,长度为 5,并初始化了数组的元素。

  1. 可变长度数组(Dynamic-size Arrays):
    Rust 中没有直接支持可变长度数组的语法。但是,你可以使用 Vec<T> 类型来创建一个动态增长的数组。 Vec<T> 是一个可变长度的动态数组,可以根据需要动态添加和删除元素。以下是一个使用 Vec<T> 的示例:
fn main() {
    let mut vec: Vec<i32> = Vec::new();
    vec.push(1);
    vec.push(2);
    vec.push(3);
}

在上面的例子中,我们首先创建了一个空的 Vec<i32> ,然后使用 push 方法向数组中添加元素。 Vec<T> 会根据需要自动调整大小。

需要注意的是,可变长度数组( Vec<T> )和固定长度数组( [T; N] )是不同的类型,它们具有不同的性质和用途。下面我们再看下Vec的一些基础用法:

创建Vec
在 Rust 中,有几种创建 Vec 的方式:

  1. 使用 Vec::new() 创建一个空的 Vec:
let mut vec = Vec::new();

这会创建一个长度为 0 的空向量。

  1. 使用 vec![] 宏创建一个非空的 Vec:
let mut vec = vec![1, 2, 3];

这会创建一个长度为 3、值为 [1, 2, 3] 的可变数组。

  1. 使用 Vec::with_capacity() 创建一个指定容量的 Vec:
let mut vec = Vec::with_capacity(10);

这会创建一个长度为 0 但预分配了 10 个元素空间的向量。这意味着,在不重新分配内存的情况下,vec 可以增长到 10 个元素。

  1. 使用 iterator 方法创建一个 Vec:
let mut vec = (1..10).collect::<Vec<i32>>();

这会创建一个长度为 9、值为 [1, 2, 3, 4, 5, 6, 7, 8, 9] 的向量。

这些方法的主要区别在于:

  • Vec::new() 和 vec![] 创建的向量初始长度为 0 或指定长度。
  • Vec::with_capacity() 创建的向量初始长度为 0,但预分配了指定的容量。这可以提高向量在后续增长时的性能,因为不需要频繁重新分配内存。
  • 使用 iterator 方法创建的向量会根据 iterator 的长度创建指定大小的向量。

总的来说,如果你知道向量的大致大小,使用 Vec::with_capacity() 可以获得最好的性能。否则,Vec::new() 和 vec![] 也是不错的选择。这里的区别类似Java。

操作Vec
在 Rust 中, Vec<T> 是一个可变长度的动态数组,用于存储相同类型的多个值。它有以下主要的方法:

  1. 添加元素 - 使用 push() 方法:
let mut vec = Vec::new();
vec.push(1);
  1. 删除元素 - 使用 pop() 方法删除最后一个元素:
let mut vec = vec![1, 2, 3];
vec.pop(); // vec = [1, 2]
  1. 查找元素 - 使用索引( [] )访问元素:
let vec = vec![1, 2, 3];
let elem = vec[0]; // elem = 1
  1. 修改元素 - 也使用索引( [] )访问元素,然后对其进行修改:
let mut vec = vec![1, 2, 3];
vec[0] = 5; 
// vec = [5, 2, 3]

除此之外, Vec<T> 还有其他方法,比如:

  • len() - 获取向量长度
  • iter() - 创建一个迭代器以便于遍历元素
  • iter_mut() - 创建一个可变迭代器以便于修改元素
  • first() - 获取第一个元素
  • last() - 获取最后一个元素
  • get() - 安全地访问一个元素,返回 Option<&T>
  • get_mut() - 安全地访问一个可变元素,返回 Option<&mut T>

这些方法可以满足你对 Vec<T> 的基本操作需求。

map

在 Rust 中,有几种主要的 map 实现:

  1. HashMap - 散列表映射,基于哈希表实现。这是 Rust 中最常用的映射类型。
  2. BTreeMap - 二叉树映射,基于二叉树实现。键值是有序的。
  3. LinkedHashMap - 链表散列表映射,基于哈希表和双向链表实现。键值保持插入顺序。
  4. IndexMap - 基于数组的映射。键必须实现 Index trait。
  5. FxHashMap - 散列表映射,使用第三方 fxhash 算法实现。性能可能优于标准库的 HashMap

这里主要介绍HashMap的用法,其他的大同小异,后续会出一个专门的用法介绍。
在 Rust 中,HashMap 的主要用法如下:

  1. 创建一个空的 HashMap:
let mut map = HashMap::new();
  1. 插入键值对:
map.insert(1, "a");
  1. 获取值:
let a = map.get(&1); // a = Some("a")
  1. 删除键值对:
map.remove(&1);
  1. 迭代 HashMap:
for (key, value) in &map {
    println!("{}: {}", key, value);
}
  1. 检查键是否存在:
map.contains_key(&1); // true 或 false
  1. 获取 HashMap 的长度:
let len = map.len();
  1. 清空 HashMap:
map.clear();
  1. 只迭代键或值:
for key in map.keys() {
    println!("{}", key); 
}

for value in map.values() {
    println!("{}", value);
}

这些是 HashMap 在 Rust 中最基本和最常用的方法。HashMap 是一个无序的 map,键类型必须实现 EqHash trait。

Set

  1. HashSet - 散列表集合,基于哈希表实现。用于存储唯一的键。
  2. BTreeSet - 二叉树集合,基于二叉树实现。键值是有序的。

这里我们也重点介绍HashSet的用法:

  1. HashSet基础用法:
let mut set = HashSet::new();
set.insert(1); // 插入元素:
set.remove(&1);// 删除元素:
set.contains(&1); // 检查元素是否存在: true 或 false
let len = set.len();// 获取 HashSet 的长度:

for elem in &set { // 迭代 HashSet:
    println!("{}", elem);
}

set.clear(); // 清空 HashSet:
  1. 取两个 HashSet 的交集、并集、差集:
let set1 = HashSet::from([1, 2, 3]);
let set2 = HashSet::from([2, 3, 4]);

let intersection = set1.intersection(&set2).collect(); // [2, 3]
let union = set1.union(&set2).collect(); // [1, 2, 3, 4]
let difference = set1.difference(&set2).collect(); // [1]

HashSet 是一个无序的集合,元素类型必须实现 EqHash trait。

迭代器&流式编程(Iterator)

在 Rust 中,迭代器(Iterator)是一种用于遍历集合元素的抽象。它提供了一个统一的接口,使你可以对各种不同类型的集合进行迭代。

要使用迭代器,你可以按照以下步骤进行操作:

  1. 创建一个迭代器:
    你可以通过调用集合上的 .iter().iter_mut() 方法来创建一个不可变或可变的迭代器。例如:
let vec = vec![1, 2, 3];
let iter = vec.iter(); // 不可变迭代器
let mut_iter = vec.iter_mut(); // 可变迭代器
  1. 使用迭代器方法:
    一旦你创建了迭代器,你可以使用迭代器的方法来处理集合的元素。一些常见的方法包括 .next().map().filter().fold() 等。例如:
let vec = vec![1, 2, 3];
let mut iter = vec.iter();

// 使用 .next() 方法逐个获取元素
while let Some(item) = iter.next() {
    println!("{}", item);
}

// 使用 .map() 方法对元素进行转换
let vec2: Vec<i32> = vec.iter().map(|x| x * 2).collect();
println!("{:?}", vec2); // 输出 [2, 4, 6]

// 使用 .filter() 方法过滤元素
let vec3: Vec<i32> = vec.iter().filter(|x| *x > 1).cloned().collect();
println!("{:?}", vec3); // 输出 [2, 3]
  1. 链式调用迭代器方法:
    你可以使用链式调用来组合多个迭代器方法,以实现复杂的操作。例如:
let vec = vec![1, 2, 3];
let result: i32 = vec.iter()
    .filter(|x| *x > 1)
    .map(|x| x * 2)
    .sum();
println!("{}", result); // 输出 10

通过这些方法,你可以对集合进行各种操作,如过滤、映射、折叠等。

  1. 自定义迭代器

在 Rust 中,你可以通过实现 Iterator trait 来自定义迭代器。 Iterator trait 有以下定义:

trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;

    // 默认方法
    fn size_hint(&self) -> (usize, Option<usize>) { ... }
    fn count(self) -> usize { ... }
    fn last(self) -> Option<Self::Item> { ... }
    fn nth(&mut self, n: usize) -> Option<Self::Item> { ... }
    fn step_by(self, step: usize) -> StepBy<Self> { ... }
    // 等等
}

要实现这个 trait,你需要:

  1. 定义 Item 类型,表示迭代器返回的元素类型。

  2. 实现 next 方法,返回迭代器的下一个元素,如果迭代器结束则返回 None

  3. 可选:实现其他默认方法来改善迭代器的行为。

以下是一个自定义迭代器的示例:

struct Counter {
    count: u32,
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            let c = self.count;
            self.count += 1;
            Some(c)
        } else {
            None
        }
    }
}

fn main() {
    let mut iter = Counter { count: 0 };
    while let Some(i) = iter.next() {
        println!("{}", i);
    }
}

这个迭代器会返回 0 到 4 的数字,然后结束。我们实现了 next 方法来定义这个行为。

通过实现 Iterator trait,你可以创建各种自定义的迭代器,以满足不同的需求。希望这能帮助你理解 Rust 中的迭代器和如何自定义迭代器!如果还有其他问题,请随时提问。

并发

多线程处理

下面我们通过一个例子学习: 创建一个线程,并每隔2s输出“hello world”

上代码:

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        loop {
            println!("hello world");
            thread::sleep(Duration::from_secs(2));
        }
    });
}

这个代码会:

  • 使用 thread::spawn 创建一个新线程
  • 在线程中有一个无限循环
  • 每次循环会打印 “hello world”
  • 使用 thread::sleep 使线程睡眠 2 秒
  • 所以这个线程会每隔 2 秒打印一次 “hello world”

Duration::from_secs(2) 是创建一个表示 2 秒的 Duration。我们将其传递给 thread::sleep 来使线程睡眠 2 秒。

Ok,我们掌握了线程的基础用法, 再来看一个复杂的例子: 用多线程实现观察者模式

要实现观察者模式,可以使用通道(channel)在线程间通信。例如:

use std::sync::mpsc;
use std::thread;

struct Subject {
    observers: Vec<mpsc::Sender<i32>>,
}

impl Subject {
    fn new() -> Subject {
        Subject { observers: vec![] }
    }

    fn attach(&mut self, observer: mpsc::Sender<i32>) {
        self.observers.push(observer);
    }

    fn notify(&self) {
        for observer in self.observers.iter() {
            observer.send(1).unwrap();
        }
    }
}

fn main() {
    let (tx1, rx1) = mpsc::channel();
    let (tx2, rx2) = mpsc::channel();

    let mut subject = Subject::new();
    subject.attach(tx1);
    subject.attach(tx2);

    thread::spawn(move || {
        let msg = rx1.recv().unwrap();
        println!("Got: {}", msg);
    });

    thread::spawn(move || {
        let msg = rx2.recv().unwrap();
        println!("Got: {}", msg);
    });

    subject.notify();
}

在这个例子中:

  • Subject 结构体充当主题(subject),维护多个观察者(observers)的列表。
  • attach 方法用于添加观察者(通道的发送端)。
  • notify 方法用于通知所有观察者(通过通道发送消息)。
  • 我们创建两个线程作为观察者,通过通道接收主题的通知。
  • 当调用 subject.notify() 时,两个观察者线程会接收到通知并打印消息。

线程间通信

在上面的例子中,有一个新的知识点:使用通道(channel)在线程间通信。 那么什么是channel呢?

在 Rust 中,channel 用于在线程之间发送消息和通信。它可以在不同的线程之间安全地传递数据。

channel 的主要作用有:

  1. 线程间通信:channel 可以在不同的线程之间发送消息,用于线程间的通信和协作。

  2. 安全地共享数据:channel 可以在线程之间安全地传递数据,避免数据竞争。

  3. 限制并发:channel 的发送端和接收端各有一个缓存,这可以限制线程之间并发发送和接收消息的数量。

举个例子:

use std::sync::mpsc::channel;
use std::thread;

fn main() {
    let (tx, rx) = channel();

    thread::spawn(move || {
        tx.send(10).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

在这个例子中:

  • 我们使用 channel() 创建一个 channel,它返回一个发送端 tx 和一个接收端 rx
  • 然后我们创建一个线程,在线程中通过 tx 发送消息 10。
  • 在主线程中,我们通过 rx 接收该消息,并打印结果。
  • 这样,通过 channel 我们就在两个线程之间安全地传递了数据。

channel 在 Rust 的并发编程中非常有用,它可以用于线程池、工作窃取等并发模式中。
再看一个用法: 工作窃取

这里是一个使用 channel 实现工作窃取的例子:

use std::sync::mpsc::channel;
use std::thread;

fn main() {
    let (tx, rx) = channel();

    let mut threads = vec![];
    for i in 0..10 {
        let tx = tx.clone();
        threads.push(thread::spawn(move || {
            let mut work = rx.recv().unwrap();
            while let Some(job) = work.recv() {
                println!("Worker {} got job {}", i, job);
            }
        }));
    }

    for job in 0..10 {
        let thread_id = job % threads.len();
        threads[thread_id].send(job).unwrap();
    }
}

这个例子做了以下工作:

  1. 创建一个 channel,得到发送端 tx 和接收端 rx。

  2. 创建 10 个工作线程,每个线程从 rx 接收工作。

  3. 将 10 个工作(job)发送到不同的工作线程,实现工作窃取。每个工作会被发送到线程 ID 与工作 ID 取余后的线程。

  4. 每个工作线程接收工作,并打印接收到的工作 ID。

  5. 主线程将所有工作分发完成后结束。

这个例子展示了如何使用 channel 在线程之间传递工作,实现工作窃取的模式。每个工作线程从 channel 接收工作,而不是固定的工作队列。这使得工作可以在线程之间动态分配,实现工作窃取。

线程池

熟悉java的同学可能会问了,有线程? 那有线程池吗?必须有!!

在 Rust 中,你可以使用 threadpool crate 来创建一个线程池。以下是一个基本的示例:

use threadpool::ThreadPool;

fn main() {
    let pool = ThreadPool::new(4);

    for i in 0..10 {
        let j = i;
        pool.execute(move || {
            println!("Hello from thread {}", j);
        });
    }
}

这会创建一个包含 4 个线程的线程池。然后我们使用 pool.execute() 方法在线程池中执行 10 个闭包。这些闭包会被线程池的线程执行,并打印出执行线程的索引。

threadpool crate 提供了以下主要功能:

  • ThreadPool::new(size) :创建一个包含 size 个线程的线程池。
  • pool.execute(closure) :在线程池的某个线程中执行提供的闭包。
  • pool.join() :等待线程池中的所有线程结束。
  • ThreadPoolBuilder :可以用来自定义线程池的各种设置,如线程名称、堆栈大小等。

一个更复杂的例子:

use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use threadpool::ThreadPool;

fn main() {
    let pool = ThreadPool::new(4);

    let (tx, rx) = mpsc::channel();

    let tx = Arc::new(Mutex::new(tx));

    for i in 0..10 {
        let tx = tx.clone();
        pool.execute(move || {
            let mut tx = tx.lock().unwrap();
            tx.send(i).unwrap();
        });
    }

    for _ in 0..10 {
        let j = rx.recv().unwrap();
        println!("Got: {}", j);
    }

    pool.join();
}

这里我们使用了 mpsc 库创建一个通道,并使用 Arc<Mutex<T>> 在线程之间共享该通道的发送端。然后我们在 10 个任务中发送数字到通道,并在主线程中接收这些数字。

序列化

在后端开发中,序列化是一个绕不过的话题,前后端交互,后端之间交互都需要对数据做序列化与反序列化。 在 Rust 中,有几种常用的序列化方式:

  1. Serde:这是 Rust 中最流行的序列化库。它提供了多种序列化格式的支持,如 JSON、YAML、TOML 等。使用 Serde 可以方便地将 Rust 结构体序列化为这些格式,以及反序列化回 Rust 结构体。

  2. Bincode:这是一个用于在 Rust 中进行二进制序列化的库。它可以高效地将 Rust 的基本数据结构编码为二进制,并解码回原数据结构。

  3. Ron:这是一个用于 Rust 对象表示法 (RON) 的序列化格式和解析器。RON 是一个人类友好的二进制序列化格式,设计用于在 Rust 中存储和传输数据。

  4. CBOR:这是一个实现了约束二进制对象表示法 (CBOR) 的 Rust 库。CBOR 是一种二进制序列化格式,它比 JSON 更紧凑,也更适用于嵌入式系统。

  5. MessagePack:这是一个实现 MessagePack 二进制序列化格式的 Rust 库。MessagePack 是一个高效的二进制序列化格式,可以用于在不同语言之间交换数据。

  6. Protobuf:这是 Google 开发的一种数据序列化格式,在 Rust 中可以使用 prostprotobuf 库来实现。Protobuf 是一种语言无关、平台无关的可扩展机制,用于序列化结构化数据。

以上就是 Rust 中常用的几种序列化方式。总的来说,如果你需要一个通用的序列化方式,可以选择 Serde。如果你需要一个高效紧凑的二进制格式,可以选择 Bincode、CBOR 或 MessagePack。如果你需要跨语言支持,可以选择 Protobuf。

这里主要演示下Serde的用法,它提供了一组宏和 trait,用于将 Rust 数据结构转换为各种格式的序列化表示,并将序列化表示转换回 Rust 数据结构。

要使用 Serde,首先需要在 Cargo.toml 文件中添加以下依赖项:

[dependencies]
serde = "1.0"
serde_json = "1.0"

接下来,我们将给出一个使用 Serde 进行 JSON 序列化和反序列化的例子:

use serde::{Serialize, Deserialize};
use serde_json::{Result, Value};

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    age: u8,
    address: String,
}

fn main() -> Result<()> {
    // 序列化为 JSON
    let person = Person {
        name: "Alice".to_string(),
        age: 25,
        address: "123 ABC Street".to_string(),
    };

    let serialized = serde_json::to_string(&person)?;
    println!("Serialized: {}", serialized);

    // 反序列化为 Rust 结构体
    let deserialized: Person = serde_json::from_str(&serialized)?;
    println!("Deserialized: {:?}", deserialized);

    Ok(())
}

在上面的例子中,我们定义了一个 Person 结构体,并使用 #[derive(Serialize, Deserialize)] 宏为其实现了 Serde 的 SerializeDeserialize trait。这使得我们可以将 Person 结构体序列化为 JSON 字符串,并将 JSON 字符串反序列化为 Person 结构体。

main 函数中,我们首先创建一个 Person 实例,然后使用 serde_json::to_string 方法将其序列化为 JSON 字符串,并打印出来。接着,我们使用 serde_json::from_str 方法将 JSON 字符串反序列化为 Person 结构体,并打印出来。

网络请求

请求Http接口

在 Rust 中,你可以使用第三方库来进行 HTTP 请求。最常用的库之一是 reqwest ,它提供了简单且易于使用的 API 来发送 HTTP 请求。

首先,你需要在 Cargo.toml 文件中添加 reqwest 依赖项:

[dependencies]
reqwest = "0.11"

接下来,我们将给出一个使用 reqwest 发送 GET 请求的示例:

use reqwest::Error;

#[tokio::main]
async fn main() -> Result<(), Error> {
    let response = reqwest::get("https://api.example.com/users").await?;
    let body = response.text().await?;
    println!("Response Body: {}", body);

    Ok(())
}

在上面的示例中,我们使用 reqwest::get 方法发送一个 GET 请求到 https://api.example.com/users 。然后,我们使用 response.text().await? 来获取响应的文本内容,并打印出来。

需要注意的是,我们使用了 tokio::main 宏来异步运行请求。因此,你需要在 main 函数之前添加 tokio 作为依赖项,并在 main 函数前面使用 #[tokio::main] 注解。

到目前为止,我们学习了集合、并发、序列化和网络请求,最后再留一个作业: 请求百度首页,并解析出所有的http链接。 结合本文所学哦文章来源地址https://www.toymoban.com/news/detail-649446.html

到了这里,关于20天学会rust(四)常见系统库的使用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 如何在 Ubuntu 20.04 上安装 Rust

    前些天发现了一个人工智能学习网站,通俗易懂,风趣幽默,最重要的屌图甚多,忍不住分享一下给大家。点击跳转到网站。 介绍 Rust 编程语言,是一种功能强大的通用编程语言。Rust 在语法上与C++类似,用于广泛的软件开发项目,包括浏览器组件、游戏引擎和操作系统。

    2024年04月15日
    浏览(68)
  • Rust 语言常见的一些概念(下)

    目录 1、函数 参数 语句和表达式 具有返回值的函数 2、注释 文档注释 多行注释 3、控制流 3.1 if 表达式 3.2 使用esle if 处理多重条件 3.3 在 let 语句中使用 if 3.4 使用循环重复执行 使用 loop 重复执行代码 从循环中返回值 循环标签:在多个循环之间消除歧义 while 条件循环 使用

    2024年02月06日
    浏览(39)
  • Rust 语言常见的一些概念(上)

    目录 1、变量的可变性 常量  隐藏 2、数据类型 2.1 标量类型 整型 浮点型 数值运算 布尔型 字符类型 复合类型 元组类型 数组类型 变量默认是不可改变的(immutable)。这是 Rust 提供给你的众多优势之一,让你得以充分利用 Rust 提供的安全性和简单并发性来编写代码。不过,你

    2024年02月06日
    浏览(34)
  • 如何在Win11系统中使用ubuntu(WSL)终端编译 Rust 程序

    参考微软提供的官方指南 在管理员模式下打开 PowerShell 或 Windows 命令提示符,方法是右键单击并选择“以管理员身份运行”,输入 wsl --install 命令,然后重启计算机。 从windows store 中下载安装 打开文件资源管理器,打开左侧的Linux文件夹,定位到 etc/apt/ 目录,将 sources.list

    2024年02月20日
    浏览(42)
  • 【Rust】枚举类型创建单链表以及常见的链表操作方法

    目录 单链表 用枚举表达链表 枚举enum Box容器 创建节点 1. 创建并打印 2. match 匹配 3. 节点初始化 4.节点嵌套 追加节点 1. 尾插法 2. 链表追加方法 3. 头插法 4. 改写成单链表方法 遍历链表 1. 递归法 2. 递推法 3. 改写成单链表方法  自定义Display trait 创建链表 1. 递归法 2. 递推法

    2024年02月15日
    浏览(40)
  • 【unity实战】使用unity制作一个类似Rust的3D生存建造建筑系统(附项目源码)

    配置 配置 效果 https://gitcode.net/unity1/3dbuildsystem 赠人玫瑰,手有余香!如果文章内容对你有所帮助,请不要吝啬你的 点赞评论和关注 ,以便我第一时间收到反馈,你的每一次 支持 都是我不断创作的最大动力。当然如果你发现了文章中 存在错误 或者有 更好的解决方法 ,也欢

    2024年02月19日
    浏览(47)
  • 掘力计划第 20 期: Pake —— 利用 Rust 轻松构建跨端轻量级应用

    在掘力计划系列活动第20场 , 前端工程师 Tw93(真名汤威)分享了跨端开发与跨端技术实践。 汤威是一名主职前端、爱折腾的前端开发者,除了前端之外他对后端和客户端技术皆有涉猎,并且是 Pake / 妙言 / 潮流周刊 / XRender / Weex Ui 的作者。 本期汤威带来的是跨端技术相关内

    2024年02月13日
    浏览(42)
  • 2023-05-20:go语言的slice和rust语言的Vec的扩容流程是什么?

    2023-05-20:go语言的slice和rust语言的Vec的扩容流程是什么? 答案2023-05-20: go版本是1.20.4。 扩容流程见源码见runtime/slice.go文件中的 growslice 函数。 growslice 函数的大致过程如下: 1.如果元素类型的大小为零,则返回具有 nil 指针但非零长度的切片。否则,下一步。 2.计算新切片的

    2024年02月05日
    浏览(43)
  • 20. 从零用Rust编写正反向代理,四层反向代理stream(tcp与udp)实现

    wmproxy 已用 Rust 实现 http/https 代理, socks5 代理, 反向代理, 静态文件服务器,四层TCP/UDP转发,内网穿透,后续将实现 websocket 代理等,会将实现过程分享出来,感兴趣的可以一起造个轮子 gite: https://gitee.com/tickbh/wmproxy github: https://github.com/tickbh/wmproxy 四层代理,也称为网络层代理

    2024年01月19日
    浏览(34)
  • 简单对比Java、Python、Go、Rust等常见语言计算斐波拉契数的性能

    最近简单学了下Rust,以我这种菜鸟水平,没感受到什么安全、性能什么方面的优势,只觉得概念太多,编译各种报错。暂时也写不出来什么玩法,索性对比下各种学过的语言的性能。部分语言很早之前学过,很久不用就忘了,所以是用GPT写的。但运行逻辑很简单,所以应该没

    2024年03月16日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包