Operators

The function call operator

You can call a function using its name and a comma-separated list of arguments passed to it in parentheses.

function-name(argument?(,argument)*);

Parameter	Description
function-name (required)	The name of the function that you're calling.
argument	An argument that you pass the function.

The order, number, and type of arguments that you pass a function when invoking it needs to conform to the function's definition.

Even if a function does not take any arguments, the parentheses are required to call it.

The indexing operator

Use square brackets [] as a shorthand of the GetAt and SetAt type methods. On the data types for which these methods are defined, you can get or set specific values.

For lists, get or set values at specific indexes.

operatorSample.rfs

// access indexed list values
var c = [43, 42, 41];
trace c[0], c[2];
// re-set indexed list values
c[0] = "Moist von Lipwig";
trace c[0];

43, 41
"Moist von Lipwig"

Figure 309. The trace message output of the script above

For strings, use the [] operator to access characters at specific indexes.

operatorSample.rfs

c[0] = "Moist von Lipwig";
...
// access characters at string indexes
trace c[0][3];

"s"

Figure 310. The trace message output of the script above

However, since the SetAt method is not defined for string type objects, you cannot redefine string characters at specific indexes using the [] operator either.

operatorSample.rfs

/* no SetAt method for strings
var d = c[0];
d[3] = "e";
trace d; */

For maps, use the [] operator to get or set the values associated with specific keys.

operatorSample.rfs

// access values associated with specific map keys
var f = { name: c[0], age: 33, occupation: "postman"};
trace f;
trace "Age:", f["age"];
// reset values associated with specific map keys
f["occupation"] = "man of mystery";
trace "Occupation:", f["occupation"];

{name: "Moist von Lipwig", age: 33, occupation: "postman"}
"Age:", 33
"Occupation:", "man of mystery"

Figure 311. The trace message output of the script above

Note that square brackets can also instantiate list literals.

The dot operator

Use the . operator to access members of an object to get or set values of fields or invoke methods.

operatorSample.rfs

// accessing the New method of the timespan type
var a = timespan.New(4, 3, 2, 1, 60);
trace a;
// accessing the Minutes field of a timespan
trace a.Minutes;
// accessing a member of a map
var b = { name: "Rincewind" };
trace b.name;
// access and set a map member
b.name = "Didactylos";
trace b.name;

2
"Rincewind"
"Didactylos"

Figure 312. The trace message output of the script above

Logical and comparison operators in order of precedence

Logical OR

The logical OR || binary operator takes boolean operands, and returns the boolean value true if either operand is true and false otherwise. It has left-to-right associativity, and the right-hand-side operand is not evaluated if the left-hand-side evaluates to true.

operatorSample.rfs

trace 5 > 3 || "This won't be evaluated.";

true

Logical AND

The logical AND && binary operator takes boolean operands, and returns the boolean value true if both operands are true and false otherwise. It has left-to-right associativity, and the right-hand-side operand is not evaluated if the left-hand-side evaluates to false.

operatorSample.rfs

trace 3 > 5 && "This won't be evaluated.";

false

Logical NOT

The logical NOT ! unary operator takes a bool operand and returns its opposite bool.

operatorSample.rfs
trace !(8 > 4);

false

Function call, the indexing, and the dot operators have precedence over logical and comparison operators.

Arithmetic operators in order of precedence

Unary negation

The negative sign - unary operator takes int or float operands and changes the sign but not the type of their operands.

operatorSample.rfs

var cat = 7.89;
var dog = -cat;
trace "This is dog", dog;
trace "This is not dog", -dog;

"This is dog", -7.89
"This is not dog", 7.89

Multiplication

The multiplication * and division / binary operators take int or float type operands. If one or both operands is a float, they return a float value, otherwise the result is an int.

operatorSample.rfs
trace 62 * 15;

Division

The multiplication * and division / binary operators take int or float type operands. If one or both operands is a float, they return a float value, otherwise the result is an int.

operatorSample.rfs
trace 62 / 15;

Addition

The addition + binary operator takes int, float, string, dtl, dtu, or timespan values in specific combinations. The type of the returned value is determined by the particular combination. When adding the result will be an int unless any of the operands is a float.

operatorSample.rfs
trace 4.56 + 16;

20.56

Addition is valid for strings. The result will be a concantenated string.

operatorSample.rfs
trace "Hello " + "World!";

"Hello World!"

timespan values can be added to dtu and dtl values. The result will be a dtu or dtl depending on the non-timespan operand.

operatorSample.rfs

trace dtu.Now() + timespan.New(4,3,2,1,60);
trace dtl.Now() + timespan.New(4,3,2,1,60);

2015.10.11. 14:05:31 (Dtu) 
2015.10.11. 16:05:31 (Dtl)

timespan values may be added to each other, resulting in a third timespan value.

operatorSample.rfs

trace timespan.New(4,3,2,1,60) + timespan.New(1,2,3,4,56);

5.05:05:05.1160000

Subtraction

The subtraction - binary operator takes int, float, string, dtl, dtu, or timespan values in specific combinations. The type of the returned value is determined by the particular combination. When or subtracting numbers, the result will be an int unless any of the operands is a float.

operatorSample.rfs
trace 16 - 20;

-4

Subtraction is valid for dtu and dtl values. The result will be a timespan.

operatorSample.rfs

trace dtu.Now() - dtu.New(2000, 3, 12, 6, 45, 32, 43);

5687.04:17:58.0340000

timespan values can be subtracted from dtu and dtl values. The result will be a dtu or dtl depending on the non-timespan operand.

operatorSample.rfs

trace dtl.Now() - timespan.New(4,3,2,1,60);

2015.10.03. 10:01:29 (Dtl)

timespan values may be subtracted from each other, resulting in a third timespan value.

operatorSample.rfs

trace timespan.New(4,3,2,1,60) - timespan.New(1,2,3,4,56);

3.00:58:57.0040000

Less than <, greater than >, less than or equal to <=, greater than or equal to >=

The less than <, greater than >, less than or equal to <=, and greater than or equal to >= binary operators take operands of int, float, dtl, or dtu type and return a bool value.

operatorSample.rfs

var baz = 25 < 42;
trace baz;
trace (8 > 3 && 3 >= 3.2) || (4 <= 4.5 || 3 < 23.3);

"This is true", "true"
"This is true also", true

Equality and inequality

The equality == and inequality != binary operators take operands of any type, and return a bool value based on whether the two operands are equal or not. ints and floats are treated as the same type for equality purposes.

operatorSample.rfs

var foo = 3;
var bar = "3";
trace "This is true", foo == float.Parse(bar);
trace "This is false", foo != foo;

"This is true", true;
"This is false", false;

Using the equality or inequality operators with operands of differing types results in a runtime error.

operatorSample.rfs

var foo = 3;
...
/* throws a runtime error
trace foo == foo.ToString(); */

Function call, the indexing, and the dot operators have precedence over both logical and arithmetic operators.

Developer Documentation

Language basics