2024-08-19



// 假设我们有一个Rust函数,用于将字符串转换为大写
fn to_uppercase(input: &str) -> String {
    input.to_uppercase()
}
 
// 在Rust中,我们可以使用一个宏来导出函数到JavaScript
#[wasm_bindgen]
pub fn export_to_uppercase(input: &str) -> String {
    to_uppercase(input)
}
 
// 以下是JavaScript代码,用于加载和使用Rust生成的WebAssembly模块
import("./your_rust_module_path").then(module => {
    const uppercased = module.export_to_uppercase('hello world');
    console.log(uppercased); // 输出: 'HELLO WORLD'
});

这个例子展示了如何在Rust中定义一个简单的函数,并使用wasm_bindgen宏来导出它,以便它可以在WebAssembly模块中被JavaScript代码调用。然后,在JavaScript中,我们通过动态导入Rust模块并调用该函数来演示如何使用Rust代码生成的WebAssembly。

2024-08-17



use actix_web::{dev::ServiceRequest, dev::ServiceResponse, Error};
use std::time::SystemTime;
 
/// 日志打印中间件
/// 记录请求的开始时间,响应时间,并打印日志
pub fn log_middleware<S>(req: ServiceRequest, srv: &S) -> Result<ServiceResponse, Error>
where
    S: ActixWebService,
{
    // 记录请求开始时间
    let start = SystemTime::now();
    // 设置自定义数据,以便在后续中间件和处理器中访问
    req.extensions_mut().insert(start);
 
    let result = srv.call(req);
 
    // 处理result,记录日志
    match result {
        Ok(response) => {
            let res = response.map_err(|e| e.into())?;
            let duration = start.elapsed().unwrap().as_millis();
            // 打印日志,例如:"GET /index 200 10ms"
            println!("{} {} {} {}ms", req.method(), req.path(), res.status(), duration);
            Ok(res)
        },
        Err(e) => {
            let duration = start.elapsed().unwrap().as_millis();
            // 打印错误日志
            println!("{} {} {} {}ms", req.method(), req.path(), e.status(), duration);
            Err(e)
        }
    }
}
 
/// 鉴权中间件
/// 检查请求是否有有效的鉴权信息
pub fn auth_middleware<S>(req: ServiceRequest, srv: &S) -> Result<ServiceResponse, Error>
where
    S: ActixWebService,
{
    // 假设我们有一个鉴权逻辑
    let auth_header = req.headers().get("Authorization");
    if let Some(header) = auth_header {
        // 鉴权逻辑...
        if header == "Bearer valid_token" {
            // 鉴权通过,继续处理请求
            srv.call(req)
        } else {
            // 返回401未授权响应
            Err(actix_web::error::ErrorUnauthorized("Authorization header invalid"))
        }
    } else {
        // 没有鉴权头,返回401未授权响应
        Err(actix_web::error::ErrorUnauthorized("Missing Authorization header"))
    }
}
 
// 使用中间件
fn main() {
    // 注册中间件,确保它们按正确的顺序注册
    App::new()
        .wrap(log_middleware)
        .wrap(auth_middleware)
        // ... 其他设置和服务
}

这个代码示例展示了如何在Rust的actix-web框架中定义和使用自定义的日志记录中间件和鉴权中间件。这些中间件可以被注册到actix-web应用中,并在请求处理管道中按预定义的顺序执行。在实际应用中,你需要替换日志打印和鉴权逻辑以满足你的具体需求。

2024-08-17



use std::collections::HashSet;
use std::io::{self, Write};
use url::Url;
 
// 初始URL集合
let mut initial_urls = HashSet::new();
initial_urls.insert("https://www.example.com".parse().unwrap());
 
// 已访问URL集合
let mut visited_urls = HashSet::new();
 
// 待访问URL集合
let mut unvisited_urls = initial_urls.clone();
 
while let Some(url) = unvisited_urls.iter().next().cloned() {
    if !visited_urls.contains(&url) {
        visited_urls.insert(url.clone());
        unvisited_urls.remove(&url);
 
        match download_and_parse_url(&url) {
            Ok(new_urls) => {
                for new_url in new_urls {
                    if let Ok(new_url) = new_url.parse::<Url>() {
                        unvisited_urls.insert(new_url);
                    }
                }
            }
            Err(e) => {
                writeln!(io::stderr(), "Error downloading {}: {}", url, e)?;
            }
        }
    }
}
 
// 模拟下载和解析URL的函数
fn download_and_parse_url(url: &Url) -> Result<Vec<String>, Box<dyn std::error::Error>> {
    // 这里只是模拟,实际应该下载页面内容,解析并提取新的URL
    println!("下载和解析: {}", url);
    Ok(vec![])
}

这个代码示例展示了如何使用Rust实现一个简单的网络爬虫,包括初始化URL集合、使用哈希集保存已访问和未访问的URL、从每个URL下载和解析内容以提取新的URL,并且通过使用Result类型来处理可能发生的错误。虽然这个代码不会真正下载页面内容或解析链接,但它展示了如何组织爬虫的基本结构,并包含了错误处理的实践。

2024-08-16

Flutter-RS 是一个正在开发中的项目,它旨在为 Flutter 提供一个 Rust 语言的工具链。目前,Flutter-RS 还在早期阶段,并未准备好用于生产环境。

如果你想要尝试这个项目,你需要做以下几个步骤:

  1. 安装 Rust 语言编译器。
  2. 安装 Flutter SDK。
  3. 克隆 Flutter-RS 仓库。
  4. 根据 Flutter-RS 的文档编译并运行。

以下是一个简单的代码示例,演示如何在 Flutter 项目中使用 Flutter-RS 工具链:




// 引入 Flutter-RS 的必要组件
use flutter_rs::{
    plugins::{flutter::{self, FlutterEngine}, plugins},
    FlutterEnginePlugin, FlutterPlugin, Plugin,
};
 
// 定义一个插件,这里只是示例,具体实现依赖于 Flutter-RS 的 API
pub struct ExamplePlugin {
    // ...
}
 
// 实现 FlutterPlugin 接口
impl FlutterPlugin for ExamplePlugin {
    // 初始化方法
    fn init_plugin(&mut self, plugin: &mut Plugin) {
        // ...
    }
 
    // 处理方法调用
    fn handle_method_call(&mut self, call: &MethodCall, plugin_ptr: usize) {
        // ...
    }
}
 
fn main() {
    // 创建 Flutter 引擎实例
    let mut flutter_engine = FlutterEngine::new();
 
    // 初始化插件
    let mut example_plugin = ExamplePlugin::new();
    example_plugin.init_plugin(&mut flutter_engine.plugin());
 
    // 运行 Flutter 引擎
    flutter_engine.run(plugins!(example_plugin));
}

请注意,上述代码仅为示例,实际的 Flutter-RS 实现会更加复杂,并且会有更多的接口和方法需要实现。

由于 Flutter-RS 目前还在开发阶段,上述代码可能会随着项目的发展而发生变化。如果你想要跟踪这个项目的进展,建议直接访问 Flutter-RS 的官方仓库查看最新的文档和代码示例。

2024-08-16



use reqwest::Client;
use std::io::{self, Write};
 
// 异步下载网页内容
async fn download_website(client: &Client, url: &str) -> Result<String, reqwest::Error> {
    let res = client.get(url).send().await?;
    let body = res.text().await?;
    Ok(body)
}
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化一个 Reqwest 客户端
    let client = Client::new();
 
    // 待下载的网页 URL
    let url = "https://www.example.com";
 
    // 下载网页内容
    let content = download_website(&client, url).await?;
 
    // 打印网页内容到控制台
    println!("网页内容:\n{}", content);
 
    // 将内容写入到文件
    let mut file = io::stdout();
    writeln!(file, "{}", content)?;
 
    Ok(())
}

这段代码使用了 Reqwest 库来异步下载一个网页的内容,并将其打印到控制台和文件中。这是一个简单的网络爬虫示例,展示了如何在 Rust 中使用 Reqwest 库进行基本的 HTTP 请求。

2024-08-16

由于原代码已经是一个致命Bug的示例,我们无法直接提供可运行的代码。但是,我们可以尝试用C++/Python/Rust重写其核心逻辑,以演示如何正确实现B-树。

以下是一个简单的B-树节点定义和插入操作的伪代码示例:

C++:




#include <vector>
#include <iostream>
 
using namespace std;
 
struct BTreeNode {
    vector<int> keys;
    vector<BTreeNode*> children;
    int t; // min degree
 
    BTreeNode(int t) : t(t) {}
};
 
class BTree {
    BTreeNode *root;
    int t;
 
public:
    BTree(int t) : t(t) {
        root = new BTreeNode(t);
    }
 
    void insert(int key) {
        // Insertion logic goes here
    }
};
 
int main() {
    BTree tree(2); // min degree of 2
    tree.insert(1);
    // ...
    return 0;
}

Python:




class BTreeNode:
    def __init__(self, t):
        self.keys = []
        self.children = []
        self.t = t
 
class BTree:
    def __init__(self, t):
        self.root = BTreeNode(t)
 
    def insert(self, key):
        # Insertion logic goes here
 
# Example usage
tree = BTree(2) # min degree of 2
tree.insert(1)
# ...

Rust:




struct BTreeNode<T> {
    keys: Vec<T>,
    children: Vec<Box<BTreeNode<T>>>,
    t: usize, // min degree
}
 
impl<T> BTreeNode<T> {
    fn new(t: usize) -> Self {
        BTreeNode { keys: Vec::new(), children: Vec::new(), t }
    }
}
 
struct BTree<T> {
    root: BTreeNode<T>,
}
 
impl<T: Ord + Copy> BTree<T> {
    fn new(t: usize) -> Self {
        BTree { root: BTreeNode::new(t) }
    }
 
    fn insert(&mut self, key: T) {
        // Insertion logic goes here
    }
}
 
fn main() {
    let mut tree = BTree::new(2); // min degree of 2
    tree.insert(1);
    // ...
}

请注意,这些示例只是展示了B-树的基本结构和插入操作的伪代码,实际的实现细节需要根据原代码中的Bug修复和完整的插入、删除、搜索算法。

2024-08-16



// Rust代码,在lib.rs文件中
#[no_mangle]
pub extern "C" fn double_input(input: i32) -> i32 {
    input * 2
}
 
// 构建Rust库的命令
// 在Rust项目目录中执行:
// cargo build --release
 
// Go代码,在main.go文件中
package main
 
/*
#cgo LDFLAGS: -L${SRCDIR}/target/release -lmy_rust_library -lstdc++
#include <stdlib.h>
 
extern int double_input(int input);
 
static int double_input_wrapper(void *arg) {
    int input = *(int*)arg;
    return double_input(input);
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)
 
func main() {
    input := 10
    result := C.double_input_wrapper(unsafe.Pointer(&input))
    fmt.Printf("Result from Rust: %d\n", result)
}
 
// 构建Go程序的命令
// 在Go项目目录中执行:
// go build
// 运行Go程序
// ./my_go_program

这个代码示例展示了如何在Go程序中调用一个使用Rust编写的函数。首先,在Rust中定义了一个函数double_input,该函数接收一个整数输入并返回其两倍。然后,在Go中,我们使用cgo特性定义了相应的外部函数声明和包装器,以便能够正确地调用Rust函数。在实际使用时,你需要确保Rust库已经被正确编译并且Go程序知道从哪里链接这个库。

2024-08-15

这个例子展示了如何使用Rust语言搭建一个使用Axum框架的后端API服务器,以及如何使用Next.js框架搭建一个前端应用,并与后端API服务器进行通信。

后端Rust代码(axum\_nextjs\_starter/src/main.rs):




use axum::{routing::get, Router};
 
#[tokio::main]
async fn main() {
    // 初始化一个axum路由器
    // 添加一个处理GET请求的路由
    // 响应 "Hello, Next.js + Axum!"
    let app = Router::new().route("/", get(|| async { "Hello, Next.js + Axum!" })).layer(axum::middleware::trace::TraceLayer::new());
 
    // 在8080端口启动服务器
    axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

前端Next.js代码(pages/index.js):




import fetch from 'node-fetch';
import { useEffect, useState } from 'react';
 
export default function Home() {
  const [message, setMessage] = useState('');
 
  useEffect(() => {
    fetch('http://localhost:8080')
      .then(res => res.text())
      .then(text => setMessage(text))
      .catch(console.error);
  }, []);
 
  return (
    <div>
      <h1>Next.js + Axum</h1>
      <p>{message}</p>
    </div>
  );
}

这个例子简单展示了如何使用Rust搭建后端服务,并通过API与Next.js前端通信。这是一个入门级的示例,展示了前后端如何交互的基本概念。在实际应用中,你需要考虑更多的安全性、可靠性和性能因素。

2024-08-15

以下是单链表的创建、插入、打印和删除操作的实现代码,在C++、Java、Python、Go和Rust中:

C++:




#include <iostream>
 
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};
 
// 插入节点
void insert(ListNode*& head, int data) {
    ListNode* newNode = new ListNode(data);
    newNode->next = head;
    head = newNode;
}
 
// 打印链表
void printList(ListNode* head) {
    while (head != nullptr) {
        std::cout << head->val << " ";
        head = head->next;
    }
    std::cout << std::endl;
}
 
// 删除节点
void deleteNode(ListNode*& head, int data) {
    if (head->val == data) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
        return;
    }
    ListNode* current = head;
    while (current->next != nullptr && current->next->val != data) {
        current = current->next;
    }
    if (current->next != nullptr) {
        ListNode* temp = current->next;
        current->next = current->next->next;
        delete temp;
    }
}
 
int main() {
    ListNode* head = nullptr;
    insert(head, 4);
    insert(head, 3);
    insert(head, 2);
    insert(head, 1);
 
    printList(head); // 输出: 1 2 3 4
 
    deleteNode(head, 3);
    printList(head); // 输出: 1 2 4
 
    return 0;
}

Java:




class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}
 
public class Main {
    // 插入节点
    void insert(ListNode head, int data) {
        ListNode newNode = new ListNode(data);
        newNode.next = head;
        head = newNode;
    }
 
    // 打印链表
    void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }
 
    // 删除节点
    void deleteNode(ListNode head, int data) {
        if (head.val == data) {
            ListNode newHead = head.next;
            head = null;
            head = newHead;
            return;
        }
        ListNode current = head;
        while (current.next != null && current.next.val != data) {
            current = current.next;
        }
        if (current.next != null) {
            ListNode temp = current.next;
            current.next = current.next.next;
            temp = null;
        }
    }
 
    public static void main(String[] args) {
        ListNode head = null;
        Main obj = new Main();
        obj.insert(head, 4);
        obj.insert(head, 3)
2024-08-14



// 引入Python的macOS系统库
#[cfg(target_os = "macos")]
extern crate libc;
 
// 引入Python的Linux系统库
#[cfg(target_os = "linux")]
extern crate libc as python_libc;
 
use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
 
// 定义一个简单的Rust函数
fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}
 
// 定义Python可调用的接口
#[pyfunction]
fn hello_world(py: Python) -> PyResult<String> {
    Ok(greet("World").into_py(py))
}
 
// 模块初始化函数,将Rust函数暴露给Python
#[pymodule]
fn rustpythondemo(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_wrapped(wrap_pyfunction!(hello_world))?;
    Ok(())
}

这段代码展示了如何使用Pyo3库在Rust中创建一个可以被Python调用的函数。它定义了一个简单的greet函数,并通过hello_world函数暴露给Python,使得Python能够调用Rust编写的代码。这个例子简单明了,并且展示了如何在Rust和Python之间建立高效的互操作性,同时保持代码的简洁性和性能。