3.2 KiB
Export Variables, Functions and Sub-Modules From a Script
{{#include ../../links.md}}
See [_Create a Module from AST_]({{rootUrl}}/rust/modules/ast.md) for more details.
The easiest way to expose a collection of [functions] as a self-contained [module] is to do it via a Rhai script itself.
The script text is evaluated.
[Variables] are then selectively exposed via the export statement.
[Functions] defined by the script are automatically exported, unless marked as private.
Modules loaded within this [module] at the global level become sub-modules and are also automatically exported.
Export Global Variables
The export statement, which can only be at global level, exposes a selected [variable] as member of a [module].
[Variables] not exported are private and hidden. They are merely used to initialize the [module], but cannot be accessed from outside.
Everything exported from a [module] is [constant] (i.e. read-only).
// This is a module script.
let hidden = 123; // variable not exported - default hidden
let x = 42; // this will be exported below
export x; // the variable 'x' is exported under its own name
export const x = 42; // convenient short-hand to declare a constant and export it
// under its own name
export let x = 123; // variables can be exported as well, though it'll still be constant
export x as answer; // the variable 'x' is exported under the alias 'answer'
// another script can load this module and access 'x' as 'module::answer'
{
let inner = 0; // local variable - it disappears when the statements block ends,
// therefore it is not 'global' and cannot be exported
export inner; // <- syntax error: cannot export a local variable
}
[Variables] can be exported under multiple names.
For example, the following exports three [variables]:
* `x` as `x` and `hello`
* `y` as `foo` and `bar`
* `z` as `z`
~~~js
export x;
export x as hello;
export y as foo;
export x as world;
export y as bar;
export z;
~~~
Export Functions
`private` [functions] are commonly called within the [module] only.
They cannot be accessed otherwise.
All [functions] are automatically exported, unless it is explicitly opt-out with the private prefix.
[Functions] declared private are hidden to the outside.
// This is a module script.
fn inc(x) { x + 1 } // script-defined function - default public
private fn foo() {} // private function - hidden
Sub-Modules
All loaded [modules] are automatically exported as sub-modules.
To prevent a [module] from being exported, load it inside a block statement so that it goes away at the
end of the block.
```js
// This is a module script.
import "hello" as foo; // <- exported
{
import "world" as bar; // <- not exported
}
```