Lua tutorial (III): Expressions and statements

1. Expression:

    1. Arithmetic operator:
Lua supports conventional arithmetic operators: binary "+", "-", "*", "/", "^" (index), "%" (module), and mono-" (negative sign). All of these operators can be used for real numbers. However, it should be specifically noted that the modulo operator (%) is defined in Lua as:
 

From this we can deduce that the result of x %1 is the decimal part of x, while the result of x - x %1 is the integer part of x. Similarly, x - x % 0.01 is the result of x being accurate to two decimal places.
    
    2. Relational operators:
Lua supports relational operators: >, <, >=, <=, ==, ~=, and the results of all these operators are true or false.
Operator == is used for equality testing, operator ~= is used for inequality testing. These two operators can be applied to any two values. If the two values ​​have different types, Lua thinks they are not equal. nil value is equal to itself. For table, userdata, and functions, Lua is compared by reference. That is, they are considered equal only when they refer to the same object. like:

The result is a == c, but a ~= b.
For string comparisons, Lua is compared in character order.
    
3. Logical operators:

The logical operators supported by Lua are: and, or and not. Like conditional control statements, all logical operators treat false and nil as false, and other results are true. Like most other languages, and and or in Lua use the "short circuit principle". There is an idiomatic way of writing "x = x or v" in Lua, which is equivalent to: if not x then x = v end. There is also an idiomatic writing method based on the "short circuit principle", such as:
 

This is equivalent to max = (x > y) ? x : y in C. Since both x and y are numeric values, their results will always be true.
    
    4. String concatenation:
The previous blog has mentioned the string concatenation operator (..), and here are some simple examples.
 
> print(0 .. 1) --Even if the operand of the connection operator is a numeric type, Lua will automatically convert it to a string when executed.
    01

   5. Table constructor:

The constructor is used to build and initialize table expressions. This is a unique expression of Lua and one of the most useful and general mechanisms in Lua. The simplest constructor is the empty constructor {}, which is used to create an empty table. We can also initialize arrays through constructors, such as:

From the output results, we can see that days will be automatically initialized after construction, where days[1] is initialized to "Sunday", days[2] is "Monday", and so on.
Another special syntax is also provided in Lua for initializing the record style table. For example: a = { x = 10, y = 20 }, which is equivalent to: a = {}; = 10; = 20
In actual programming, we can also combine these two initialization methods together, such as:

In addition to the above two construction initialization methods, Lua also provides another more general method, such as:

For table constructors, there are two syntax rules that need to be understood, such as:
 
Here we need to note that commas (,) can still be retained after the last element, which is similar to enums in C.
 
You can see that the above declaration has both comma (,) and semicolon (;) element separators, which are allowed in Lua. We usually use semicolons (;) to separate elements of different initialization types. For example, in the example above, the initialization method before the semicolon is the record initialization method, and the subsequent array initialization method.

2. Statement:

    1. Assignment statement:

The assignment statements in Lua are basically the same as other programming languages. The only difference is that Lua supports "multiple assignment", such as: a, b = 10, 2 * x, which is equivalent to a = 10; b = 2 * x. However, it should be noted that Lua needs to calculate the expression on the right of the equal sign before assigning, and then assign the value after each expression has obtained the result. Therefore, we can write variable interaction like this: x,y = y,x. If the number of expressions on the right side of the equal sign is less than the number of variables on the left, Lua will set the value of the extra variable on the left to nil. If the opposite is true, Lua will ignore the extra expressions on the right.

2. Local variables and blocks:

The definition syntax of local variables in Lua is: local i = 1, where the local keyword means that the variable is a local variable. Unlike global variables, the scope of action of local variables is limited to the program block where they are located. The program in Lua can be an executor body, a function executor body or a program block of the control structure, such as:
The following x variable is only valid in the while loop.

If it is in interactive mode, when local x = 0 is executed, the program where the variable x is located ends, and the subsequent Lua statement will be regarded as a new program block. If we want to avoid such problems, we can explicitly declare the program block so that even in interactive mode, local variables can still maintain their validity within the block, such as:

Like other programming languages, try to use local variables if possible to avoid contaminating variable names in the global environment. At the same time, because the validity period of local variables is shorter, the garbage collector can clean them up in time, thereby obtaining more available memory.

   3. Control structure:
The control statements provided in Lua are basically the same as those provided by most other development languages, so here is just a simple list. Then give a detailed introduction to the differences. like:
    1). if then else
 

    2). if elseif else then
 
    3). while
 
    4). repeat
 
    5). for
 
It should be noted that the three variables begin, end and step at the beginning of the for loop will be executed only once if they make the expression return value. Another thing is not to modify the value of the variable var in the for loop body, otherwise it will lead to unpredictable results.
    
    6). foreach
 
See the following example code:
 

   7). break
It is exactly the same as the break semantics in C language, that is, it breaks out of the innermost loop.