Hola nuevamente, sigo aportando a este que espero sea un gran tutorial al finalizarlo :D
Bueno, hemos visto lo que son las variables y sus tipos, sabemos que podemos almacenar datos en ellas y luego acceder a estos datos con tan sólo escribir el nombre de la variable, pues lo que explicaré en esta entrega son las operaciones que se pueden realizar entre ellas.

Las operaciones por lo general se realizan escribiendo el nombre de dos variables (operandos) y entre ellas una palabra reservada o símbolo (operador), ya sea esta una operación matemática (+ suma, - resta, * multiplicación y / división) o una operación lógica.

Lo que veremos aquí son las operaciones lógicas, ya que nos servirán luego para usarlas en condicionales; En Lua disponemos de los siguientes operadores de comparación:

A == B -- será verdadero si A es igual a B
A ~= B -- será verdadero si A es diferente de B
A != B -- es lo mismo que A ~= B, sólo disponible en LuaDEV
A > B -- verdadero sólo si A es mayor que B
A < B -- verdadero sólo si A es menor que B
A >= B -- verdadero si A es mayor o igual que B
A <= B -- verdadero si A es menor o igual que B
A -- verdadero si A existe, es decir, si a es distinto de nil (vacio o nulo) y distinto de false (falso)

Estas operaciones dan como resultado SIEMPRE un valor true (verdadero) o false (falso), por tanto se lo puede usar en condiciones de estructuras de control que veremos más adelante.

Pero esos no son todos, también tenemos estos:

A or B: El operador or, comprueba si el operando A es nil (vacio o nulo) o false (falso), si lo es, el resultado será B, caso contrario será A.

Aquí van algunos ejemplos:

5 or 10 -> 5
2 or mostrar() -> 2
nil or "b" -> "b"
"nil" or 20 -> "nil"
false or 20 -> 20
false or true -> true
nil or false -> false

Nota: si al hacer mentalmente la operación "nil" or 20 les dio como resultado 20, deberían leer de nuevo en la Entrega 1 la parte de tipos de variables, ya que cualquier texto entre comillas dobles (" ") o simples (' '), es una variable de tipo string (texto) y no un nil (vacio o nulo)

A and B: El operador and, comprueba si A es nil (vacio o nulo) o false (falso), si lo es, el resultado será A, caso contrario será B. Ejemplos:

5 and 10 -> 10
2 and mostrar() -> mostrar()
nil and "b" -> nil
"nil" and 20 -> 20
false and 20 -> false
false and true -> false
nil and false -> nil

Con esto podemos definir dos relaciones muy importantes:

true and true -> true
false or false -> false

Sólo esos casos darán esos resultados, cualquier variación en sus operandos hará que el resultado sea el contrario.

Y por último tenemos el operador not

not A: Este operador a diferencia de los otros, solo acepta un operando, situado a su derecha, y su resultado será solo true o false. Si A es nil (vacio o nulo) o false (falso), el resultado será true, cualquier otra cosa dará false. Ejemplos:

not nil -> true
not "C" -> false
not false -> true
not true -> false

Nota: Los operandos, no son siempre variables, números, "strings", trues o falses, pueden ser más operaciones lógicas, una dentro de la otra, por ejemplo:

not (A == B) -> equivale a: A ~= B
not ((A or B) and (C or D))

Recomendación: Sería bueno adoptar la costumbre de usar paréntesis, ya que así queda más claro que operación se realizará primero, las internas y luego las externas con los resultados obtenidos.

Un poco de avanzado, operaciones binarias sólo disponibles en LuaDEV:

Si bien tenemos operaciones lógicas con palabras reservadas (and, or, not), también tenemos operaciones con símbolos, pero estos se usan para operaciones en binario, por lo tanto los operandos deberán ser del tipo number y sin importar la base con que se lo escriba, la operación se realizará en binario; Aquí 0 es un valor lógico que representa a false y 1 representará true.

AND: En binario, el operador and se lo representa con el símbolo "&", y obedece la relación que establecimos arriba (true and true = true, el resto es false).

Como he dicho, no debemos fijarnos en la base del número, sino a su valor en binario ya que entre los bits del mismo se realizará la operación. Ejemplo:

a = 5 -- 5 en binario es 101
b = 3 -- 3 en binario es 11

Para realizar la operación a & b se los dispone en columnas y se realiza la operación entre los bits una vez alineados:

1 0 1
0 1 1
------
0 0 1
 
1 & 0 (true and false) = 0 (false)
0 & 1 (false and true) = 0 (false)
1 & 1 (true and true) = 1 (true)
 
001 en base 10 es 1, por lo tanto 5 & 3 = 1

OR: Este operador en binario se lo representa con "|" y obedece a la otra relación que establecimos arriba (false or false = false, el resto es true). Ejemplo:

a = 5 -- 5 en binario es 101
b = 3 -- 3 en binario es 11

Luego se los dispone en columnas para realizar la operación a | b

1 0 1
0 1 1
------
1 1 1
 
1 | 0 (true or false) = 1 (true)
0 | 1 (false or true) = 1 (true)
1 | 1 (true or true) = 1 (true)
 
111 en base 10 es 7, por lo tanto 5 | 3 = 7

XOR: Este es un tanto especial, se llama or exclusivo y se lo representa con "^^", este operador dará como resultado true siempre y cuando los dos valores sean distintos entre sí, es decir, solamente (1 ^^ 0) y (0 ^^ 1) serán verdaderas. Ejemplo:

a = 5 -- 5 en binario es 101
b = 3 -- 3 en binario es 11

Luego se los dispone en columnas para realizar la operación a ^^ b

1 0 1
0 1 1
------
1 1 0
 
1 ^^ 0 (true xor false) = 1 (true)
0 ^^ 1 (false xor true) = 1 (true)
1 ^^ 1 (true xor true) = 0 (false)
 
110 en base 10 es 6, por lo tanto 5 ^^ 3 = 6

NOT: Not o negación en binario se lo representa con el símbolo "~", lo que hace es negar bit por bit de un número. Ejemplo:

5 en binario es 101
la operación ~5 daría 010 que sería 2 en base 10... o al menos eso creemos...

Lua trabaja con datos tipo Dword, es decir de 32 bits, por lo tanto 5 en binario para Lua no es 101, sino 0000 0000 0000 0000 0000 0000 0000 0101, entonces la negación no sería 010, sino 1111 1111 1111 1111 1111 1111 1111 1010 y eso transformado a un signed integer (entero con signo) da como resultado -6.

Shift Left: Este operador también usa operandos del tipo
number, pero con la diferencia que el 1º será tomado como binario y el
2º en base 10, a este operador se lo representa con este símbolo: "<<". Ahora, veamos que hace:

Si tenemos la operación A << B, se desplazarán los bits de A una cantidad entera B de bits a la izquierda, ejemplo:

5 << 2
5 en binario es 101, si se desplaza dos bits a la izquierda, quedaría 10100.
10100 en base 10 es 20, por lo tanto 5 << 2 = 20

Además, es rotatorio, es decir, que si yo hago:

1000 0000 0000 0000 0000 0000 0000 0000 << 1
no será 0000 0000 0000 0000 0000 0000 0000 0000
sino: 0000 0000 0000 0000 0000 0000 0000 0001

Shift Right:
Trabaja de la misma manera que el anterior, pero con la diferencia de que este desplaza una cantidad entera B de bits a la derecha. Ejemplo:

8 >> 2
8 en binario es 1000, si se desplaza 2 bits a la derecha quedaría 10.
10 en base 10 es 2, por lo tanto 8 >> 2 = 2

Al igual que el shift left, es rotatorio:

1 << 1
Y sabiendo que Lua trabaja con datos tipo Dword (32 bits), esta operación daría como resultado:
1000 0000 0000 0000 0000 0000 0000 0000
y no 0 a como se pensaría inicialmente

Eso es todo en cuanto operadores

Tutoriales realizados con la ayuda y asesoramiento de DeViaNTe

Saludos!