Nasal Conditionals: Difference between revisions

Sometimes you may only want to execute certain portions of your code, depending on conditions. This can be accomplished in several ways. One of the most straightforward ways  being an '''if''' expression, which  has the form:

var condition=1; # this evaluates to boolean true

if (condition) {

To negate the whole thing, use the '''!''' operator:

var condition=1; # boolean true

if (!condition) {

In both examples, the '''condition''' variable is just a placeholder, it could be a variable named '''condition''', but it could also be a more complex expression, such as a '''getprop''' call for example:

var condition = getprop("/sim/signals/freeze");

if (var condition = getprop("/sim/signals/freeze")) {

     # true block, will  be executed if condition is true

if (getprop("/sim/signals/freeze")) {

     # true block, will  be executed if condition is true

* '''or'''

var condition = (1==1 and 2==2 and 3==3) or (4!=5 and !0);

if (condition) {

The last semicolon in a code block is optional, to make this prettier:

var abs = func(n) {  

     if(n<0)  

And for those who don't like typing, the ternary operator works like you expect:

var abs = func(n) { n < 0 ? -n : n }

</syntaxhighlight>

In addition, Nasal supports braceless blocks, like they're known from C/C++ and other languages. Basically, the block ends with a semicolon, instead of being encapsulated inside a <tt>{</tt>/<tt>}</tt> pair. This means basically that the first statement (expression) after a conditional is evaluated if the condition is true, otherwise it will be ignored:

var foo=1;

if (foo)

Instead of a switch statement one can use

if (1==2) {

     print("wrong");

Instead of "else if", you can also use the shorter equivalent form "elsif":

if (1==2) {

     print("wrong");

The <tt>nil</tt> logic is actually quite logical, let's just restate the obvious:

if (nil) {

     print("This should never be printed");

Nasal's binary boolean operators are "and" and "or", unlike C. Unary not is still "!" however. They short-circuit like you expect:

var toggle = 0;

var a = nil;

Note that you should always surround multiple conditions within outer parentheses:

if (1) do_something();

if (1 and 1) do_something();

Nasal's binary boolean operators can also be used to default expressions to certain values:

var altitude = getprop("/position/altitude-ft") or 0.00;

</syntaxhighlight>

At first, this may seem pretty complex and counter-intuitive - but it's important to keep this technique in mind, especially for variables that are later on used in calcuations:

var x = getprop("/velocities/airspeed-kts") or 0.00; # to ensure that x is always valid number

var foo = 10*3.1*x; # ... for this computation

Bottom line being, using "or" to default a variable to a given value is a short and succinct way to avoid otherwise elaborate checks, e.g. compare:

var altitude_ft = getprop("/position/altitude-ft");

if (altitude_ft == nil) {

versus:

var altitude_ft = getprop("/position/altitude-ft") or 0.00;

</syntaxhighlight>

Nasal is a language that has no statements, it's all about EXPRESSIONS. So you can put things in pretty much arbitrary places.

var do_something = func return 0;

if (a==1) {

In a boolean comparison, 1 always means "true" while 0 always means "false". For instance, ANY comparison with if x ==1 can be abbreviated to if (x), because the ==1 check is implictly done:

var do_something = func return 0;

( a and do_something() ) or print("failed");

You can easily reduce the complexity of huge conditional (IF) statements, such as this one:

if (a==1) function_a();

else

.. just by using the variable as a key (index) into a hash, so that you can directly call the corresponding function:

var mapping = {1:function_a, 2:function_b, 3:function_c, 4:function_d,5:function_e};

mapping[a] ();

Using this technique, you can reduce the complexity of huge conditional blocks. For example, consider this extract from weather_tile_management.nas:

if (code == "altocumulus_sky"){weather_tiles.set_altocumulus_tile();}

else if (code == "broken_layers") {weather_tiles.set_broken_layers_tile();}

While this is not a very complex or huge block of code, it is an excellent example for very good naming conventions used already, because the consistency of naming variables and functions can pay off easily here, with just some very small changes, you can already reduce the whole thing to a hash lookup like this:

weather_tiles["set_"~code~"_tile"]();  # naming convention

</syntaxhighlight>

But these are very simple changes to do (just renaming these functions to match the existing conventions). When you do that, you can easily replace such huge IF statements and replace them with a single hash lookup and function call:

hash[key] (arguments...);

</syntaxhighlight>

For example, consider:

var makeFuncString = func(c) return tolower("set_"~c~"_tile");

var isFunc = func(f) typeof(f)=='func';