Lib.rs

如果您愿意，也可以通过实现 Push 和 LuaRead 特性来添加其他类型。

执行 Lua

let x: u32 = lua.execute("return 6 * 2;").unwrap();    // equals 12

execute 函数接受一个 &str 并返回一个 Result<T, ExecutionError>，其中 T: LuaRead。

您还可以调用execute_from_reader，它接受一个std::io::Read类型的参数。例如，您可以轻松地执行文件内容，如下所示

lua.execute_from_reader::<()>(File::open(&Path::new("script.lua")).unwrap())

编写函数

为了编写一个函数，您必须将其包裹在hlua::functionX中，其中X是参数的数量。这是目前Rust推断系统的限制。

fn add(a: i32, b: i32) -> i32 {
    a + b
}

lua.set("add", hlua::function2(add));
lua.execute::<()>("local c = add(2, 4)");   // calls the `add` function above
let c: i32 = lua.get("c").unwrap();   // returns 6

在Lua中，函数与普通变量完全一样。

您既可以编写普通函数，也可以编写闭包。

lua.set("mul", hlua::function2(|a: i32, b: i32| a * b));

请注意，Lua上下文的生存期必须等于或短于闭包的生存期。这是在编译时强制执行的。

let mut a = 5i;

{
    let mut lua = Lua::new();

    lua.set("inc", || a += 1);    // borrows 'a'
    for i in (0 .. 15) {
        lua.execute::<()>("inc()").unwrap();
    }
} // unborrows `a`

assert_eq!(a, 20)

错误处理

如果您的Rust函数返回一个包含错误的Result对象，则Lua将触发一个错误。

操作Lua表

通过读取LuaTable对象来操作Lua表。这可以通过读取一个LuaTable对象轻松实现。

let mut table: hlua::LuaTable<_> = lua.get("a").unwrap();

然后，您可以使用.iter()函数遍历表。请注意，迭代器返回的值是Option<(Key, Value)>，当键或值无法转换为请求的类型时，Option为空。当处理这种情况时，标准Iterator特质的filter_map函数非常有用。

for (key, value) in table.iter().filter_map(|e| e) {
    ...
}

您还可以检索和修改单个索引。

let x = table.get("a").unwrap();
table.set("b", "hello");

调用Lua函数

您可以通过读取functions_read::LuaFunction来调用Lua函数。

lua.execute::<()>("
    function get_five() 
        return 5
    end");

let get_five: hlua::LuaFunction<_> = lua.get("get_five").unwrap();
let value: i32 = get_five.call().unwrap();
assert_eq!(value, 5);

此对象持有对Lua的可变引用，因此在get_five变量存在时，您不能读取或修改Lua上下文中的任何内容。目前无法存储函数，但将来可能会实现。

读取和写入Rust容器

(注意：目前无法读取所有容器，请见下文)

可以一次性读取和写入整个Rust容器。

lua.set("a", [ 12, 13, 14, 15 ]);
let hashmap: HashMap<i32, f64> = [1., 2., 3.].into_iter().enumerate().map(|(k, v)| (k as i32, *v as f64)).collect();
lua.set("v", hashmap);

如果容器具有单个元素，则索引将是数字。例如，在上面的代码中，12位于索引1处，13位于索引2处，等等。

fn foo() { }
fn bar() { }

lua.set("mylib", [
    ("foo", hlua::function0(foo)),
    ("bar", hlua::function0(bar))
]);

lua.execute::<()>("mylib.foo()");

        let mut lua = Lua::new();

        lua.execute::<()>(r#"v = { 1, 2, 3 }"#).unwrap();

        let read: Vec<_> = lua.get("v").unwrap();
        assert_eq!(
            read,
            [1., 2., 3.].iter()
                .map(|x| AnyLuaValue::LuaNumber(*x)).collect::<Vec<_>>());

let mut lua = Lua::new();

lua.execute::<()>(r#"v = { [-1] = -1, ["foo"] = 2, [2.] = 42 }"#).unwrap();

let read: HashMap<_, _> = lua.get("v").unwrap();
assert_eq!(read[&AnyHashableLuaValue::LuaNumber(-1)], AnyLuaValue::LuaNumber(-1.));
assert_eq!(read[&AnyHashableLuaValue::LuaString("foo".to_owned())], AnyLuaValue::LuaNumber(2.));
assert_eq!(read[&AnyHashableLuaValue::LuaNumber(2)], AnyLuaValue::LuaNumber(42.));
assert_eq!(read.len(), 3);

struct Foo;

impl<L> hlua::Push<L> for Foo where L: hlua::AsMutLua<'lua> {
    fn push_to_lua(self, lua: L) -> hlua::PushGuard<L> {
        lua::userdata::push_userdata(self, lua,
            |mut metatable| {
                // you can define all the member functions of Foo here
                // see the official Lua documentation for metatables
                metatable.set("__call", hlua::function0(|| println!("hello from foo")))
            })
    }
}

fn main() {
    let mut lua = lua::Lua::new();
    lua.set("foo", Foo);
    lua.execute::<()>("foo()");       // prints "hello from foo"
}