Operators

Operator

Purpose

Example

==

Compare LHS and RHS for equality.

if a == b {...}

!=

Compare LHS and RHS for inequality.

if a != b {...}

>

Compare LHS as greater than RHS.

if a > b {...}

<

Compare LHS as less than RHS.

if a < b {...}

>=

Compare LHS as greater than or equal to RHS.

if a >= b {...}

<=

Compare LHS as less than or equial to RHS.

if a <= b {...}

Operator

Purpose

Example

+

Addition / concatenation

var b = a + 5;
var name = 'John ' + 'Doe';

-

Subtraction

var b = a - 5;

-

Unary minus (negation)

var b = -a;

*

Multiplication

var b = a * 5;

/

Division

var b = a / 5;

%

Modulo (remainder)

var b = a % 5;

Operator

Purpose

Example

.

Member access. The expression on the LHS represents the object that contains the member. The name on the RHS is the function, public method, public property, public field, public nested type, etc. that is defined in the LHS code.

import script "B.dino" as B;
from System import object;
from Nature import Animal;

B.foo(5);

var o = object();
var hash = o.GetHashCode();

var dino = Animal();
dino.Name = "T-Rex";
dino.IsCarnivore = true;
var n = dino.Name;

?.

Null-safe member access for the member to the left of the '?'

var x = null;
var a = x.Num; // oops
var b = x?.Num; // ok, null

[]

Indexing operator for accessing a member of an object by an index key

var a = array(1,2);
var x = a[0]; // 1
a[0] = 3;

var d = dict('a':1, 'b':2);
var v1 = d['a']; // 1
var v2 = d['b']; // 2

?[]

Missing key index-safe indexing operator. This operator is safe to use for virtually any member access. It will even safely get the values of built-in properties on objects, or just get null if the key or property doesn’t exist.

var a = array(1,2);
var x = a[10]; // oops
var y = arr?[10]; // null
a?[0] = 3; // ok
a?[10] = 3; // ignored

var d = dict('a':1, 'b':2);
var v1 = d['c']; // oops
var v2 = d?['c']; // null
d?['a'] = 3; // replace value
d?['c'] = 3; // add value
v2 = d?['c']; // 3

Operator

Purpose

Example

=

Assign a value to a symbol or other LHS statement

var x = 10;
person.Name = 'Sam';
someList[0] = 4;

+=

Add the RHS value from the LHS. Also used to add an event handler delegate.

x += 5;
str += 'more';
def handler(sender, e) {...}
obj.Modified += handler;

-=

Subract the RHS value form the LHS. Also used to remove an event handler delegate.

x -= 5;
def handler(sender, e){...}
obj.Modified -= handler;

*=

Multiply the LHS value with the RHS

x *= 5;

/=

Divide the LHS value with the RHS

x /= 5;

++

Postfix increment. Increase LHS by 1.

a++;
var x = 10;
var y = x++; // y == 10, x == 11

--

Postfix decrement. Decrease LHS by 1.

a--;
var x = 10;
var y = x--; // y == 10, x == 9

Operator

Purpose

Example

and

Check LHS and RHS, return true if both LHS and RHS evaluate to truthy. And expressions are short-circuit evaluated: if the LHS is false, the RHS does not need to be evaluated.

var x = 0 and 1; // false
var y = 1 and 3; // true 

or

Check LHS and RHS, return true if either LHS or RHS evaluates to truthy. Or expressions are short-circuit evaluated: if the LHS is true, the RHS does not need to be evaluated.

var x = 0 or 1; // true
var y = 1 or 3; // true
var z = 0 or null; //false

xor

Check LHS and RHS, return true if one and only one of LHS and RHS evaluates to truthy. Xor expressions cannot be short-circuit evaluated.

var x = 0 xor 1; // true
var y = 1 xor 3; // false
var z = 0 xor null; // false

not

Check RHS, returns true if RHS is falsy, false if RHS is truthy. Not is a unary operator.

var x = not 0; // true
var y = not true; // false
var z = not null; // true

?:

Ternary operator, written as expr ? expr : expr. Return the middle expr if LHS is truthy, other if LHS is falsy, return the RHS expr. The ternary operator is a ternary (three-place) expression.

var x = true ? 'yes' : 'no'; // 'yes'
var y = 0 ? 5 : 10; // 10

??

Null-coalescing operator. Return LHS if LHS is non-null, otherwise RHS. Note that this operator only works with null values, it does not follow the "truthiness" tests of the other logical operators. Short-circuit evaluated.

var a = 3 ?? 4; // 3
var b = null ?? 4? // 4
var c = null ?? null; // null

Operator

Purpose

Example

&

Bitwise AND

var t1 = T.All & T.Opt1; // T.Opt1
var t2 = T.Opt1 & T.Opt2; // 0
var t3 = T.All & ~T.Opt2; // Opt1, Opt3

|

Bitwise OR

var t1 = T.Opt1 | T.Opt2; // Opt1, Opt2
var t2 = T.All | T.Opt1 // T.All

~

Bitwise NOT

var t1 = T.All & ~T.Opt1; // Opt2, Opt3

&=

Bitwise AND reassignment

var t1 = T.All;
t1 &= ~T.Opt2; // Opt1, Opt3|

|=

Bitwise OR reassignment

var t1 = T.Opt1;
t1 |= T.Opt3; // Opt1, Opt3