# Expressions

SurgeScript supports many kinds of expressions. Expressions may involve strings, numbers or booleans. Let's study each case:

## Constants

Constants are types of expressions. They may be numbers, strings, booleans... You may attribute constant values to variables using the assignment operator (`=`

):

```
// strings
name = "Surge"; // variable name receives string "Surge"
message = "Surge's home";
otherMessage = 'Single-quoted strings are also allowed';
// numbers
weight = 35;
speed = 42.2;
// booleans
like = true;
crazy = false;
// null
next = null;
```

## Arithmetic operators

SurgeScript can perform basic arithmetic. The operators are as follows:

Operator | Meaning |
---|---|

`+` |
Addition |

`-` |
Subtraction |

`*` |
Multiplication |

`/` |
Division |

`%` |
Remainder |

The multiplication, division and remainder operators have precedence over the addition and the subtraction operators.

Examples:

```
two = 1 + 1;
ten = 5 * 2;
eleven = 5 * 2 + 1;
four = two * two;
fifteen = eleven + four;
three = fifteen / 5;
positive = +5;
negative = -1;
zero = 15 - 10 - 5;
one = 15 - (10 + 4);
twelve = (2 + 2) * 3;
prime = -(-15 + 8);
seven = 5 + 5 % 3;
negativeTwo = -5 % 3;
```

## Comparison operators

Comparison operators compare two operands.

Operator | Meaning |
---|---|

`==` |
Equality operator |

`!=` |
Inequality operator |

`<` |
Less than |

`<=` |
Less or equal |

`>` |
Greater than |

`>=` |
Greater or equal |

`===` |
Strong equality |

`!==` |
Strong inequality |

Examples:

```
x = 1;
y = (x == 1); // y is true
z = (x != 1); // z is false
w = x > 1; // w is false
t = x >= 1; // t is true
```

Pay attention!Notice that the equality operator, used for comparing expressions for equality, is

`==`

. Pay attention! Don't confuse the equality operator (`==`

) with the assignment operator (`=`

). The expression`(x = 1)`

always evaluates to 1, whereas`(x == 1)`

is`true`

only if x equals 1.

Strong equalityUnlike their counterparts, strong equality/inequality operators compare not only the content of the operands, but also their type. While

`"1" == 1`

evalutes to`true`

,`"1" === 1`

does not.

## Logical operators

Logical operators involve booleans (`true`

or `false`

values). While the **not** operator requires only one operand, operators **and** and **or** require two.

Operator | Meaning |
---|---|

`&&` |
and |

`||` |
or |

`!` |
not |

The table below summarizes the basic logical expressions:

Expression | Result |
---|---|

`a && b` |
`true` only if both `a` and `b` are true |

`a || b` |
`true` if `a` is true or `b` is true |

`!a` |
`true` if `a` is false, `false` if `a` is true |

Notice that **not** has higher precedence than the other two operators. Examples:

```
x = 5 < 2; // evaluates to false
y = !x; // evaluates to true
z = 18 < 35 || x; // evaluates to true
w = (z && x) || true; // evaluates to true
t = !x && x; // evaluates to false
```

Short-circuit evaluationSurgeScript performs short-circuit evaluation in

andandoroperations. This means that the second operator is not evaluated if the first alone is sufficient to determine the value of the operation. Example: in the expression`a || b`

, expression`b`

is not evaluated if`a`

is evaluated to`true`

. Similarly, in`a && b`

, expression`b`

is not evaluated if`a`

is evaluated to`false`

.

## Textual expressions

You may concatenate strings with the `+`

operator. Example:

```
message = "Surge" + " rocks!"; // evaluates to "Surge rocks!"
```

Other data types, such as numbers and booleans, may also be implicitly converted to strings when using this feature. Example:

```
group = "Jackson " + 5; // evaluates to "Jackson 5"
```

## Assignment operators

The attribution operator (`=`

) may be used to attribute data to variables. However, there's more to it. The expression `variable = "data"`

is itself evaluated to string `"data"`

.

Likewise, the expression `variable = variable + 5`

is evaluated to the new value of the variable and may be shortened to `variable += 5`

.

Let's see what kind of assignment expressions we have:

Expression | Translates to | Meaning |
---|---|---|

`x = value` |
`x = value` |
Assigns `value` to `x` |

`x += value` |
`x = x + value` |
Adds `value` to `x` |

`x -= value` |
`x = x - value` |
Subtracts `value` from `x` |

`x *= value` |
`x = x * value` |
Multiplies `x` by `value` |

`x /= value` |
`x = x / value` |
Divides `x` by `value` |

`x %= value` |
`x = x % value` |
Sets `x` to the remainder of `x / value` |

Example:

```
language = "Surge";
language += "Script";
// language now evaluates to "SurgeScript"
number = 5;
number += 2;
// number now evaluates to 7
```

## Increment and decrement

Increment and decrement operators should be used only on numeric variables.

Expression | Meaning |
---|---|

`x++` |
Increments x by 1 and returns the old value of x |

`x--` |
Decrements x by 1 and returns the old value of x |

`++x` |
Increments x by 1 and returns the new value of x |

`--x` |
Decrements x by 1 and returns the new value of x |

Example:

```
x = 1; // x is 1
y = x++; // y is 1
z = ++x; // z is 3
w = --x; // w is 2
t = --x; // t is 1
Console.print(x); // prints 1
```

## Chained expressions

You may chain assignment operations:

```
x = y = z = 1;
```

## Commas

The comma operator takes two operands. It first evaluates the first operand and then discards the result. Next, it evaluates the second operand and then returns this result. The comma is the operator with the lowest precedence.

```
c = (1, 2); // Results in c = 2
a = 1, b = 2, c = 3; // Results in a = 1, b = 2 and c = 3
d = (c++, a); // Results in c = 4, d = 1
e = (++a, f = 2, 3); // Results in a = 2, e = 3, f = 2
```

## Other expressions

#### this

The keyword `this`

represents the object in which it appears. Example:

```
this.destroy(); // destroys this object
```

#### typeof

The expression `typeof(expr)`

(or simply `typeof expr`

), is evaluated to a string corresponding to the type of `expr`

. The possible types are: *number*, *string*, *boolean*, *object* or *null*. Example:

```
t = typeof 5; // t will hold the string "number"
```

#### timeout

The expression `timeout(seconds)`

is a handy feature of SurgeScript. It is evaluated to `true`

if the object has been on the same state for the specified amount of time or more. It can only be used inside states. Example:

```
object "Application"
{
state "main"
{
if(timeout(2.0)) {
Console.print("2 seconds have passed");
state = "done";
}
}
state "done"
{
}
}
```