Operadores e seus diferentes tipos.

and.lua

--[[ O operador and retorna seu primeiro argumento se este 
primeiro argumento é false ou nil; caso contrário, ele 
retornará o segundo argumento.
]]

print( false and true ) -- false é retornado porque ele é o primeiro argumento

print( nil and "Lua", false and "Lua" )


--[[ Todas as seguintes expressões retornam o 
segundo argumento, pois o primeiro é true.
]]

print( true and false )

print( true and true )

caveat.lua

-- Falha estrutural: Só funciona se o primeiro argumento retornar not , nil ou false.

-- certo
print( 3>1 and 1 or "False" )       

-- falha, deve retornar falso, Output : oops
print( 3>1 and false or "oops" )     

-- falha, deve retornar nil Output : oops
print( 3>1 and nil or "oops" )

code misc concat.lua

-- Utilizando concatenação ..

print(5..6)
print("122" + 3)
print("122" .. 3)
print("12" + "23")
print(12 .. 23)
	

a = "Engenharia"
print(a .. " Quimica")   
print(a)                

nome = "Francisco"
sobrenome = "Beltrão"

print(nome..sobrenome)

print("Francisco ".."Beltrão")


	

code op relacionais.lua

print( 1 == 1, 1 == 0 ) 

print( 1 ~= 1, 1 ~= 0 )

print( true ~= false ) 

x = true
print(x)
print(not x)

print( 3 < 7, 7 < 7, 8 < 7 ) 

print( 3 >= 7, 7 >= 7, 8 >= 7 ) 

print(100 == "100")

print( "abc" == "abc" ) 

print('abc'..'123' == 'abc123')

code operador tamanho.md

O operador # para comprimento

Utilize # para saber a quantidade de caracteres da string (string length)

Exemplo 1:

print(#"Francisco Beltrão")

Exemplo 2:

p = 84
print(#p)
~~

code precedencia.lua

--[[ Exercício de Fixação

Atribua valores as variáveis e imprima seus resultados.
]]

a+i < b/2+1
5+x^2*8
a < y and y <= z
-x^2
x^y^z
n*(2-8.3)/77.7+99.1

code ternario.lua

print( 3>1 and 1 or 0 )

print( 3<1 and 1 or 0 )

print( 3<1 and "True" or "False" )

print( 3>1 and true or "false" )

coercao.lua

-- Força a transformação de um tipo em outro tipo

print( "10" == 10 )
print( tonumber("10") == 10 )
print("2" + "2")

print (“10” + 1)  
print (“10 + 1”)  
print (“- 3.3e-10” * ”2”)  
print (“oi” + 1)            -->> ERROR (cannot convert “oi”)”

comprim.lua

print(#"")      -->> 0
print(#"!")     -->> 1
print(#"\n")    -->> 1
print(#"abcd")  -->> 4

frasefeita = "vejo voce na prox aula"
print(#frasefeita) 

expressoes aritmeticas.lua

-- Exemplo do uso de operadores aritméticos

print( 2+3, 5-12, 2*7, 7/8 )

-- Exemplo do uso de operadores aritméticos com função
a=12
b=5
print( a % b == a - math.floor(a/b)*b )
 
--[[ A função math.floor(x) retorna o menor número inteiro 
dentre o número "x". Veremos outras funções no Lua 5.
]]

intro.md

Operadores

Sobre Operadores e seus diferentes tipos.

1. Aritméticos
2. Relacionais
3. Lógicos
4. Mesclados (Misc)
5. Ternário (fake)

modulo.lua

-- obter o resto da divisão da expressão

print( 15%7, -4%3, 5.5%1 )

negacao.lua

-- aqui, exemplificamos um atributo de negação ao positivo da segunda expressão

print( -(-10), -(10) )

not.lua

-- O operador lógico not inverte o valor de expressão lógica

print(not nil)      
print(not false)     
print(not 0)         
print(not not nil)
print( true, false, not true, not false )
print( not not true ) 

or.lua

-- O operador or retorna seu primeiro argumento se não for falso

print( true or false )

print( true or nil )

print( "olá" or "até logo", 1 or 0 )


-- caso contrário, ele retornará seu segundo argumento.

print( false or true )

print( nil or true )

print( nil or "Lua" )

potencia.lua

-- levar a um número a sua potência

print( 7^2, 107^0, 2^8 )

precedencia exemplo.md

Exemplos de Prioridades

A esquerda temos expressões com construção madura. Já a direita, temos as equivalentes, apresentadas para quem inicia na programação Lua.

    a+i < b/2+1          -->>       (a+i) < ((b/2)+1)
    5+x^2*8              -->>       5+((x^2)*8)
    a < y and y <= z     -->>       (a < y) and (y <= z)
    -x^2                 -->>       -(x^2)
    x^y^z                -->>       x^(y^z)

precedencia.md

Precedência dos operadores

Prioridade da mais alta (topo) à mais baixa (base):

   ^
   not   #     - (unário)
   *     /     %
   +   -
   ..
   <   >   <=  >=  ~=  ==  
   and    or               

rev2.lua

valor = 5
termo1 = "gas"
termo2 = " toxico"

print(valor > 5 and #(termo1 .. termo2) <= 20)

print(termo1 > termo2 and termo1 .. termo2 or termo2 .. termo1) 

revisao op lgicos.lua

print(4 and 5)         
print(nil and 13)      
print(false and 13)    
print(4 or 5)          
print(false or 5)      
print(true and false or not false and not true)
print( (true and false) or ((not false) and (not true)) )

print(10 or 20)            --> 10
print(10 or error())       --> 10
print(nil or "a")          --> "a"
print(nil and 10)          --> nil
print(false and error())   --> false
print(false and nil)       --> false
print(false or nil)        --> nil
print(10 and 20 )          --> 20

revs relacionais.lua

print("abc" < "def")
print("abc" > "def")
print("abb" < "baa")
print("abc" == "abc")
print("abc" == "a".."bc")

sec misc operador.md

Operadores Miscelaneos

Esta miscelânea de operadores os recursos de:

Concatenar strings

a .. b 

Retorna o comprimento da string

#var

Aqui, exemplificamos que var é uma variável com algum conteúdo, por exemplo literal e que # será o responsável por contar o comprimento desta string.

Coerção

"11" + 4

Basicamente, a coerção força uma transformação de um tipo em outro tipo. Neste exemplo acima, embora 11 seja literal pois está entre aspas, Lua entende que 11 pode ser utilizado em uma expressão do tipo +. Assim Lua transforma literal "11" internamente em 11 e soma a 4. Lindo!

sec operadores aritmeticos.md

Operadores aritméticos

Tipos binário:

  + (adição)
  - (subtração)
  * (multiplicação)
  / (divisão) 	
  % (módulo)
  ^ (exponenciação) 	 

Tipo unário:

  - (negação)

sec operadores logicos.md

Operadores lógicos: Precedência

not
and
or 

Similar aos operadores:

not   -
and   *
or    +

not a    -- (qualquer valor) true se a eh false
a and b  -- (qualquer valor) true se ambos a e b sao true
a or b   -- (qualquer valor) true se a ou b ou ambos sao true

"short-circuited" logic

a and b -- (qualquer valor) b se a eh true, caso contrario a
a or b  -- (qualquer valor) a se a eh true, caso contrario b

-- exemplo dica futura para table: atribua a para uma tabela vazia 
-- se a nao estah definida
-- "a or {}" serah {}.
a = a or {}

sec operadores relacionais.md

Operadores Relacionais

Operadores relacionais retornam valores booleanos true ou false.

== 	igual a
~= 	diferente de
< 	menor que
> 	maior que
<= 	menor ou igual a
>= 	maior ou igual a 

Observe que para atribuir valor à variável você usa um único sinal de igual ( = ), mas para comparação, você usa um sinal de igual duplo ( == ).

a > b  -- (numero e numero) true se a eh maior que b
a < b  -- (numero e numero) true se a eh menor que b

a >= b -- (numero e numero) true se a eh maior ou igual a b
a <= b -- (numero e numero) true se a eh menor ou igual a b

a == b -- (qualquer tipo) true se a e b sao os mesmos objetos, ou ou igual
a ~= b -- (qualquer tipo) true se a e b não são os mesmos objetos, ou igual

ternariofake.md

Ternário

Embora Lua não tenha operador ternario, podemos simular este comportamento limitador: das três, a do meio deve ser valor true

valor = condicao and valortrue or valorfalse

valor = (condicao and valortrue) or valorfalse

Basicamente significa que dada uma condição, se esta condição for verdadeira, então valortrue é executado, caso contrário teremos valorfalse executado.