В предыдущих уроках мы видели, как Lua позволяет динамически управлять значениями и типами, всегда выделяясь своей простотой и универсальностью при выполнении этих операций.
Но это не все, что предлагает Lua с точки зрения простоты, он традиционно поддерживает операторы, которые мы можем найти в таких языках, как C или Pascal, где эти операторы включают в себя как присваивания, так и управляющие структуры, мы даже можем столкнуться с некоторыми нетрадиционные способы, такие как множественные присваивания и локальные объявления.
назначения
Назначения в Lua чрезвычайно просты, и они работают, чтобы изменить значение переменной в данный момент времени в нашей программе, давайте посмотрим на простой пример с использованием интерактивной консоли Lua, которую мы можем ввести, поместив зарезервированное слово lua в терминал:
Как мы видим, у нас есть несколько простых примеров присваиваний, меняющих значения переменных с помощью конкатенации, арифметических или просто перезаписывающих значений. В дополнение к этому, Lua допускает множественное присваивание, когда список значений назначается списку переменных, всегда разделяя эти списки запятыми для правильной работы:
Как мы могли видеть, var1 получил числовое значение, а var2 - текстовое значение, в соответствии с порядком, в котором выполняется присваивание. Если мы наблюдатели, мы видим, как мы можем чередовать значения обеих переменных, что очень полезно при работе с функциями.
Lua может даже настроить количество значений для количества присутствующих переменных, например, если список значений меньше, чем список переменных, дополнительные переменные получают тип значения nil по умолчанию в качестве своих значений, давайте посмотрим пример этого процесс:
Как мы видим, первые две переменные получают свои соответствующие значения, а последняя из них автоматически получает ноль, как мы объясним. Важно отметить, что множественные назначения не всегда быстрее простых, но они позволяют нам собирать несколько возвратов от вызова функции для присвоения ей имени.
Локальные переменные и блоки
В дополнение к глобальным переменным Lua поддерживает локальные переменные, которые, в отличие от глобальных, имеют ограниченную область видимости, которая зависит от блока, в котором они были объявлены, давайте посмотрим, как мы объявляем локальную переменную:
Когда мы видим объявление этих переменных, мы делаем их с помощью локального зарезервированного слова, эти переменные работают в блоке, в котором они были объявлены, например, мы можем сказать, что блок может быть управляющей структурой или функцией, давайте рассмотрим следующий пример:
x = 10 local i = 1, в то время как i <= x do local x = i * 2 print (x) i = i + 1 end, если i> 20, тогда local xx = 20 print (x + 2) else print (x) end печать (х)Если мы выполним то же самое в нашем терминале, мы увидим, что результат, возможно, не тот, который мы ожидаем, и это потому, что у нас есть разные блоки, в которых мы используем переменные, давайте посмотрим результат:
Хотя управление нашей программой может быть ограничено, мы можем использовать разделители do-end, чтобы указать блок и узнать, как далеко наши локальные переменные имеют область действия, давайте посмотрим пример, где мы можем сделать это:
do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Здесь заканчивается область действия var1 и var2 print (x, y) print (var1, var2)Выполняя его в нашем терминале, мы увидим, что переменные x и y отображаются без проблем, потому что они глобальные, но для var1 и var2 область их действия заканчивается блоком do-end, давайте посмотрим:
Мы можем подчеркнуть, что использование локальных переменных в наших программах является хорошей практикой, это помогает нам не трогать глобальную среду ненужными именами, кроме того, доступ к этим переменным намного быстрее, чем если бы мы делали это с глобальными переменными и, наконец, Эти переменные исчезают, как только их охват заканчивается, освобождая пространство памяти, поэтому мы рекомендуем их использовать по мере возможности.
Управляющие структуры
Как и остальные языки программирования, Lua предоставляет нам набор управляющих структур для использования в наших программах, используя известные if для обработки условий и while, repeat и for для итерационных циклов, за исключением повтора, который имеет явный терминатор до, а остальные заканчиваются на конец .
Если, то и еще
Как и в большинстве языков программирования , оператор if проверяет условие и выполняет часть then или часть else, где последнее может быть необязательным, давайте рассмотрим набор этих условий, как видно из наших программ:
если var1 <0, тогда var1 = 0 end, если var1 maxlines, тогда show () lines = 0 endЗдесь у нас есть три типа операций, основной с тогдашним, с использованием return для возврата значения в соответствии с условием и немного более полной части кода, которая вызывает функцию. В дополнение к этому мы можем написать, если вложенный, используя elseif, что не позволяет нам использовать несколько концов, давайте посмотрим, как это выглядит:
если операция == "+", то результат = a + b elseif операция == "-" затем result = a - b elseif операция == "*" тогда result = a * b elseif операция == "/" затем result = a / b else error («Операция неверна») конецВажно отметить, что это не только более оптимально, но и необходимо, поскольку Lua не имеет объявлений типов переключателей, так что этот тип вложенных условий будет довольно распространен в наших программах.
Пока цикл
Как и в других языках, Lua сначала оценивает условие while, если условие ложно, цикл заканчивается, и в противном случае выполняются следующие строки кода, и процесс повторяется до тех пор, пока условие не становится ложным, давайте рассмотрим простой пример для проиллюстрируем это:
local i = 1, а var1 [i] печатает (var1 [i]) i = i + 1 end
Повторить цикл
Это объявление, в отличие от while, позволяет нам повторять код в условии до тех пор, пока оно не станет истинным, где даже этот код может быть выполнен хотя бы один раз, так как оценка условия выполнена в конце, давайте посмотрим пример:
повторение строки = os.read () до строки ~ = "" print (line)
Для числового и общего
Что касается итерационных циклов для, у Lua есть два варианта: числовой для и общий для . Давайте посмотрим на синтаксис числовой для:
для var = exp1, exp2, exp3 do endЭтот цикл будет выполнять что-то для каждого значения var от exp1 до exp2, используя exp3 в качестве значения, чтобы увеличить его или уменьшить его, если мы не включим его, Lua по умолчанию предполагает, что он идет один за другим, давайте рассмотрим более подробный пример этих циклов:
для var = 1, f (x) do print (var) end для var2 = 10, 1, -1 do print (var2) endПоскольку мы видим, что его применение довольно простое и позволяет нам реализовывать полезные итеративные циклы в наших программах, давайте теперь посмотрим на синтаксис универсального выражения для :
для i, var в ipairs (расположение) сделать print (var) endЭтот цикл использует функцию, которую Lua дает нам, и называется ipairs, которая является итератором соглашений, где для каждой итерации я выбираю индекс, а var получает значение, связанное с этим индексом.
Как мы видим, операторы в Lua не сильно отличаются от других языков, однако язык добавляет эту дополнительную простоту, чтобы дать нам гораздо более быстрое изучение его синтаксиса и гораздо более эффективное использование. На этом мы завершаем этот урок, где мы изучили назначения и структуры управления в Lua, тем самым добавив еще один уровень знаний в отношении этого простого, но мощного языка.
СТАТЬИ