快捷導(dǎo)航

Rust動態(tài)調(diào)用字符串定義的Rhai函數(shù)方式

更新時間：2025年02月26日 11:29:45 作者：許野平

Rust中使用Rhai動態(tài)調(diào)用字符串定義的函數(shù),通過eval_expression_with_scope實現(xiàn),但參數(shù)傳遞和函數(shù)名處理有局限性,使用FnCall功能更健壯,但更復(fù)雜,總結(jié)提供了更通用的方法,但需要處理更多錯誤情況

Rust動態(tài)調(diào)用字符串定義的Rhai函數(shù)

在 Rust 中使用 Rhai 腳本引擎時，你可以動態(tài)地調(diào)用傳入的字符串表示的 Rhai 函數(shù)。

Rhai 是一個嵌入式腳本語言，專為嵌入到 Rust 應(yīng)用中而設(shè)計。

這是一個基本示例

展示了如何在 Rust 中調(diào)用用字符串傳入的 Rhai 函數(shù)。

首先，確保你已經(jīng)將 Rhai 添加到你的 Cargo.toml 文件中：

[dependencies]
rhai = "0.19"  # 請檢查最新版本號

然后，你可以使用以下代碼來調(diào)用用字符串傳入的 Rhai 函數(shù)：

use rhai::{Engine, EvalAltResult, FnPtr, Module, Scope};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 創(chuàng)建一個 Rhai 引擎實例
    let mut engine = Engine::new();

    // 定義一個 Rhai 模塊，其中包含一些函數(shù)
    let mut module = Module::new();
    module.insert_fn("greet", |name: String| format!("Hello, {}", name));
    module.insert_fn("add", |a: i32, b: i32| a + b);

    // 將模塊注冊到引擎中
    engine.register_module(module)?;

    // 創(chuàng)建一個作用域
    let mut scope = Scope::new();

    // 示例：要調(diào)用的函數(shù)名及其參數(shù)
    let function_name = "greet".to_string();
    let args: Vec<Box<dyn FnPtr>> = vec![Box::new(|_| "World".to_string()) as Box<dyn FnPtr>];

    // 調(diào)用函數(shù)
    let result: EvalAltResult = engine.eval_expression_with_scope(
        &format!("({})", function_name),
        &mut scope,
        args.iter().cloned().collect::<Vec<_>>(),
    )?;

    // 打印結(jié)果
    match result {
        EvalAltResult::Value(value) => println!("Result: {}", value.render()?),
        _ => println!("Result is not a value"),
    }

    Ok(())
}

然而，上面的代碼有一些限制和簡化的地方：

參數(shù)傳遞：在上面的示例中，參數(shù)傳遞是通過創(chuàng)建一個 FnPtr 的向量并傳遞給 eval_expression_with_scope 實現(xiàn)的。但這種方法比較繁瑣，并且只適用于簡單的函數(shù)簽名。
函數(shù)名處理：函數(shù)名是通過字符串格式化直接嵌入到表達式中的，這意味著你需要確保傳入的函數(shù)名是安全的（即不會導(dǎo)致 Rhai 執(zhí)行不安全的代碼）。

一個更健壯的方法是使用 Rhai 的 FnCall 功能，但這需要更多的設(shè)置和錯誤處理。

這是一個更通用的方法，但稍微復(fù)雜一些

use rhai::{Engine, EvalAltResult, Module, Scope};
use rhai::serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct CallArgs {
    func: String,
    args: Vec<String>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 創(chuàng)建一個 Rhai 引擎實例
    let mut engine = Engine::new();

    // 定義一個 Rhai 模塊，其中包含一些函數(shù)
    let mut module = Module::new();
    module.insert_fn("greet", |name: String| format!("Hello, {}", name));
    module.insert_fn("add", |a: i32, b: i32| a + b);

    // 將模塊注冊到引擎中
    engine.register_module(module)?;

    // 創(chuàng)建一個作用域
    let mut scope = Scope::new();

    // 示例：要調(diào)用的函數(shù)名及其參數(shù)
    let call_args = CallArgs {
        func: "greet".to_string(),
        args: vec!["Alice".to_string()],
    };

    // 將參數(shù)轉(zhuǎn)換為 Rhai 值
    let rhai_args: rhai::Array = call_args.args.into_iter().map(|arg| rhai::Value::from(arg)).collect();

    // 定義一個臨時的 Rhai 函數(shù)來調(diào)用目標函數(shù)
    let call_code = format!(
        r#"
        fn call_func(func_name: String, args: Array) -> Any {{
            let func = match func_name.as_str() {{
                "greet" => greet,
                "add" => add as fn(i32, i32) -> i32,
                _ => return "Function not found".into(),
            }};
            
            match (func, args.len()) {{
                (greet, 1) => greet(args[0].cast::<String>()?),
                (add, 2) => add(args[0].cast::<i32>()?, args[1].cast::<i32>()?),
                _ => return "Invalid argument count".into(),
            }}
        }}
        call_func("{}", {})
        "#,
        call_args.func, rhai_args
    );

    // 調(diào)用函數(shù)
    let result: EvalAltResult = engine.eval_expression(&call_code, &mut scope)?;

    // 打印結(jié)果
    match result {
        EvalAltResult::Value(value) => println!("Result: {}", value.render()?),
        _ => println!("Result is not a value"),
    }

    Ok(())
}

在這個更通用的示例中，我們定義了一個 CallArgs 結(jié)構(gòu)體來存儲函數(shù)名和參數(shù)，然后構(gòu)建了一個臨時的 Rhai 腳本，該腳本根據(jù)函數(shù)名和參數(shù)數(shù)量調(diào)用相應(yīng)的 Rhai 函數(shù)。

這種方法提供了更大的靈活性，但也更復(fù)雜，并且需要處理更多的錯誤情況。