Next: 4.6 Function Definitions Up: 4 The Language Previous: 4.4 Statements

4.5 Expressions

4.5.1 Simple Expressions

Simple expressions are:

```
exp( exp )
expnil
expnumber
expliteral
expvar
```
Numbers (numerical constants) and string literals are explained in Section 4.1. Variables are explained in Section 4.4.2.

4.5.2 Arithmetic Operators

Lua supports the usual arithmetic operators. These operators are the binary + , - , * , / and ^ (exponentiation), and the unary - . If the operands are numbers, or strings that can be converted to numbers, according to the rules given in Section 4.2, all operations but exponentiation have the usual meaning. Otherwise, the fallback ``arith'' is called; see Section 4.7. An exponentiation always calls this fallback. The standard mathematical library redefines this fallback, giving the expected meaning to exponentiation; see Section 6.3.

4.5.3 Relational Operators

Lua offers the following relational operators:

```       <   >   <=  >=  ~=  ==
```
All return nil as false and a value different from nil \ (actually the number 1) as true.

Equality first compares the types of its operands. If they are different, the result is nil . Otherwise, their values are compared. Numbers and strings are compared in the usual way. Tables, CFunctions, and functions are compared by reference, that is, two tables are considered equal only if they are the same table. The operator ~= is exactly the negation of equality (== ).

The other operators work as follows. If both arguments are numbers, they are compared as such. Otherwise, if both arguments can be converted to strings, their values are compared using lexicographical order. Otherwise, the fallback ``order'' is called; see Section 4.7.

4.5.4 Logical Operators

All logical operators, like control structures, consider nil as false and anything else as true. The logical operators are:

```             and   or   not
```
The operators and and or use short-cut evaluation, that is, the second operand is evaluated only if necessary.

4.5.5 Concatenation

Lua offers a string concatenation operator, denoted by `` ..''. If operands are strings or numbers, they are converted to strings according to the rules in Section 4.2. Otherwise, the fallback ``concat'' is called; see Section 4.7.

4.5.6 Precedence

Operator precedence follows the table below, from the lower to the higher priority:

```             and   or
<   >   <=  >=  ~=  ==
..
+   -
*   /
not  - (unary)
^
```
All binary operators are left associative, except for ^ , which is right associative.

4.5.7 Table Constructors

Table constructors are expressions that create tables; every time a constructor is evaluated, a new table is created. Constructors can be used to create empty tables, or to create a table and initialize some fields.

The general syntax for constructors is:

```
tableconstructor{ fieldlist }
fieldlistlfieldlist  ffieldlist  lfieldlist ; ffieldlist
lfieldlistlfieldlist1
ffieldlistffieldlist1
```

The form lfieldlist1 is used to initialize lists.

```
lfieldlist1exp , exp ,
```
The expressions in the list are assigned to consecutive numerical indexes, starting with 1. As an example:
```   a = {"v1", "v2", 34}
```
is equivalent to:
```   temp = {}
temp[1] = "v1"
temp[2] = "v2"
temp[3] = 34
a = temp
```

The next form initializes named fields in a table.

```
ffieldlist1ffield , ffield ,
ffieldname = exp
```
As an example:
```   a = {x = 1, y = 3}
```
is equivalent to:
```   temp = {}
temp.x = 1
temp.y = 3
a = temp
```

4.5.8 Function Calls

A function call has the following syntax:
```
functioncallvar realParams
```
Here, var can be any variable (global, local, indexed, etc). If its type is function or CFunction, this function is called. Otherwise, the fallback ``function'' is called, having as first parameter the value of var , and then the original call parameters.

The form:

```
functioncallvar : name realParams
```
can be used to call ``methods''. A call var:name(...) is syntactic sugar for
```  var.name(var, ...)
```
except that var is evaluated only once.

```
realParams( explist1 )
realParamstableconstructor
explist1exp1 , exp1
```
All argument expressions are evaluated before the call; then the list of arguments is adjusted to the length of the list of parameters (see Section 4.3); finally, this list is assigned to the formal parameters. A call of the form f{...} is syntactic sugar for f({...}) , that is, the parameter list is a single new table.

Because a function can return any number of results (see Section 4.4.3), the number of results must be adjusted before used. If the function is called as a statement (see Section 4.4.4), its return list is adjusted to 0. If the function is called in a place that needs a single value (syntactically denoted by the non-terminal exp1 ), its return list is adjusted to 1. If the function is called in a place that can hold many values (syntactically denoted by the non-terminal exp ), no adjustment is done.

Next: 4.6 Function Definitions Up: 4 The Language Previous: 4.4 Statements