117 lines
3.2 KiB
Markdown
117 lines
3.2 KiB
Markdown
Export Variables, Functions and Sub-Modules From a Script
|
|
=========================================================
|
|
|
|
{{#include ../../links.md}}
|
|
|
|
```admonish info.side "See also"
|
|
|
|
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).
|
|
|
|
```js
|
|
// 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
|
|
}
|
|
```
|
|
|
|
```admonish tip.small "Tip: Multiple exports"
|
|
|
|
[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
|
|
----------------
|
|
|
|
```admonish info.side "Private 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.
|
|
|
|
```rust
|
|
// 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.
|
|
|
|
~~~admonish tip.small "Tip: Skip exporting a module"
|
|
|
|
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
|
|
}
|
|
```
|
|
~~~
|