98 lines
2.4 KiB
Markdown
98 lines
2.4 KiB
Markdown
`eval` Function
|
|
===============
|
|
|
|
{{#include ../links.md}}
|
|
|
|
Or "How to Shoot Yourself in the Foot even Easier"
|
|
--------------------------------------------------
|
|
|
|
Saving the best for last, there is the ever-dreaded... `eval` [function]!
|
|
|
|
```rust
|
|
let x = 10;
|
|
|
|
fn foo(x) { x += 12; x }
|
|
|
|
let script =
|
|
"
|
|
let y = x;
|
|
y += foo(y);
|
|
x + y
|
|
";
|
|
|
|
let result = eval(script); // <- look, JavaScript, we can also do this!
|
|
|
|
result == 42;
|
|
|
|
x == 10; // prints 10 - arguments are passed by value
|
|
y == 32; // prints 32 - variables defined in 'eval' persist!
|
|
|
|
eval("{ let z = y }"); // to keep a variable local, use a statements block
|
|
|
|
print(z); // <- error: variable 'z' not found
|
|
|
|
"print(42)".eval(); // <- nope... method-call style doesn't work with 'eval'
|
|
```
|
|
|
|
~~~admonish danger.small "`eval` executes inside the current scope!"
|
|
|
|
Script segments passed to `eval` execute inside the _current_ [`Scope`], so they can access and modify
|
|
_everything_, including all [variables] that are visible at that position in code!
|
|
|
|
```rust
|
|
let script = "x += 32";
|
|
|
|
let x = 10;
|
|
eval(script); // variable 'x' is visible!
|
|
print(x); // prints 42
|
|
|
|
// The above is equivalent to:
|
|
let script = "x += 32";
|
|
let x = 10;
|
|
x += 32;
|
|
print(x);
|
|
```
|
|
|
|
`eval` can also be used to define new [variables] and do other things normally forbidden inside
|
|
a [function] call.
|
|
|
|
```rust
|
|
let script = "let x = 42";
|
|
eval(script);
|
|
print(x); // prints 42
|
|
```
|
|
|
|
Treat it as if the script segments are physically pasted in at the position of the `eval` call.
|
|
~~~
|
|
|
|
~~~admonish warning.small "Cannot define new functions"
|
|
|
|
New [functions] cannot be defined within an `eval` call, since [functions] can only be defined at
|
|
the _global_ level!
|
|
~~~
|
|
|
|
~~~admonish failure.small "`eval` is evil"
|
|
|
|
For those who subscribe to the (very sensible) motto of ["`eval` is evil"](http://linterrors.com/js/eval-is-evil),
|
|
disable `eval` via [`Engine::disable_symbol`][disable keywords and operators].
|
|
|
|
```rust
|
|
// Disable usage of 'eval'
|
|
engine.disable_symbol("eval");
|
|
```
|
|
~~~
|
|
|
|
|
|
~~~admonish question.small "Do you regret implementing `eval` in Rhai?"
|
|
|
|
Or course we do.
|
|
|
|
Having the possibility of an `eval` call disrupts any predictability in the Rhai script,
|
|
thus disabling a large number of optimizations.
|
|
~~~
|
|
|
|
```admonish question.small "Why did it then???!!!"
|
|
|
|
Brendan Eich puts it well: "it is just too easy to implement." _(source wanted)_
|
|
```
|