Atribuições e estruturas de controle em Lua

Em tutoriais anteriores, vimos como Lua permite o tratamento tanto de valores como de tipos de forma dinâmica, primando sempre pela simplicidade e versatilidade na execução destas operações.
Mas isto não é tudo Lua oferece em termos de simplicidade, ele convencionalmente suporta declarações que podemos encontrar em linguagens como em C ou PascalOnde essas declarações incluem atribuições e estruturas de controle semelhantes, podemos até tropeçar em algumas maneiras não convencionais, como atribuições múltiplas e declarações locais.
As atribuições em Lua Eles são extremamente simples e funcionam para alterar o valor de uma variável em um determinado momento dentro de nosso programa, vamos ver um exemplo simples usando o console interativo do Lua, que podemos inserir colocando a palavra reservada lua No terminal:

Como podemos ver, temos alguns exemplos simples de atribuições, alterando o valor das variáveis ​​com operações de concatenação, aritmética ou simplesmente escrevendo valores. Além disso, Lua permite múltiplas atribuições, onde uma lista de valores é atribuída a uma lista de variáveis, sempre separando essas listas com vírgulas para operação correta:

Como pudemos ver var1 obteve o valor numérico e var2 o valor do texto, este de acordo com a ordem em que a atribuição é feita. Se formos observadores, vemos como também podemos alternar os valores de ambas as variáveis, algo que é útil quando estamos trabalhando com funções.
Lua você pode até ajustar o número de valores para o número de variáveis ​​presentes, por exemplo se a lista de valores for menor que a lista de variáveis, as variáveis ​​extras recebem o tipo de valor nada por padrão como seus valores, vamos ver um exemplo desse processo:

Como podemos ver, as duas primeiras variáveis ​​recebem seus valores correspondentes e a última delas recebe automaticamente nada como explicamos. É importante mencionar que atribuições múltiplas nem sempre são mais rápidas do que atribuições simples, mas nos permitem ajudar a coletar retornos múltiplos de uma chamada de função, para citar alguns.
Além de variáveis ​​globais, Lua Ele suporta variáveis ​​locais que, ao contrário das globais, têm um escopo limitado, que depende do bloco em que foram declaradas, vejamos como declaramos uma variável local:

Como vemos a declaração dessas variáveis, nós as fazemos com a palavra reservada localEssas variáveis ​​atuam no bloco em que foram declaradas, por exemplo, podemos dizer que um bloco pode ser uma estrutura de controle ou uma função, vejamos o seguinte exemplo:

 x = 10 local i = 1 enquanto i <= x faz local x = i * 2 print (x) i = i + 1 end se i> 20 então local xx = 20 print (x + 2) else print (x) end imprimir (x) 

Se executarmos o mesmo em nosso terminal, veremos como o resultado pode não ser o que esperamos, e isso porque temos diferentes blocos nos quais usamos as variáveis, vamos ver o resultado:

Embora o controle do nosso programa possa ser limitado, podemos usar os delimitadores fim Para especificar um bloco e saber até que ponto nossas variáveis ​​locais têm escopo, vamos ver um exemplo onde podemos fazer isso:

 fazer local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 fim - Aqui termina o escopo de var1 e var2 print (x, y) print (var1, var2)

Quando o executarmos em nosso terminal, veremos que as variáveis ​​xey são mostradas sem nenhum problema porque são globais, mas para var1 e var2 seu escopo termina com o bloco fim, vamos ver:

Podemos enfatizar que o uso de variáveis ​​locais em nossos programas é uma boa prática, elas nos ajudam a não tocar no ambiente global com nomes desnecessários, também que o acesso a essas variáveis ​​é muito mais rápido do que se o fizéssemos com variáveis ​​globais e finalmente estas as variáveis ​​desaparecem assim que seu escopo termina, liberando espaço de memória, portanto, recomendamos seu uso sempre que possível.
Estruturas de controleComo o resto das linguagens de programação, Lua nos fornece um conjunto de estruturas de controle para usarmos em nossos programas, usando o conhecido E se para lidar com as condições e enquanto, repita Y para para loops iterativos, onde exceto repita que tem o terminador explícito até e os outros terminando com fim.
Como na maioria das linguagens de programação, a declaração E se verifica uma condição e executa a parte do então ou a parte de outro, onde o último pode ser opcional, vamos ver um conjunto dessas condições conforme visto em nossos programas:

 if var1 <0 then var1 = 0 end if var1 max lines then show () lines = 0 end

Aqui temos três tipos de operações, a básica com o então, usando return para retornar um valor de acordo com a condição e um trecho de código um pouco mais completo que chama uma função. Além disso, podemos escrever E se aninhado usando elseif, o que nos evita ter que usar vários termina, vamos ver como fica:

 if operation == "+" then result = a + b elseif operation == "-" then result = a - b elseif operation == "*" then result = a * b elseif operation == "/" then result = a / b else error ("operação inválida") end

É importante notar que isso não é apenas mais ideal, mas também necessário, uma vez que Lua não tem as declarações de tipo interruptor portanto, este tipo de condições aninhadas será bastante comum em nossos programas.
Como em outras línguas, Lua primeiro avalie a condição do enquanto, se a condição for falsa, o loop termina e, caso contrário, as seguintes linhas de código são executadas e o processo é repetido até que a condição seja falsa, vamos ver um exemplo simples para ilustrar isso:

 local i = 1 enquanto var1 [i] imprime (var1 [i]) i = i + 1 fim

Esta declaração, ao contrário do enquanto nos permite repetir o código dentro da condição até que seja verdadeiro, onde mesmo este código pode ser executado pelo menos uma vez já que a avaliação da condição é feita no final, vejamos um exemplo:

 repetir linha = os.read () até linha ~ = "" imprimir (linha)

Em relação aos ciclos iterativos para, Lua tem duas variantes dele, o para numérico e ele genérico para. Vejamos a sintaxe do numérico para:

 para var = exp1, exp2, exp3 do fim

Este loop irá executar algo para cada valor de var a partir de exp1 até exp2 usando exp3 como o valor para aumentar var ou diminuí-lo, se não incluí-lo Lua assume por padrão que vai um por um, vamos ver um exemplo mais detalhado desses ciclos:

 para var = 1, f (x) imprime (var) end para var2 = 10,1, -1 imprime (var2) end

Como vemos sua aplicação é bastante simples e nos permite implementar os ciclos iterativos úteis em nossos programas, agora vamos ver a sintaxe para o genérico para:

 para i, var em ipairs (array) do print (var) end

O que este ciclo faz é usar a função que ele nos dá Lua ligar ipairs, que é um iterador de matrizes, onde para cada iteração i obtém um índice, enquanto var obtém o valor associado a esse índice.
Como vemos as declarações dentro Lua Eles não diferem muito de outras linguagens, no entanto, a linguagem adiciona essa simplicidade extra para nos dar um aprendizado muito mais rápido de sua sintaxe e um uso muito mais eficaz. Com isso, terminamos este tutorial, onde aprendemos as atribuições e estruturas de controle dentro Lua, adicionando assim outra camada de conhecimento quando se trata desta linguagem simples, mas poderosa.