Rust：如何动态调用字符串定义的 Rhai 函数？

在 Rust 中使用 Rhai 脚本引擎时，你可以动态地调用传入的字符串表示的 Rhai 函数。Rhai 是一个嵌入式脚本语言，专为嵌入到 Rust 应用中而设计。以下是一个基本示例，展示了如何在 Rust 中调用用字符串传入的 Rhai 函数。

首先，确保你已经将 Rhai 添加到你的 Cargo.toml 文件中：

[dependencies]
rhai = "0.19"  # 请检查最新版本号

然后，你可以使用以下代码来调用用字符串传入的 Rhai 函数：

use rhai::{Engine, EvalAltResult, FnPtr, Module, Scope};fn main() -> Result<(), Box<dyn std::error::Error>> {// 创建一个 Rhai 引擎实例let mut engine = Engine::new();// 定义一个 Rhai 模块，其中包含一些函数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)?;// 创建一个作用域let mut scope = Scope::new();// 示例：要调用的函数名及其参数let function_name = "greet".to_string();let args: Vec<Box<dyn FnPtr>> = vec![Box::new(|_| "World".to_string()) as Box<dyn FnPtr>];// 调用函数let result: EvalAltResult = engine.eval_expression_with_scope(&format!("({})", function_name),&mut scope,args.iter().cloned().collect::<Vec<_>>(),)?;// 打印结果match result {EvalAltResult::Value(value) => println!("Result: {}", value.render()?),_ => println!("Result is not a value"),}Ok(())
}

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

1. 参数传递：在上面的示例中，参数传递是通过创建一个 FnPtr 的向量并传递给 eval_expression_with_scope 实现的。但这种方法比较繁琐，并且只适用于简单的函数签名。
2. 函数名处理：函数名是通过字符串格式化直接嵌入到表达式中的，这意味着你需要确保传入的函数名是安全的（即不会导致 Rhai 执行不安全的代码）。

一个更健壮的方法是使用 Rhai 的 FnCall 功能，但这需要更多的设置和错误处理。以下是一个更通用的方法，但稍微复杂一些：

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>> {// 创建一个 Rhai 引擎实例let mut engine = Engine::new();// 定义一个 Rhai 模块，其中包含一些函数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)?;// 创建一个作用域let mut scope = Scope::new();// 示例：要调用的函数名及其参数let call_args = CallArgs {func: "greet".to_string(),args: vec!["Alice".to_string()],};// 将参数转换为 Rhai 值let rhai_args: rhai::Array = call_args.args.into_iter().map(|arg| rhai::Value::from(arg)).collect();// 定义一个临时的 Rhai 函数来调用目标函数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);// 调用函数let result: EvalAltResult = engine.eval_expression(&call_code, &mut scope)?;// 打印结果match result {EvalAltResult::Value(value) => println!("Result: {}", value.render()?),_ => println!("Result is not a value"),}Ok(())
}

在这个更通用的示例中，我们定义了一个 CallArgs 结构体来存储函数名和参数，然后构建了一个临时的 Rhai 脚本，该脚本根据函数名和参数数量调用相应的 Rhai 函数。这种方法提供了更大的灵活性，但也更复杂，并且需要处理更多的错误情况。