Lua/Конструкции языка

← Типы данных	Глава	Функции →
Конструкции языка

Условные конструкции[править]

Часто нам нужно будет использовать условия в коде - мы их называем условными выражениями. Для их создания используют ключевые слова if(если), then(тогда), else(иначе), elseif. Пример:

a = 15
b = 14.7 
-- Если а больше b, то добавим к b единицу, иначе, отнимем единицу:
if a > b then
    b = b + 1
else 
    b = b -1
end

Можно записать эту конструкцию кратко, но лучше так не делать - ухудшается читаемость вашего кода:

if a > b then b = b +1 else b = b -1 end

Но что, если мы хотим проверить еще, сделать еще условия? Используем elseif:

a = 3
b = 4
c = 5
if c > a then
    print("с больше а")
elseif c > b then
    print("с больше b")
else
    print("с - не самое большое")
end

Циклы[править]

Циклы часто оказываются незаменимыми в случаях, когда нужно повторять некоторый блок кода несколько раз. Итераторы, которые мы рассмотрели ранее, является частным случаем циклов: итератор "обходит" массив (работает последовательно с каждым его элементом) и во многих языках является сокращенной формой для цикла.

Цикл работает по достаточно простому принципу: операции выполняются из раза в раз, пока условие не станет ложным. С точки зрения логических операций, цикл выполняется, когда условие является true и прекращается, когда false.

while[править]

Первый представитель - цикл while. Его можно интерпретировать как "Пока условие истинное делать (инструкции) закончить"

i = 0
while true do
    print("Манул",i) --> Манул + число проходок цикла 
    i = i + 1  --> число проходок
    end

Данный цикл будет выполняться бесконечно долго, так как условие всегда будет истинным (у нас стоит true, но вместо этого может быть любое другое условие)

repeat-until[править]

Второй представитель - repeat-until. Он пытается выполнить заданный код (который должен находится в блоке repeat), пока условие не станет истинным:

-- Считаем манулов
manul = 0 --> сначала было 0 манулов
repeat
    manul = manul + 1 --> начинаем считать манулов по одному
until manul == 1000 --> если мануов стало 1000 - закончить цикл 
print(manul) --> 1000

break[править]

Break - не является циклом. Он останавливает его выполнение.

a = 0
while True do
    a = a + 1 --> Каждое выполнение цикла увеличивает а на единицу
    if a == 13 then --> но когда a достигает 13 - цикл заканчивает свое выполнение
        break 
    end
end

Как вы видите, чаще всего break используют с условным выражением.

Итераторы[править]

В прошлой главе мы рассматривали такой тип как table. Задавать ключи/значения достаточно долгая ручная работа. Автоматизировать эту работу можно при помощи итераторов.

И так, попробуем наполнить нашу таблицу 100 элементов, ключ которых, равен значению.

a = {} -- создали пустой массив 
for i = 1,100 do a[i] = i end -- добавили 100 элементов

Немного непонятная конструкция, верно? Давайте разберем в ней каждое слово, каждый символ:

for(для) конструкция, после которой следует количество элементов с которыми мы будем работать
i = 1,100 (переменной i от 1 до 100)
do (сделать) конструкция, после которой говорится, что мы будем делать с конструкцией
a[i] = i каждому a[i] с ключом i присвоить значение i (фактически, это создание элемента массива)
end(конец) указывает на то, что конструкция должны быть закрыта.
А теперь все вместе: для переменной i от 1 до 100 сделать так, чтобы каждому a[i] был присвоен i и закончить конструкцию

Если вы ранее программировали на других языках, то вам привычнее будет такая конструкция:

for i = 1,100 do
    a[i] = i
end

Мы бы рекомендовали использовать именно ее. Между for и do, можно поставить не только индекс начала и конца массива, но и шаг с которым будет идти процесс итерации. Это часто называют в других языках как start,stop,step (начало, конец, шаг) и в других языках эта конструкция аналогична. Например:

for i = 1,100,2 do --> start= 1, stop=100, step = 2 
    a[i] = i --> 1,3,5,7 и т.д.
end

Мы создали массив и, предположим, забыли, что в него добавили и какая его длина. Давайте посмотрим на элементы массива:

for i = 1,#a do
    print(a[i])
end
--> выводит 100 элементов

Напомним, что #a - длина массива (в нашем случае, она равна 100)

Можно также перебирать ключи одновременно со значениями:

a = {'a' = 1,'b' = 2;'c' = 3}
for k,v in pairs(a) do
    print(k,v)
end

Goto[править]

В Lua существует оператор goto. Он позволяет перепрыгивать в отдельные участки кода, например, выпрыгнуть из цикла в итератор где-то снаружи.

Вы не часто встретите в других языках данный оператор и этому есть разумное объяснение: goto часто приводит к ухудшению читаемости кода, создать непредвиденные ситуации для программиста и многое другое. Именно поэтому мы, как и разработчики языка, рекомендуем его использовать ограниченно и обдуманно.

Также, есть 3 ограничения:

Нельзя прыгнуть внутрь блока
Нельзя выпрыгнуть из функции
Нельзя прыгнуть внутрь области видимости локальной переменной

← Типы данных

Функции →